@beiguancyc/parse-server 9.9.0-ruixiang.1

package/bin/parse-live-query-server

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/cli/parse-live-query-server");

package/bin/parse-server

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/cli/parse-server");

package/lib/AccountLockout.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AccountLockout = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// This class handles the Account Lockout Policy settings.
+
+class AccountLockout {
+  constructor(user, config) {
+    this._user = user;
+    this._config = config;
+  }
+
+  /**
+   * set _failed_login_count to value
+   */
+  _setFailedLoginCount(value) {
+    const query = {
+      username: this._user.username
+    };
+    const updateFields = {
+      _failed_login_count: value
+    };
+    return this._config.database.update('_User', query, updateFields);
+  }
+
+  /**
+   * increment _failed_login_count by 1 and return the updated document
+   */
+  _incrementFailedLoginCount() {
+    const query = {
+      username: this._user.username
+    };
+    const updateFields = {
+      _failed_login_count: {
+        __op: 'Increment',
+        amount: 1
+      }
+    };
+    return this._config.database.update('_User', query, updateFields);
+  }
+
+  /**
+   * if the failed login count is greater than the threshold
+   * then sets lockout expiration to 'currenttime + accountPolicy.duration', i.e., account is locked out for the next 'accountPolicy.duration' minutes
+   * else do nothing
+   */
+  _setLockoutExpiration() {
+    const query = {
+      username: this._user.username,
+      _failed_login_count: {
+        $gte: this._config.accountLockout.threshold
+      }
+    };
+    const now = new Date();
+    const updateFields = {
+      _account_lockout_expires_at: _node.default._encode(new Date(now.getTime() + this._config.accountLockout.duration * 60 * 1000))
+    };
+    return this._config.database.update('_User', query, updateFields).catch(err => {
+      if (err && err.code && err.message && err.code === _node.default.Error.OBJECT_NOT_FOUND && err.message === 'Object not found.') {
+        return; // nothing to update so we are good
+      } else {
+        throw err; // unknown error
+      }
+    });
+  }
+
+  /**
+   * if _account_lockout_expires_at > current_time and _failed_login_count > threshold
+   *   reject with account locked error
+   * else
+   *   resolve
+   */
+  _notLocked() {
+    const query = {
+      username: this._user.username,
+      _account_lockout_expires_at: {
+        $gt: _node.default._encode(new Date())
+      },
+      _failed_login_count: {
+        $gte: this._config.accountLockout.threshold
+      }
+    };
+    return this._config.database.find('_User', query).then(users => {
+      if (Array.isArray(users) && users.length > 0) {
+        throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Your account is locked due to multiple failed login attempts. Please try again after ' + this._config.accountLockout.duration + ' minute(s)');
+      }
+    });
+  }
+
+  /**
+   * Atomically increment _failed_login_count and enforce lockout threshold.
+   * Uses the atomic increment result to determine the exact post-increment
+   * count, eliminating the TOCTOU race between checking and updating.
+   */
+  _handleFailedLoginAttempt() {
+    return this._incrementFailedLoginCount().then(result => {
+      const count = result._failed_login_count;
+      if (count >= this._config.accountLockout.threshold) {
+        return this._setLockoutExpiration().then(() => {
+          if (count > this._config.accountLockout.threshold) {
+            throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Your account is locked due to multiple failed login attempts. Please try again after ' + this._config.accountLockout.duration + ' minute(s)');
+          }
+        });
+      }
+    });
+  }
+
+  /**
+   * handle login attempt if the Account Lockout Policy is enabled
+   */
+  handleLoginAttempt(loginSuccessful) {
+    if (!this._config.accountLockout) {
+      return Promise.resolve();
+    }
+    return this._notLocked().then(() => {
+      if (loginSuccessful) {
+        return this._setFailedLoginCount(0);
+      } else {
+        return this._handleFailedLoginAttempt();
+      }
+    });
+  }
+
+  /**
+   * Removes the account lockout.
+   */
+  unlockAccount() {
+    if (!this._config.accountLockout || !this._config.accountLockout.unlockOnPasswordReset) {
+      return Promise.resolve();
+    }
+    return this._config.database.update('_User', {
+      username: this._user.username
+    }, {
+      _failed_login_count: {
+        __op: 'Delete'
+      },
+      _account_lockout_expires_at: {
+        __op: 'Delete'
+      }
+    });
+  }
+}
+exports.AccountLockout = AccountLockout;
+var _default = exports.default = AccountLockout;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","e","__esModule","default","AccountLockout","constructor","user","config","_user","_config","_setFailedLoginCount","value","query","username","updateFields","_failed_login_count","database","update","_incrementFailedLoginCount","__op","amount","_setLockoutExpiration","$gte","accountLockout","threshold","now","Date","_account_lockout_expires_at","Parse","_encode","getTime","duration","catch","err","code","message","Error","OBJECT_NOT_FOUND","_notLocked","$gt","find","then","users","Array","isArray","length","_handleFailedLoginAttempt","result","count","handleLoginAttempt","loginSuccessful","Promise","resolve","unlockAccount","unlockOnPasswordReset","exports","_default"],"sources":["../src/AccountLockout.js"],"sourcesContent":["// This class handles the Account Lockout Policy settings.\nimport Parse from 'parse/node';\n\nexport class AccountLockout {\n  constructor(user, config) {\n    this._user = user;\n    this._config = config;\n  }\n\n  /**\n   * set _failed_login_count to value\n   */\n  _setFailedLoginCount(value) {\n    const query = {\n      username: this._user.username,\n    };\n\n    const updateFields = {\n      _failed_login_count: value,\n    };\n\n    return this._config.database.update('_User', query, updateFields);\n  }\n\n  /**\n   * increment _failed_login_count by 1 and return the updated document\n   */\n  _incrementFailedLoginCount() {\n    const query = {\n      username: this._user.username,\n    };\n\n    const updateFields = {\n      _failed_login_count: { __op: 'Increment', amount: 1 },\n    };\n\n    return this._config.database.update('_User', query, updateFields);\n  }\n\n  /**\n   * if the failed login count is greater than the threshold\n   * then sets lockout expiration to 'currenttime + accountPolicy.duration', i.e., account is locked out for the next 'accountPolicy.duration' minutes\n   * else do nothing\n   */\n  _setLockoutExpiration() {\n    const query = {\n      username: this._user.username,\n      _failed_login_count: { $gte: this._config.accountLockout.threshold },\n    };\n\n    const now = new Date();\n\n    const updateFields = {\n      _account_lockout_expires_at: Parse._encode(\n        new Date(now.getTime() + this._config.accountLockout.duration * 60 * 1000)\n      ),\n    };\n\n    return this._config.database.update('_User', query, updateFields).catch(err => {\n      if (\n        err &&\n        err.code &&\n        err.message &&\n        err.code === Parse.Error.OBJECT_NOT_FOUND &&\n        err.message === 'Object not found.'\n      ) {\n        return; // nothing to update so we are good\n      } else {\n        throw err; // unknown error\n      }\n    });\n  }\n\n  /**\n   * if _account_lockout_expires_at > current_time and _failed_login_count > threshold\n   *   reject with account locked error\n   * else\n   *   resolve\n   */\n  _notLocked() {\n    const query = {\n      username: this._user.username,\n      _account_lockout_expires_at: { $gt: Parse._encode(new Date()) },\n      _failed_login_count: { $gte: this._config.accountLockout.threshold },\n    };\n\n    return this._config.database.find('_User', query).then(users => {\n      if (Array.isArray(users) && users.length > 0) {\n        throw new Parse.Error(\n          Parse.Error.OBJECT_NOT_FOUND,\n          'Your account is locked due to multiple failed login attempts. Please try again after ' +\n            this._config.accountLockout.duration +\n            ' minute(s)'\n        );\n      }\n    });\n  }\n\n  /**\n   * Atomically increment _failed_login_count and enforce lockout threshold.\n   * Uses the atomic increment result to determine the exact post-increment\n   * count, eliminating the TOCTOU race between checking and updating.\n   */\n  _handleFailedLoginAttempt() {\n    return this._incrementFailedLoginCount().then(result => {\n      const count = result._failed_login_count;\n      if (count >= this._config.accountLockout.threshold) {\n        return this._setLockoutExpiration().then(() => {\n          if (count > this._config.accountLockout.threshold) {\n            throw new Parse.Error(\n              Parse.Error.OBJECT_NOT_FOUND,\n              'Your account is locked due to multiple failed login attempts. Please try again after ' +\n                this._config.accountLockout.duration +\n                ' minute(s)'\n            );\n          }\n        });\n      }\n    });\n  }\n\n  /**\n   * handle login attempt if the Account Lockout Policy is enabled\n   */\n  handleLoginAttempt(loginSuccessful) {\n    if (!this._config.accountLockout) {\n      return Promise.resolve();\n    }\n    return this._notLocked().then(() => {\n      if (loginSuccessful) {\n        return this._setFailedLoginCount(0);\n      } else {\n        return this._handleFailedLoginAttempt();\n      }\n    });\n  }\n\n  /**\n   * Removes the account lockout.\n   */\n  unlockAccount() {\n    if (!this._config.accountLockout || !this._config.accountLockout.unlockOnPasswordReset) {\n      return Promise.resolve();\n    }\n    return this._config.database.update(\n      '_User',\n      { username: this._user.username },\n      {\n        _failed_login_count: { __op: 'Delete' },\n        _account_lockout_expires_at: { __op: 'Delete' },\n      }\n    );\n  }\n}\n\nexport default AccountLockout;\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/AdapterLoader.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.loadAdapter = loadAdapter;
+exports.loadModule = loadModule;
+/**
+ * @module AdapterLoader
+ */
+/**
+ * @static
+ * Attempt to load an adapter or fallback to the default.
+ * @param {Adapter} adapter an adapter
+ * @param {Adapter} defaultAdapter the default adapter to load
+ * @param {any} options options to pass to the contstructor
+ * @returns {Object} the loaded adapter
+ */
+function loadAdapter(adapter, defaultAdapter, options) {
+  if (!adapter) {
+    if (!defaultAdapter) {
+      return options;
+    }
+    // Load from the default adapter when no adapter is set
+    return loadAdapter(defaultAdapter, undefined, options);
+  } else if (typeof adapter === 'function') {
+    try {
+      return adapter(options);
+    } catch (e) {
+      if (e.name === 'TypeError') {
+        var Adapter = adapter;
+        return new Adapter(options);
+      } else {
+        throw e;
+      }
+    }
+  } else if (typeof adapter === 'string') {
+    adapter = require(adapter);
+    // If it's define as a module, get the default
+    if (adapter.default) {
+      adapter = adapter.default;
+    }
+    return loadAdapter(adapter, undefined, options);
+  } else if (adapter.module) {
+    return loadAdapter(adapter.module, undefined, adapter.options);
+  } else if (adapter.class) {
+    return loadAdapter(adapter.class, undefined, adapter.options);
+  } else if (adapter.adapter) {
+    return loadAdapter(adapter.adapter, undefined, adapter.options);
+  }
+  // return the adapter as provided
+  return adapter;
+}
+async function loadModule(modulePath) {
+  const module = await import(modulePath);
+  return module?.default || module;
+}
+var _default = exports.default = loadAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Analytics/AnalyticsAdapter.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AnalyticsAdapter = void 0;
+/* eslint-disable unused-imports/no-unused-vars */
+/**
+ * @interface AnalyticsAdapter
+ * @module Adapters
+ */
+class AnalyticsAdapter {
+  /**
+  @param {any} parameters: the analytics request body, analytics info will be in the dimensions property
+  @param {Request} req: the original http request
+   */
+  appOpened(parameters, req) {
+    return Promise.resolve({});
+  }
+
+  /**
+  @param {String} eventName: the name of the custom eventName
+  @param {any} parameters: the analytics request body, analytics info will be in the dimensions property
+  @param {Request} req: the original http request
+   */
+  trackEvent(eventName, parameters, req) {
+    return Promise.resolve({});
+  }
+}
+exports.AnalyticsAdapter = AnalyticsAdapter;
+var _default = exports.default = AnalyticsAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJBbmFseXRpY3NBZGFwdGVyIiwiYXBwT3BlbmVkIiwicGFyYW1ldGVycyIsInJlcSIsIlByb21pc2UiLCJyZXNvbHZlIiwidHJhY2tFdmVudCIsImV2ZW50TmFtZSIsImV4cG9ydHMiLCJfZGVmYXVsdCIsImRlZmF1bHQiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvQWRhcHRlcnMvQW5hbHl0aWNzL0FuYWx5dGljc0FkYXB0ZXIuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgdW51c2VkLWltcG9ydHMvbm8tdW51c2VkLXZhcnMgKi9cbi8qKlxuICogQGludGVyZmFjZSBBbmFseXRpY3NBZGFwdGVyXG4gKiBAbW9kdWxlIEFkYXB0ZXJzXG4gKi9cbmV4cG9ydCBjbGFzcyBBbmFseXRpY3NBZGFwdGVyIHtcbiAgLyoqXG4gIEBwYXJhbSB7YW55fSBwYXJhbWV0ZXJzOiB0aGUgYW5hbHl0aWNzIHJlcXVlc3QgYm9keSwgYW5hbHl0aWNzIGluZm8gd2lsbCBiZSBpbiB0aGUgZGltZW5zaW9ucyBwcm9wZXJ0eVxuICBAcGFyYW0ge1JlcXVlc3R9IHJlcTogdGhlIG9yaWdpbmFsIGh0dHAgcmVxdWVzdFxuICAgKi9cbiAgYXBwT3BlbmVkKHBhcmFtZXRlcnMsIHJlcSkge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoe30pO1xuICB9XG5cbiAgLyoqXG4gIEBwYXJhbSB7U3RyaW5nfSBldmVudE5hbWU6IHRoZSBuYW1lIG9mIHRoZSBjdXN0b20gZXZlbnROYW1lXG4gIEBwYXJhbSB7YW55fSBwYXJhbWV0ZXJzOiB0aGUgYW5hbHl0aWNzIHJlcXVlc3QgYm9keSwgYW5hbHl0aWNzIGluZm8gd2lsbCBiZSBpbiB0aGUgZGltZW5zaW9ucyBwcm9wZXJ0eVxuICBAcGFyYW0ge1JlcXVlc3R9IHJlcTogdGhlIG9yaWdpbmFsIGh0dHAgcmVxdWVzdFxuICAgKi9cbiAgdHJhY2tFdmVudChldmVudE5hbWUsIHBhcmFtZXRlcnMsIHJlcSkge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoe30pO1xuICB9XG59XG5cbmV4cG9ydCBkZWZhdWx0IEFuYWx5dGljc0FkYXB0ZXI7XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDTyxNQUFNQSxnQkFBZ0IsQ0FBQztFQUM1QjtBQUNGO0FBQ0E7QUFDQTtFQUNFQyxTQUFTQSxDQUFDQyxVQUFVLEVBQUVDLEdBQUcsRUFBRTtJQUN6QixPQUFPQyxPQUFPLENBQUNDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztFQUM1Qjs7RUFFQTtBQUNGO0FBQ0E7QUFDQTtBQUNBO0VBQ0VDLFVBQVVBLENBQUNDLFNBQVMsRUFBRUwsVUFBVSxFQUFFQyxHQUFHLEVBQUU7SUFDckMsT0FBT0MsT0FBTyxDQUFDQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7RUFDNUI7QUFDRjtBQUFDRyxPQUFBLENBQUFSLGdCQUFBLEdBQUFBLGdCQUFBO0FBQUEsSUFBQVMsUUFBQSxHQUFBRCxPQUFBLENBQUFFLE9BQUEsR0FFY1YsZ0JBQWdCIiwiaWdub3JlTGlzdCI6W119

package/lib/Adapters/Auth/AuthAdapter.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AuthAdapter = void 0;
+/* eslint-disable unused-imports/no-unused-vars */
+
+/**
+ * @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 {Object} options additional adapter options
+   * @param {Parse.Cloud.TriggerRequest} request
+   * @returns {Promise<ParseAuthResponse|void|undefined>}
+   */
+  validateAuthData(authData, options, request) {
+    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 {Object} options additional adapter options
+   * @param {Parse.Cloud.TriggerRequest} request
+   * @returns {Promise<ParseAuthResponse|void|undefined>}
+   */
+  validateSetUp(authData, options, req) {
+    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 {Object} options additional adapter options
+   * @param {Parse.Cloud.TriggerRequest} request
+   * @returns {Promise<ParseAuthResponse|void|undefined>}
+   */
+  validateLogin(authData, options, req) {
+    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, options, req) {
+    return Promise.resolve({});
+  }
+
+  /**
+   * Triggered when user is looked up by authData with this provider. Override the `id` field if needed.
+   * @param {Object} authData The client provided authData
+   */
+  beforeFind(authData) {}
+
+  /**
+   * 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
+   * @param {Parse.Cloud.TriggerRequest} request
+   * @returns {Promise<Object>} Any overrides required to authData
+   */
+  afterFind(authData, options, request) {
+    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","beforeFind","challenge","challengeData","afterFind","validateOptions","exports","_default","default"],"sources":["../../../src/Adapters/Auth/AuthAdapter.js"],"sourcesContent":["/* eslint-disable unused-imports/no-unused-vars */\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 {Object} options additional adapter options\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateAuthData(authData, options, request) {\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 {Object} options additional adapter options\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateSetUp(authData, options, req) {\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 {Object} options additional adapter options\n   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {Promise<ParseAuthResponse|void|undefined>}\n   */\n  validateLogin(authData, options, req) {\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, options, req) {\n    return Promise.resolve({});\n  }\n\n  /**\n   * Triggered when user is looked up by authData with this provider. Override the `id` field if needed.\n   * @param {Object} authData The client provided authData\n   */\n  beforeFind(authData) {\n\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   * @param {Parse.Cloud.TriggerRequest} request\n   * @returns {Promise<Object>} Any overrides required to authData\n   */\n  afterFind(authData, options, request) {\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,EAAEC,OAAO,EAAEC,OAAO,EAAE;IAC3C,OAAOC,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,aAAaA,CAACN,QAAQ,EAAEC,OAAO,EAAEM,GAAG,EAAE;IACpC,OAAOJ,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEI,aAAaA,CAACR,QAAQ,EAAEC,OAAO,EAAEM,GAAG,EAAE;IACpC,OAAOJ,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEK,cAAcA,CAACT,QAAQ,EAAEC,OAAO,EAAEM,GAAG,EAAE;IACrC,OAAOJ,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;EACEM,UAAUA,CAACV,QAAQ,EAAE,CAErB;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEW,SAASA,CAACC,aAAa,EAAEZ,QAAQ,EAAEC,OAAO,EAAEC,OAAO,EAAE;IACnD,OAAOC,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACES,SAASA,CAACb,QAAQ,EAAEC,OAAO,EAAEC,OAAO,EAAE;IACpC,OAAOC,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5B;;EAEA;AACF;AACA;AACA;EACEU,eAAeA,CAACb,OAAO,EAAE;IACvB;EAAA;AAEJ;AAACc,OAAA,CAAApB,WAAA,GAAAA,WAAA;AAAA,IAAAqB,QAAA,GAAAD,OAAA,CAAAE,OAAA,GAEctB,WAAW","ignoreList":[]}

package/lib/Adapters/Auth/BaseCodeAuthAdapter.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// abstract class for auth code adapters
+
+class BaseAuthCodeAdapter extends _AuthAdapter.default {
+  constructor(adapterName) {
+    super();
+    this.adapterName = adapterName;
+  }
+  validateOptions(options) {
+    if (!options) {
+      throw new Error(`${this.adapterName} options are required.`);
+    }
+    this.enableInsecureAuth = options.enableInsecureAuth;
+    if (this.enableInsecureAuth) {
+      return;
+    }
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    if (!this.clientId) {
+      throw new Error(`${this.adapterName} clientId is required.`);
+    }
+    if (!this.clientSecret) {
+      throw new Error(`${this.adapterName} clientSecret is required.`);
+    }
+  }
+  async beforeFind(authData) {
+    if (this.enableInsecureAuth && !authData?.code) {
+      if (!authData?.access_token) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);
+      }
+      const user = await this.getUserFromAccessToken(authData.access_token, authData);
+      if (user.id !== authData.id) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);
+      }
+      return;
+    }
+    if (!authData?.code) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `${this.adapterName} code is required.`);
+    }
+    const access_token = await this.getAccessTokenFromCode(authData);
+    const user = await this.getUserFromAccessToken(access_token, authData);
+    if (authData.id && user.id !== authData.id) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);
+    }
+    authData.access_token = access_token;
+    authData.id = user.id;
+    delete authData.code;
+    delete authData.redirect_uri;
+  }
+  async getUserFromAccessToken() {
+    // abstract method
+    throw new Error('getUserFromAccessToken is not implemented');
+  }
+  async getAccessTokenFromCode() {
+    // abstract method
+    throw new Error('getAccessTokenFromCode is not implemented');
+  }
+
+  /**
+   * Validates auth data on login. In the standard auth flows (login, signup,
+   * update), `beforeFind` runs first and validates credentials, so no
+   * additional credential check is needed here.
+   */
+  validateLogin(authData) {
+    return {
+      id: authData.id
+    };
+  }
+
+  /**
+   * Validates auth data on first setup or when linking a new provider.
+   * In the standard auth flows, `beforeFind` runs first and validates
+   * credentials, so no additional credential check is needed here.
+   */
+  validateSetUp(authData) {
+    return {
+      id: authData.id
+    };
+  }
+
+  /**
+   * Returns the auth data to expose to the client after a query.
+   */
+  afterFind(authData) {
+    return {
+      id: authData.id
+    };
+  }
+
+  /**
+   * Validates auth data on update. In the standard auth flows, `beforeFind`
+   * runs first for any changed auth data and validates credentials, so no
+   * additional credential check is needed here. Unchanged (echoed-back) data
+   * skips both `beforeFind` and validation entirely.
+   */
+  validateUpdate(authData) {
+    return {
+      id: authData.id
+    };
+  }
+  parseResponseData(data) {
+    const startPos = data.indexOf('(');
+    const endPos = data.indexOf(')');
+    if (startPos === -1 || endPos === -1) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);
+    }
+    const jsonData = data.substring(startPos + 1, endPos);
+    return JSON.parse(jsonData);
+  }
+}
+exports.default = BaseAuthCodeAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_AuthAdapter","_interopRequireDefault","require","e","__esModule","default","BaseAuthCodeAdapter","AuthAdapter","constructor","adapterName","validateOptions","options","Error","enableInsecureAuth","clientId","clientSecret","beforeFind","authData","code","access_token","Parse","OBJECT_NOT_FOUND","user","getUserFromAccessToken","id","VALIDATION_ERROR","getAccessTokenFromCode","redirect_uri","validateLogin","validateSetUp","afterFind","validateUpdate","parseResponseData","data","startPos","indexOf","endPos","jsonData","substring","JSON","parse","exports"],"sources":["../../../src/Adapters/Auth/BaseCodeAuthAdapter.js"],"sourcesContent":["// abstract class for auth code adapters\nimport AuthAdapter from './AuthAdapter';\nexport default class BaseAuthCodeAdapter extends AuthAdapter {\n  constructor(adapterName) {\n    super();\n    this.adapterName = adapterName;\n  }\n  validateOptions(options) {\n\n    if (!options) {\n      throw new Error(`${this.adapterName} options are required.`);\n    }\n\n    this.enableInsecureAuth = options.enableInsecureAuth;\n    if (this.enableInsecureAuth) {\n      return;\n    }\n\n    this.clientId = options.clientId;\n    this.clientSecret = options.clientSecret;\n\n    if (!this.clientId) {\n      throw new Error(`${this.adapterName} clientId is required.`);\n    }\n\n    if (!this.clientSecret) {\n      throw new Error(`${this.adapterName} clientSecret is required.`);\n    }\n  }\n\n  async beforeFind(authData) {\n    if (this.enableInsecureAuth && !authData?.code) {\n      if (!authData?.access_token) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);\n      }\n\n      const user = await this.getUserFromAccessToken(authData.access_token, authData);\n\n      if (user.id !== authData.id) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);\n      }\n\n      return;\n    }\n\n    if (!authData?.code) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `${this.adapterName} code is required.`);\n    }\n\n    const access_token = await this.getAccessTokenFromCode(authData);\n    const user = await this.getUserFromAccessToken(access_token, authData);\n\n    if (authData.id && user.id !== authData.id) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);\n    }\n\n    authData.access_token = access_token;\n    authData.id = user.id;\n\n    delete authData.code;\n    delete authData.redirect_uri;\n\n  }\n\n  async getUserFromAccessToken() {\n    // abstract method\n    throw new Error('getUserFromAccessToken is not implemented');\n  }\n\n  async getAccessTokenFromCode() {\n    // abstract method\n    throw new Error('getAccessTokenFromCode is not implemented');\n  }\n\n  /**\n   * Validates auth data on login. In the standard auth flows (login, signup,\n   * update), `beforeFind` runs first and validates credentials, so no\n   * additional credential check is needed here.\n   */\n  validateLogin(authData) {\n    return {\n      id: authData.id,\n    }\n  }\n\n  /**\n   * Validates auth data on first setup or when linking a new provider.\n   * In the standard auth flows, `beforeFind` runs first and validates\n   * credentials, so no additional credential check is needed here.\n   */\n  validateSetUp(authData) {\n    return {\n      id: authData.id,\n    }\n  }\n\n  /**\n   * Returns the auth data to expose to the client after a query.\n   */\n  afterFind(authData) {\n    return {\n      id: authData.id,\n    }\n  }\n\n  /**\n   * Validates auth data on update. In the standard auth flows, `beforeFind`\n   * runs first for any changed auth data and validates credentials, so no\n   * additional credential check is needed here. Unchanged (echoed-back) data\n   * skips both `beforeFind` and validation entirely.\n   */\n  validateUpdate(authData) {\n    return {\n      id: authData.id,\n    }\n  }\n\n  parseResponseData(data) {\n    const startPos = data.indexOf('(');\n    const endPos = data.indexOf(')');\n    if (startPos === -1 || endPos === -1) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${this.adapterName} auth is invalid for this user.`);\n    }\n    const jsonData = data.substring(startPos + 1, endPos);\n    return JSON.parse(jsonData);\n  }\n}\n"],"mappings":"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","ignoreList":[]}