parse-server 5.4.0-beta.1 → 6.0.0-alpha.2

package/README.md

@@ -1,8 +1,10 @@
 ![parse-repository-header-server](https://user-images.githubusercontent.com/5673677/138278489-7d0cebc5-1e31-4d3c-8ffb-53efcda6f29d.png)
 
 ---
-    
+
 [![Build Status](https://github.com/parse-community/parse-server/workflows/ci/badge.svg?branch=alpha)](https://github.com/parse-community/parse-server/actions?query=workflow%3Aci+branch%3Aalpha)
+[![Build Status](https://github.com/parse-community/parse-server/workflows/ci/badge.svg?branch=beta)](https://github.com/parse-community/parse-server/actions?query=workflow%3Aci+branch%3Abeta)
+[![Build Status](https://github.com/parse-community/parse-server/workflows/ci/badge.svg?branch=release)](https://github.com/parse-community/parse-server/actions?query=workflow%3Aci+branch%3Arelease)
 [![Snyk Badge](https://snyk.io/test/github/parse-community/parse-server/badge.svg)](https://snyk.io/test/github/parse-community/parse-server)
 [![Coverage](https://img.shields.io/codecov/c/github/parse-community/parse-server/alpha.svg)](https://codecov.io/github/parse-community/parse-server?branch=alpha)
 [![auto-release](https://img.shields.io/badge/%F0%9F%9A%80-auto--release-9e34eb.svg)](https://github.com/parse-community/parse-dashboard/releases)
@@ -126,10 +128,8 @@ Parse Server is continuously tested with the most recent releases of Node.js to
 
 | Version    | Latest Version | End-of-Life | Compatible |
 |------------|----------------|-------------|------------|
-| Node.js 12 | 12.22.11       | April 2022  | ✅ Yes      |
 | Node.js 14 | 14.19.1        | April 2023  | ✅ Yes      |
 | Node.js 16 | 16.14.2        | April 2024  | ✅ Yes      |
-| Node.js 17 | 17.9.0         | June 2022   | ✅ Yes      |
 | Node.js 18 | 18.1.0         | April 2025  | ✅ Yes      |
 
 #### MongoDB
@@ -389,7 +389,7 @@ const server = ParseServer({
   },
 
   // The password policy
-  passwordPolicy: {    
+  passwordPolicy: {
     // Enforce a password of at least 8 characters which contain at least 1 lower case, 1 upper case and 1 digit
     validatorPattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})/,
     // Do not allow the username as part of the password
@@ -430,7 +430,7 @@ const api = new ParseServer({
 
 The above route can be invoked by sending a `GET` request to:
 `https://[parseServerPublicUrl]/[parseMount]/[pagesEndpoint]/[appId]/[customRoute]`
- 
+
 The `handler` receives the `request` and returns a `custom_page.html` webpage from the `pages.pagesPath` directory as response. The advantage of building a custom route this way is that it automatically makes use of Parse Server's built-in capabilities, such as [page localization](#pages) and [dynamic placeholders](#dynamic-placeholders).
 
 ### Reserved Paths
@@ -518,7 +518,7 @@ Parse Server allows developers to choose from several options when hosting files
 `GridFSBucketAdapter` is used by default and requires no setup, but if you're interested in using Amazon S3, Google Cloud Storage, or local file storage, additional configuration information is available in the [Parse Server guide](http://docs.parseplatform.org/parse-server/guide/#configuring-file-adapters).
 
 ## Idempotency Enforcement
- 
+
 **Caution, this is an experimental feature that may not be appropriate for production.**
 
 This feature deduplicates identical requests that are received by Parse Server multiple times, typically due to network issues or network adapter access restrictions on mobile operating systems.

package/lib/Adapters/Auth/AuthAdapter.js

@@ -6,23 +6,104 @@ Object.defineProperty(exports, "__esModule", {
 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 {
-  /*
-  @param appIds: the specified app ids in the configuration
-  @param authData: the client provided authData
-  @param options: additional options
-  @returns a promise that resolves if the applicationId is valid
+  constructor() {
+    /**
+     * Usage policy
+     * @type {AuthPolicy}
+     */
+    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>}
    */
-  validateAppId(appIds, authData, options) {
+
+
+  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({});
   }
-  /*
-  @param authData: the client provided authData
-  @param options: additional options
+  /**
+   * 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
    */
 
 
-  validateAuthData(authData, options) {
+  challenge(challengeData, authData, options, request) {
     return Promise.resolve({});
   }
 
@@ -31,4 +112,4 @@ class AuthAdapter {
 exports.AuthAdapter = AuthAdapter;
 var _default = AuthAdapter;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BdXRoL0F1dGhBZGFwdGVyLmpzIl0sIm5hbWVzIjpbIkF1dGhBZGFwdGVyIiwidmFsaWRhdGVBcHBJZCIsImFwcElkcyIsImF1dGhEYXRhIiwib3B0aW9ucyIsIlByb21pc2UiLCJyZXNvbHZlIiwidmFsaWRhdGVBdXRoRGF0YSJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBO0FBQ08sTUFBTUEsV0FBTixDQUFrQjtBQUN2QjtBQUNGO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDRUMsRUFBQUEsYUFBYSxDQUFDQyxNQUFELEVBQVNDLFFBQVQsRUFBbUJDLE9BQW5CLEVBQTRCO0FBQ3ZDLFdBQU9DLE9BQU8sQ0FBQ0MsT0FBUixDQUFnQixFQUFoQixDQUFQO0FBQ0Q7QUFFRDtBQUNGO0FBQ0E7QUFDQTs7O0FBQ0VDLEVBQUFBLGdCQUFnQixDQUFDSixRQUFELEVBQVdDLE9BQVgsRUFBb0I7QUFDbEMsV0FBT0MsT0FBTyxDQUFDQyxPQUFSLENBQWdCLEVBQWhCLENBQVA7QUFDRDs7QUFqQnNCOzs7ZUFvQlZOLFciLCJzb3VyY2VzQ29udGVudCI6WyIvKmVzbGludCBuby11bnVzZWQtdmFyczogXCJvZmZcIiovXG5leHBvcnQgY2xhc3MgQXV0aEFkYXB0ZXIge1xuICAvKlxuICBAcGFyYW0gYXBwSWRzOiB0aGUgc3BlY2lmaWVkIGFwcCBpZHMgaW4gdGhlIGNvbmZpZ3VyYXRpb25cbiAgQHBhcmFtIGF1dGhEYXRhOiB0aGUgY2xpZW50IHByb3ZpZGVkIGF1dGhEYXRhXG4gIEBwYXJhbSBvcHRpb25zOiBhZGRpdGlvbmFsIG9wdGlvbnNcbiAgQHJldHVybnMgYSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgaWYgdGhlIGFwcGxpY2F0aW9uSWQgaXMgdmFsaWRcbiAgICovXG4gIHZhbGlkYXRlQXBwSWQoYXBwSWRzLCBhdXRoRGF0YSwgb3B0aW9ucykge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoe30pO1xuICB9XG5cbiAgLypcbiAgQHBhcmFtIGF1dGhEYXRhOiB0aGUgY2xpZW50IHByb3ZpZGVkIGF1dGhEYXRhXG4gIEBwYXJhbSBvcHRpb25zOiBhZGRpdGlvbmFsIG9wdGlvbnNcbiAgICovXG4gIHZhbGlkYXRlQXV0aERhdGEoYXV0aERhdGEsIG9wdGlvbnMpIHtcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHt9KTtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBBdXRoQWRhcHRlcjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/index.js

@@ -2,6 +2,8 @@
 
 var _AdapterLoader = _interopRequireDefault(require("../AdapterLoader"));
 
+var _node = _interopRequireDefault(require("parse/node"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const apple = require('./apple');
@@ -86,27 +88,84 @@ const providers = {
   microsoft,
   keycloak,
   ldap
+}; // Indexed auth policies
+
+const authAdapterPolicies = {
+  default: true,
+  solo: true,
+  additional: true
 };
 
-function authDataValidator(adapter, appIds, options) {
-  return function (authData) {
-    return adapter.validateAuthData(authData, options).then(() => {
-      if (appIds) {
-        return adapter.validateAppId(appIds, authData, options);
-      }
+function authDataValidator(provider, adapter, appIds, options) {
+  return async function (authData, req, user, requestObject) {
+    if (appIds && typeof adapter.validateAppId === 'function') {
+      await Promise.resolve(adapter.validateAppId(appIds, authData, options, requestObject));
+    }
+
+    if (adapter.policy && !authAdapterPolicies[adapter.policy]) {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'AuthAdapter policy is not configured correctly. The value must be either "solo", "additional", "default" or undefined (will be handled as "default")');
+    }
+
+    if (typeof adapter.validateAuthData === 'function') {
+      return adapter.validateAuthData(authData, options, requestObject);
+    }
+
+    if (typeof adapter.validateSetUp !== 'function' || typeof adapter.validateLogin !== 'function' || typeof adapter.validateUpdate !== 'function') {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'Adapter is not configured. Implement either validateAuthData or all of the following: validateSetUp, validateLogin and validateUpdate');
+    } // When masterKey is detected, we should trigger a logged in user
+
+
+    const isLoggedIn = req.auth.user && user && req.auth.user.id === user.id || user && req.auth.isMaster;
+    let hasAuthDataConfigured = false;
+
+    if (user && user.get('authData') && user.get('authData')[provider]) {
+      hasAuthDataConfigured = true;
+    }
+
+    if (isLoggedIn) {
+      // User is updating their authData
+      if (hasAuthDataConfigured) {
+        return {
+          method: 'validateUpdate',
+          validator: () => adapter.validateUpdate(authData, options, requestObject)
+        };
+      } // Set up if the user does not have the provider configured
+
+
+      return {
+        method: 'validateSetUp',
+        validator: () => adapter.validateSetUp(authData, options, requestObject)
+      };
+    } // Not logged in and authData is configured on the user
+
+
+    if (hasAuthDataConfigured) {
+      return {
+        method: 'validateLogin',
+        validator: () => adapter.validateLogin(authData, options, requestObject)
+      };
+    } // User not logged in and the provider is not set up, for example when a new user
+    // signs up or an existing user uses a new auth provider
+
 
-      return Promise.resolve();
-    });
+    return {
+      method: 'validateSetUp',
+      validator: () => adapter.validateSetUp(authData, options, requestObject)
+    };
   };
 }
 
 function loadAuthAdapter(provider, authOptions) {
-  let defaultAdapter = providers[provider];
+  // providers are auth providers implemented by default
+  let defaultAdapter = providers[provider]; // authOptions can contain complete custom auth adapters or
+  // a default auth adapter like Facebook
+
   const providerOptions = authOptions[provider];
 
   if (providerOptions && Object.prototype.hasOwnProperty.call(providerOptions, 'oauth2') && providerOptions['oauth2'] === true) {
     defaultAdapter = oauth2;
-  }
+  } // Default provider not found and a custom auth provider was not provided
+
 
   if (!defaultAdapter && !providerOptions) {
     return;
@@ -119,20 +178,12 @@ function loadAuthAdapter(provider, authOptions) {
     const optionalAdapter = (0, _AdapterLoader.default)(providerOptions, undefined, providerOptions);
 
     if (optionalAdapter) {
-      ['validateAuthData', 'validateAppId'].forEach(key => {
+      ['validateAuthData', 'validateAppId', 'validateSetUp', 'validateLogin', 'validateUpdate', 'challenge', 'policy'].forEach(key => {
         if (optionalAdapter[key]) {
           adapter[key] = optionalAdapter[key];
         }
       });
     }
-  } // TODO: create a new module from validateAdapter() in
-  // src/Controllers/AdaptableController.js so we can use it here for adapter
-  // validation based on the src/Adapters/Auth/AuthAdapter.js expected class
-  // signature.
-
-
-  if (!adapter.validateAuthData || !adapter.validateAppId) {
-    return;
   }
 
   return {
@@ -152,15 +203,22 @@ module.exports = function (authOptions = {}, enableAnonymousUsers = true) {
 
   const getValidatorForProvider = function (provider) {
     if (provider === 'anonymous' && !_enableAnonymousUsers) {
-      return;
+      return {
+        validator: undefined
+      };
     }
 
+    const authAdapter = loadAuthAdapter(provider, authOptions);
+    if (!authAdapter) return;
     const {
       adapter,
       appIds,
       providerOptions
-    } = loadAuthAdapter(provider, authOptions);
-    return authDataValidator(adapter, appIds, providerOptions);
+    } = authAdapter;
+    return {
+      validator: authDataValidator(provider, adapter, appIds, providerOptions),
+      adapter
+    };
   };
 
   return Object.freeze({
@@ -170,4 +228,4 @@ module.exports = function (authOptions = {}, enableAnonymousUsers = true) {
 };
 
 module.exports.loadAuthAdapter = loadAuthAdapter;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Adapters/Auth/index.js"],"names":["apple","require","gcenter","gpgames","facebook","instagram","linkedin","meetup","google","github","twitter","spotify","digits","janrainengage","janraincapture","line","vkontakte","qq","wechat","weibo","oauth2","phantauth","microsoft","keycloak","ldap","anonymous","validateAuthData","Promise","resolve","validateAppId","providers","authDataValidator","adapter","appIds","options","authData","then","loadAuthAdapter","provider","authOptions","defaultAdapter","providerOptions","Object","prototype","hasOwnProperty","call","assign","undefined","optionalAdapter","forEach","key","module","exports","enableAnonymousUsers","_enableAnonymousUsers","setEnableAnonymousUsers","enable","getValidatorForProvider","freeze"],"mappings":"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","sourcesContent":["import loadAdapter from '../AdapterLoader';\n\nconst apple = require('./apple');\nconst gcenter = require('./gcenter');\nconst gpgames = require('./gpgames');\nconst facebook = require('./facebook');\nconst instagram = require('./instagram');\nconst linkedin = require('./linkedin');\nconst meetup = require('./meetup');\nconst google = require('./google');\nconst github = require('./github');\nconst twitter = require('./twitter');\nconst spotify = require('./spotify');\nconst digits = require('./twitter'); // digits tokens are validated by twitter\nconst janrainengage = require('./janrainengage');\nconst janraincapture = require('./janraincapture');\nconst line = require('./line');\nconst vkontakte = require('./vkontakte');\nconst qq = require('./qq');\nconst wechat = require('./wechat');\nconst weibo = require('./weibo');\nconst oauth2 = require('./oauth2');\nconst phantauth = require('./phantauth');\nconst microsoft = require('./microsoft');\nconst keycloak = require('./keycloak');\nconst ldap = require('./ldap');\n\nconst anonymous = {\n  validateAuthData: () => {\n    return Promise.resolve();\n  },\n  validateAppId: () => {\n    return Promise.resolve();\n  },\n};\n\nconst providers = {\n  apple,\n  gcenter,\n  gpgames,\n  facebook,\n  instagram,\n  linkedin,\n  meetup,\n  google,\n  github,\n  twitter,\n  spotify,\n  anonymous,\n  digits,\n  janrainengage,\n  janraincapture,\n  line,\n  vkontakte,\n  qq,\n  wechat,\n  weibo,\n  phantauth,\n  microsoft,\n  keycloak,\n  ldap,\n};\n\nfunction authDataValidator(adapter, appIds, options) {\n  return function (authData) {\n    return adapter.validateAuthData(authData, options).then(() => {\n      if (appIds) {\n        return adapter.validateAppId(appIds, authData, options);\n      }\n      return Promise.resolve();\n    });\n  };\n}\n\nfunction loadAuthAdapter(provider, authOptions) {\n  let defaultAdapter = providers[provider];\n  const providerOptions = authOptions[provider];\n  if (\n    providerOptions &&\n    Object.prototype.hasOwnProperty.call(providerOptions, 'oauth2') &&\n    providerOptions['oauth2'] === true\n  ) {\n    defaultAdapter = oauth2;\n  }\n\n  if (!defaultAdapter && !providerOptions) {\n    return;\n  }\n\n  const adapter = Object.assign({}, defaultAdapter);\n  const appIds = providerOptions ? providerOptions.appIds : undefined;\n\n  // Try the configuration methods\n  if (providerOptions) {\n    const optionalAdapter = loadAdapter(providerOptions, undefined, providerOptions);\n    if (optionalAdapter) {\n      ['validateAuthData', 'validateAppId'].forEach(key => {\n        if (optionalAdapter[key]) {\n          adapter[key] = optionalAdapter[key];\n        }\n      });\n    }\n  }\n\n  // TODO: create a new module from validateAdapter() in\n  // src/Controllers/AdaptableController.js so we can use it here for adapter\n  // validation based on the src/Adapters/Auth/AuthAdapter.js expected class\n  // signature.\n  if (!adapter.validateAuthData || !adapter.validateAppId) {\n    return;\n  }\n\n  return { adapter, appIds, providerOptions };\n}\n\nmodule.exports = function (authOptions = {}, enableAnonymousUsers = true) {\n  let _enableAnonymousUsers = enableAnonymousUsers;\n  const setEnableAnonymousUsers = function (enable) {\n    _enableAnonymousUsers = enable;\n  };\n  // To handle the test cases on configuration\n  const getValidatorForProvider = function (provider) {\n    if (provider === 'anonymous' && !_enableAnonymousUsers) {\n      return;\n    }\n\n    const { adapter, appIds, providerOptions } = loadAuthAdapter(provider, authOptions);\n\n    return authDataValidator(adapter, appIds, providerOptions);\n  };\n\n  return Object.freeze({\n    getValidatorForProvider,\n    setEnableAnonymousUsers,\n  });\n};\n\nmodule.exports.loadAuthAdapter = loadAuthAdapter;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Adapters/Auth/index.js"],"names":["apple","require","gcenter","gpgames","facebook","instagram","linkedin","meetup","google","github","twitter","spotify","digits","janrainengage","janraincapture","line","vkontakte","qq","wechat","weibo","oauth2","phantauth","microsoft","keycloak","ldap","anonymous","validateAuthData","Promise","resolve","validateAppId","providers","authAdapterPolicies","default","solo","additional","authDataValidator","provider","adapter","appIds","options","authData","req","user","requestObject","policy","Parse","Error","OTHER_CAUSE","validateSetUp","validateLogin","validateUpdate","isLoggedIn","auth","id","isMaster","hasAuthDataConfigured","get","method","validator","loadAuthAdapter","authOptions","defaultAdapter","providerOptions","Object","prototype","hasOwnProperty","call","assign","undefined","optionalAdapter","forEach","key","module","exports","enableAnonymousUsers","_enableAnonymousUsers","setEnableAnonymousUsers","enable","getValidatorForProvider","authAdapter","freeze"],"mappings":"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","sourcesContent":["import loadAdapter from '../AdapterLoader';\nimport Parse from 'parse/node';\n\nconst apple = require('./apple');\nconst gcenter = require('./gcenter');\nconst gpgames = require('./gpgames');\nconst facebook = require('./facebook');\nconst instagram = require('./instagram');\nconst linkedin = require('./linkedin');\nconst meetup = require('./meetup');\nconst google = require('./google');\nconst github = require('./github');\nconst twitter = require('./twitter');\nconst spotify = require('./spotify');\nconst digits = require('./twitter'); // digits tokens are validated by twitter\nconst janrainengage = require('./janrainengage');\nconst janraincapture = require('./janraincapture');\nconst line = require('./line');\nconst vkontakte = require('./vkontakte');\nconst qq = require('./qq');\nconst wechat = require('./wechat');\nconst weibo = require('./weibo');\nconst oauth2 = require('./oauth2');\nconst phantauth = require('./phantauth');\nconst microsoft = require('./microsoft');\nconst keycloak = require('./keycloak');\nconst ldap = require('./ldap');\n\nconst anonymous = {\n  validateAuthData: () => {\n    return Promise.resolve();\n  },\n  validateAppId: () => {\n    return Promise.resolve();\n  },\n};\n\nconst providers = {\n  apple,\n  gcenter,\n  gpgames,\n  facebook,\n  instagram,\n  linkedin,\n  meetup,\n  google,\n  github,\n  twitter,\n  spotify,\n  anonymous,\n  digits,\n  janrainengage,\n  janraincapture,\n  line,\n  vkontakte,\n  qq,\n  wechat,\n  weibo,\n  phantauth,\n  microsoft,\n  keycloak,\n  ldap,\n};\n\n// Indexed auth policies\nconst authAdapterPolicies = {\n  default: true,\n  solo: true,\n  additional: true,\n};\n\nfunction authDataValidator(provider, adapter, appIds, options) {\n  return async function (authData, req, user, requestObject) {\n    if (appIds && typeof adapter.validateAppId === 'function') {\n      await Promise.resolve(adapter.validateAppId(appIds, authData, options, requestObject));\n    }\n    if (adapter.policy && !authAdapterPolicies[adapter.policy]) {\n      throw new Parse.Error(\n        Parse.Error.OTHER_CAUSE,\n        'AuthAdapter policy is not configured correctly. The value must be either \"solo\", \"additional\", \"default\" or undefined (will be handled as \"default\")'\n      );\n    }\n    if (typeof adapter.validateAuthData === 'function') {\n      return adapter.validateAuthData(authData, options, requestObject);\n    }\n    if (\n      typeof adapter.validateSetUp !== 'function' ||\n      typeof adapter.validateLogin !== 'function' ||\n      typeof adapter.validateUpdate !== 'function'\n    ) {\n      throw new Parse.Error(\n        Parse.Error.OTHER_CAUSE,\n        'Adapter is not configured. Implement either validateAuthData or all of the following: validateSetUp, validateLogin and validateUpdate'\n      );\n    }\n    // When masterKey is detected, we should trigger a logged in user\n    const isLoggedIn =\n      (req.auth.user && user && req.auth.user.id === user.id) || (user && req.auth.isMaster);\n    let hasAuthDataConfigured = false;\n\n    if (user && user.get('authData') && user.get('authData')[provider]) {\n      hasAuthDataConfigured = true;\n    }\n\n    if (isLoggedIn) {\n      // User is updating their authData\n      if (hasAuthDataConfigured) {\n        return {\n          method: 'validateUpdate',\n          validator: () => adapter.validateUpdate(authData, options, requestObject),\n        };\n      }\n      // Set up if the user does not have the provider configured\n      return {\n        method: 'validateSetUp',\n        validator: () => adapter.validateSetUp(authData, options, requestObject),\n      };\n    }\n\n    // Not logged in and authData is configured on the user\n    if (hasAuthDataConfigured) {\n      return {\n        method: 'validateLogin',\n        validator: () => adapter.validateLogin(authData, options, requestObject),\n      };\n    }\n\n    // User not logged in and the provider is not set up, for example when a new user\n    // signs up or an existing user uses a new auth provider\n    return {\n      method: 'validateSetUp',\n      validator: () => adapter.validateSetUp(authData, options, requestObject),\n    };\n  };\n}\n\nfunction loadAuthAdapter(provider, authOptions) {\n  // providers are auth providers implemented by default\n  let defaultAdapter = providers[provider];\n  // authOptions can contain complete custom auth adapters or\n  // a default auth adapter like Facebook\n  const providerOptions = authOptions[provider];\n  if (\n    providerOptions &&\n    Object.prototype.hasOwnProperty.call(providerOptions, 'oauth2') &&\n    providerOptions['oauth2'] === true\n  ) {\n    defaultAdapter = oauth2;\n  }\n\n  // Default provider not found and a custom auth provider was not provided\n  if (!defaultAdapter && !providerOptions) {\n    return;\n  }\n\n  const adapter = Object.assign({}, defaultAdapter);\n  const appIds = providerOptions ? providerOptions.appIds : undefined;\n\n  // Try the configuration methods\n  if (providerOptions) {\n    const optionalAdapter = loadAdapter(providerOptions, undefined, providerOptions);\n    if (optionalAdapter) {\n      [\n        'validateAuthData',\n        'validateAppId',\n        'validateSetUp',\n        'validateLogin',\n        'validateUpdate',\n        'challenge',\n        'policy',\n      ].forEach(key => {\n        if (optionalAdapter[key]) {\n          adapter[key] = optionalAdapter[key];\n        }\n      });\n    }\n  }\n\n  return { adapter, appIds, providerOptions };\n}\n\nmodule.exports = function (authOptions = {}, enableAnonymousUsers = true) {\n  let _enableAnonymousUsers = enableAnonymousUsers;\n  const setEnableAnonymousUsers = function (enable) {\n    _enableAnonymousUsers = enable;\n  };\n  // To handle the test cases on configuration\n  const getValidatorForProvider = function (provider) {\n    if (provider === 'anonymous' && !_enableAnonymousUsers) {\n      return { validator: undefined };\n    }\n    const authAdapter = loadAuthAdapter(provider, authOptions);\n    if (!authAdapter) return;\n    const { adapter, appIds, providerOptions } = authAdapter;\n    return { validator: authDataValidator(provider, adapter, appIds, providerOptions), adapter };\n  };\n\n  return Object.freeze({\n    getValidatorForProvider,\n    setEnableAnonymousUsers,\n  });\n};\n\nmodule.exports.loadAuthAdapter = loadAuthAdapter;\n"]}

package/lib/Adapters/Cache/LRUCache.js

@@ -31,11 +31,11 @@ class LRUCache {
   }
 
   del(key) {
-    this.cache.del(key);
+    this.cache.delete(key);
   }
 
   clear() {
-    this.cache.reset();
+    this.cache.clear();
   }
 
 }
@@ -43,4 +43,4 @@ class LRUCache {
 exports.LRUCache = LRUCache;
 var _default = LRUCache;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9MUlVDYWNoZS5qcyJdLCJuYW1lcyI6WyJMUlVDYWNoZSIsImNvbnN0cnVjdG9yIiwidHRsIiwiZGVmYXVsdHMiLCJjYWNoZVRUTCIsIm1heFNpemUiLCJjYWNoZU1heFNpemUiLCJjYWNoZSIsIkxSVSIsIm1heCIsImdldCIsImtleSIsInB1dCIsInZhbHVlIiwic2V0IiwiZGVsIiwiY2xlYXIiLCJyZXNldCJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBOztBQUNBOzs7O0FBRU8sTUFBTUEsUUFBTixDQUFlO0FBQ3BCQyxFQUFBQSxXQUFXLENBQUM7QUFBRUMsSUFBQUEsR0FBRyxHQUFHQyxrQkFBU0MsUUFBakI7QUFBMkJDLElBQUFBLE9BQU8sR0FBR0Ysa0JBQVNHO0FBQTlDLEdBQUQsRUFBK0Q7QUFDeEUsU0FBS0MsS0FBTCxHQUFhLElBQUlDLGlCQUFKLENBQVE7QUFDbkJDLE1BQUFBLEdBQUcsRUFBRUosT0FEYztBQUVuQkgsTUFBQUE7QUFGbUIsS0FBUixDQUFiO0FBSUQ7O0FBRURRLEVBQUFBLEdBQUcsQ0FBQ0MsR0FBRCxFQUFNO0FBQ1AsV0FBTyxLQUFLSixLQUFMLENBQVdHLEdBQVgsQ0FBZUMsR0FBZixLQUF1QixJQUE5QjtBQUNEOztBQUVEQyxFQUFBQSxHQUFHLENBQUNELEdBQUQsRUFBTUUsS0FBTixFQUFhWCxHQUFHLEdBQUcsS0FBS0EsR0FBeEIsRUFBNkI7QUFDOUIsU0FBS0ssS0FBTCxDQUFXTyxHQUFYLENBQWVILEdBQWYsRUFBb0JFLEtBQXBCLEVBQTJCWCxHQUEzQjtBQUNEOztBQUVEYSxFQUFBQSxHQUFHLENBQUNKLEdBQUQsRUFBTTtBQUNQLFNBQUtKLEtBQUwsQ0FBV1EsR0FBWCxDQUFlSixHQUFmO0FBQ0Q7O0FBRURLLEVBQUFBLEtBQUssR0FBRztBQUNOLFNBQUtULEtBQUwsQ0FBV1UsS0FBWDtBQUNEOztBQXRCbUI7OztlQXlCUGpCLFEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTFJVIGZyb20gJ2xydS1jYWNoZSc7XG5pbXBvcnQgZGVmYXVsdHMgZnJvbSAnLi4vLi4vZGVmYXVsdHMnO1xuXG5leHBvcnQgY2xhc3MgTFJVQ2FjaGUge1xuICBjb25zdHJ1Y3Rvcih7IHR0bCA9IGRlZmF1bHRzLmNhY2hlVFRMLCBtYXhTaXplID0gZGVmYXVsdHMuY2FjaGVNYXhTaXplIH0pIHtcbiAgICB0aGlzLmNhY2hlID0gbmV3IExSVSh7XG4gICAgICBtYXg6IG1heFNpemUsXG4gICAgICB0dGwsXG4gICAgfSk7XG4gIH1cblxuICBnZXQoa2V5KSB7XG4gICAgcmV0dXJuIHRoaXMuY2FjaGUuZ2V0KGtleSkgfHwgbnVsbDtcbiAgfVxuXG4gIHB1dChrZXksIHZhbHVlLCB0dGwgPSB0aGlzLnR0bCkge1xuICAgIHRoaXMuY2FjaGUuc2V0KGtleSwgdmFsdWUsIHR0bCk7XG4gIH1cblxuICBkZWwoa2V5KSB7XG4gICAgdGhpcy5jYWNoZS5kZWwoa2V5KTtcbiAgfVxuXG4gIGNsZWFyKCkge1xuICAgIHRoaXMuY2FjaGUucmVzZXQoKTtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBMUlVDYWNoZTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9MUlVDYWNoZS5qcyJdLCJuYW1lcyI6WyJMUlVDYWNoZSIsImNvbnN0cnVjdG9yIiwidHRsIiwiZGVmYXVsdHMiLCJjYWNoZVRUTCIsIm1heFNpemUiLCJjYWNoZU1heFNpemUiLCJjYWNoZSIsIkxSVSIsIm1heCIsImdldCIsImtleSIsInB1dCIsInZhbHVlIiwic2V0IiwiZGVsIiwiZGVsZXRlIiwiY2xlYXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQTs7QUFDQTs7OztBQUVPLE1BQU1BLFFBQU4sQ0FBZTtBQUNwQkMsRUFBQUEsV0FBVyxDQUFDO0FBQUVDLElBQUFBLEdBQUcsR0FBR0Msa0JBQVNDLFFBQWpCO0FBQTJCQyxJQUFBQSxPQUFPLEdBQUdGLGtCQUFTRztBQUE5QyxHQUFELEVBQStEO0FBQ3hFLFNBQUtDLEtBQUwsR0FBYSxJQUFJQyxpQkFBSixDQUFRO0FBQ25CQyxNQUFBQSxHQUFHLEVBQUVKLE9BRGM7QUFFbkJILE1BQUFBO0FBRm1CLEtBQVIsQ0FBYjtBQUlEOztBQUVEUSxFQUFBQSxHQUFHLENBQUNDLEdBQUQsRUFBTTtBQUNQLFdBQU8sS0FBS0osS0FBTCxDQUFXRyxHQUFYLENBQWVDLEdBQWYsS0FBdUIsSUFBOUI7QUFDRDs7QUFFREMsRUFBQUEsR0FBRyxDQUFDRCxHQUFELEVBQU1FLEtBQU4sRUFBYVgsR0FBRyxHQUFHLEtBQUtBLEdBQXhCLEVBQTZCO0FBQzlCLFNBQUtLLEtBQUwsQ0FBV08sR0FBWCxDQUFlSCxHQUFmLEVBQW9CRSxLQUFwQixFQUEyQlgsR0FBM0I7QUFDRDs7QUFFRGEsRUFBQUEsR0FBRyxDQUFDSixHQUFELEVBQU07QUFDUCxTQUFLSixLQUFMLENBQVdTLE1BQVgsQ0FBa0JMLEdBQWxCO0FBQ0Q7O0FBRURNLEVBQUFBLEtBQUssR0FBRztBQUNOLFNBQUtWLEtBQUwsQ0FBV1UsS0FBWDtBQUNEOztBQXRCbUI7OztlQXlCUGpCLFEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTFJVIGZyb20gJ2xydS1jYWNoZSc7XG5pbXBvcnQgZGVmYXVsdHMgZnJvbSAnLi4vLi4vZGVmYXVsdHMnO1xuXG5leHBvcnQgY2xhc3MgTFJVQ2FjaGUge1xuICBjb25zdHJ1Y3Rvcih7IHR0bCA9IGRlZmF1bHRzLmNhY2hlVFRMLCBtYXhTaXplID0gZGVmYXVsdHMuY2FjaGVNYXhTaXplIH0pIHtcbiAgICB0aGlzLmNhY2hlID0gbmV3IExSVSh7XG4gICAgICBtYXg6IG1heFNpemUsXG4gICAgICB0dGwsXG4gICAgfSk7XG4gIH1cblxuICBnZXQoa2V5KSB7XG4gICAgcmV0dXJuIHRoaXMuY2FjaGUuZ2V0KGtleSkgfHwgbnVsbDtcbiAgfVxuXG4gIHB1dChrZXksIHZhbHVlLCB0dGwgPSB0aGlzLnR0bCkge1xuICAgIHRoaXMuY2FjaGUuc2V0KGtleSwgdmFsdWUsIHR0bCk7XG4gIH1cblxuICBkZWwoa2V5KSB7XG4gICAgdGhpcy5jYWNoZS5kZWxldGUoa2V5KTtcbiAgfVxuXG4gIGNsZWFyKCkge1xuICAgIHRoaXMuY2FjaGUuY2xlYXIoKTtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBMUlVDYWNoZTtcbiJdfQ==