s202226701001/sever-test/node_modules/parse-server/lib/Adapters/Auth/AuthAdapter.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.AuthAdapter = void 0;
/*eslint no-unused-vars: "off"*/

/**
 * @interface ParseAuthResponse
 * @property {Boolean} [doNotSave] If true, Parse Server will not save provided authData.
 * @property {Object} [response] If set, Parse Server will send the provided response to the client under authDataResponse
 * @property {Object} [save] If set, Parse Server will save the object provided into this key, instead of client provided authData
 */

/**
 * AuthPolicy
 * default: can be combined with ONE additional auth provider if additional configured on user
 * additional: could be only used with a default policy auth provider
 * solo: Will ignore ALL additional providers if additional configured on user
 * @typedef {"default" | "additional" | "solo"} AuthPolicy
 */

class AuthAdapter {
  constructor() {
    /**
     * Usage policy
     * @type {AuthPolicy}
     */
    if (!this.policy) {
      this.policy = 'default';
    }
  }
  /**
   * @param appIds The specified app IDs in the configuration
   * @param {Object} authData The client provided authData
   * @param {Object} options additional adapter options
   * @param {Parse.Cloud.TriggerRequest} request
   * @returns {(Promise<undefined|void>|void|undefined)} resolves or returns if the applicationId is valid
   */
  validateAppId(appIds, authData, options, request) {
    return Promise.resolve({});
  }

  /**
   * Legacy usage, if provided it will be triggered when authData related to this provider is touched (signup/update/login)
   * otherwise you should implement validateSetup, validateLogin and validateUpdate
   * @param {Object} authData The client provided authData
   * @param {Parse.Cloud.TriggerRequest} request
   * @param {Object} options additional adapter options
   * @returns {Promise<ParseAuthResponse|void|undefined>}
   */
  validateAuthData(authData, request, options) {
    return Promise.resolve({});
  }

  /**
   * Triggered when user provide for the first time this auth provider
   * could be a register or the user adding a new auth service
   * @param {Object} authData The client provided authData
   * @param {Parse.Cloud.TriggerRequest} request
   * @param {Object} options additional adapter options
   * @returns {Promise<ParseAuthResponse|void|undefined>}
   */
  validateSetUp(authData, req, options) {
    return Promise.resolve({});
  }

  /**
   * Triggered when user provide authData related to this provider
   * The user is not logged in and has already set this provider before
   * @param {Object} authData The client provided authData
   * @param {Parse.Cloud.TriggerRequest} request
   * @param {Object} options additional adapter options
   * @returns {Promise<ParseAuthResponse|void|undefined>}
   */
  validateLogin(authData, req, options) {
    return Promise.resolve({});
  }

  /**
   * Triggered when user provide authData related to this provider
   * the user is logged in and has already set this provider before
   * @param {Object} authData The client provided authData
   * @param {Object} options additional adapter options
   * @param {Parse.Cloud.TriggerRequest} request
   * @returns {Promise<ParseAuthResponse|void|undefined>}
   */
  validateUpdate(authData, req, options) {
    return Promise.resolve({});
  }

  /**
   * Triggered in pre authentication process if needed (like webauthn, SMS OTP)
   * @param {Object} challengeData Data provided by the client
   * @param {(Object|undefined)} authData Auth data provided by the client, can be used for validation
   * @param {Object} options additional adapter options
   * @param {Parse.Cloud.TriggerRequest} request
   * @returns {Promise<Object>} A promise that resolves, resolved value will be added to challenge response under challenge key
   */
  challenge(challengeData, authData, options, request) {
    return Promise.resolve({});
  }

  /**
   * Triggered when auth data is fetched
   * @param {Object} authData authData
   * @param {Object} options additional adapter options
   * @returns {Promise<Object>} Any overrides required to authData
   */
  afterFind(authData, options) {
    return Promise.resolve({});
  }

  /**
   * Triggered when the adapter is first attached to Parse Server
   * @param {Object} options Adapter Options
   */
  validateOptions(options) {
    /* */
  }
}
exports.AuthAdapter = AuthAdapter;
var _default = exports.default = AuthAdapter;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["AuthAdapter","constructor","policy","validateAppId","appIds","authData","options","request","Promise","resolve","validateAuthData","validateSetUp","req","validateLogin","validateUpdate","challenge","challengeData","afterFind","validateOptions","exports","_default","default"],"sources":["../../../src/Adapters/Auth/AuthAdapter.js"],"sourcesContent":["/*eslint no-unused-vars: \"off\"*/\n\n/**\n * @interface ParseAuthResponse\n * @property {Boolean} [doNotSave] If true, Parse Server will not save provided authData.\n * @property {Object} [response] If set, Parse Server will send the provided response to the client under authDataResponse\n * @property {Object} [save] If set, Parse Server will save the object provided into this key, instead of client provided authData\n */\n\n/**\n * AuthPolicy\n * default: can be combined with ONE additional auth provider if additional configured on user\n * additional: could be only used with a default policy auth provider\n * solo: Will ignore ALL additional providers if additional configured on user\n * @typedef {\"default\" | \"additional\" | \"solo\"} AuthPolicy\n */\n\nexport class AuthAdapter {\n  constructor() {\n    /**\n     * Usage policy\n     * @type {AuthPolicy}\n     */\n    if (!this.policy) {\n      this.policy = 'default';\n    }\n  }\n  /**\n   * @param appIds The specified app IDs in the configuration\n   * @param {Object} authData The client provided authData\n   * @param {Object} options additional adapter options\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {(Promise<undefined|void>|void|undefined)} resolves or returns if the applicationId is valid\n   */\n  validateAppId(appIds, authData, options, request) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Legacy usage, if provided it will be triggered when authData related to this provider is touched (signup/update/login)\n   * otherwise you should implement validateSetup, validateLogin and validateUpdate\n   * @param {Object} authData The client provided authData\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @param {Object} options additional adapter options\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateAuthData(authData, request, options) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered when user provide for the first time this auth provider\n   * could be a register or the user adding a new auth service\n   * @param {Object} authData The client provided authData\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @param {Object} options additional adapter options\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateSetUp(authData, req, options) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered when user provide authData related to this provider\n   * The user is not logged in and has already set this provider before\n   * @param {Object} authData The client provided authData\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @param {Object} options additional adapter options\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateLogin(authData, req, options) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered when user provide authData related to this provider\n   * the user is logged in and has already set this provider before\n   * @param {Object} authData The client provided authData\n   * @param {Object} options additional adapter options\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateUpdate(authData, req, options) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered in pre authentication process if needed (like webauthn, SMS OTP)\n   * @param {Object} challengeData Data provided by the client\n   * @param {(Object|undefined)} authData Auth data provided by the client, can be used for validation\n   * @param {Object} options additional adapter options\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {Promise<Object>} A promise that resolves, resolved value will be added to challenge response under challenge key\n   */\n  challenge(challengeData, authData, options, request) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered when auth data is fetched\n   * @param {Object} authData authData\n   * @param {Object} options additional adapter options\n   * @returns {Promise<Object>} Any overrides required to authData\n   */\n  afterFind(authData, options) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered when the adapter is first attached to Parse Server\n   * @param {Object} options Adapter Options\n   */\n  validateOptions(options) {\n    /* */\n  }\n}\n\nexport default AuthAdapter;\n"],"mappings":";;;;;;AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,MAAMA,WAAW,CAAC;EACvBC,WAAWA,CAAA,EAAG;IACZ;AACJ;AACA;AACA;IACI,IAAI,CAAC,IAAI,CAACC,MAAM,EAAE;MAChB,IAAI,CAACA,MAAM,GAAG,SAAS;IACzB;EACF;EACA;AACF;AACA;AACA;AACA;AACA;AACA;EACEC,aAAaA,CAACC,MAAM,EAAEC,QAAQ,EAAEC,OAAO,EAAEC,OAAO,EAAE;IAChD,OAAOC,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,gBAAgBA,CAACL,QAAQ,EAAEE,OAAO,EAAED,OAAO,EAAE;IAC3C,OAAOE,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,aAAaA,CAACN,QAAQ,EAAEO,GAAG,EAAEN,OAAO,EAAE;IACpC,OAAOE,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEI,aAAaA,CAACR,QAAQ,EAAEO,GAAG,EAAEN,OAAO,EAAE;IACpC,OAAOE,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEK,cAAcA,CAACT,QAAQ,EAAEO,GAAG,EAAEN,OAAO,EAAE;IACrC,OAAOE,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEM,SAASA,CAACC,aAAa,EAAEX,QAAQ,EAAEC,OAAO,EAAEC,OAAO,EAAE;IACnD,OAAOC,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEQ,SAASA,CAACZ,QAAQ,EAAEC,OAAO,EAAE;IAC3B,OAAOE,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;EACES,eAAeA,CAACZ,OAAO,EAAE;IACvB;EAAA;AAEJ;AAACa,OAAA,CAAAnB,WAAA,GAAAA,WAAA;AAAA,IAAAoB,QAAA,GAAAD,OAAA,CAAAE,OAAA,GAEcrB,WAAW","ignoreList":[]}