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

package/README.md

@@ -1,13 +1,15 @@
 ![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)
 
-[![Node Version](https://img.shields.io/badge/nodejs-12,_14,_16,_17,_18-green.svg?logo=node.js&style=flat)](https://nodejs.org)
+[![Node Version](https://img.shields.io/badge/nodejs-14,_16,_18-green.svg?logo=node.js&style=flat)](https://nodejs.org)
 [![MongoDB Version](https://img.shields.io/badge/mongodb-4.0,_4.2,_4.4,_5,_6-green.svg?logo=mongodb&style=flat)](https://www.mongodb.com)
 [![Postgres Version](https://img.shields.io/badge/postgresql-11,_12,_13,_14,_15-green.svg?logo=postgresql&style=flat)](https://www.postgresql.org)
 
@@ -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==

package/lib/Adapters/Cache/RedisCacheAdapter.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.RedisCacheAdapter = void 0;
 
-var _redis = _interopRequireDefault(require("redis"));
+var _redis = require("redis");
 
 var _logger = _interopRequireDefault(require("../../logger"));
 
@@ -28,111 +28,97 @@ const isValidTTL = ttl => typeof ttl === 'number' && ttl > 0;
 class RedisCacheAdapter {
   constructor(redisCtx, ttl = DEFAULT_REDIS_TTL) {
     this.ttl = isValidTTL(ttl) ? ttl : DEFAULT_REDIS_TTL;
-    this.client = _redis.default.createClient(redisCtx);
+    this.client = (0, _redis.createClient)(redisCtx);
     this.queue = new _KeyPromiseQueue.KeyPromiseQueue();
   }
 
-  handleShutdown() {
-    if (!this.client) {
-      return Promise.resolve();
+  async connect() {
+    if (this.client.isOpen) {
+      return;
     }
 
-    return new Promise(resolve => {
-      this.client.quit(err => {
-        if (err) {
-          _logger.default.error('RedisCacheAdapter error on shutdown', {
-            error: err
-          });
-        }
+    return this.client.connect();
+  }
+
+  async handleShutdown() {
+    if (!this.client) {
+      return;
+    }
 
-        resolve();
+    try {
+      await this.client.quit();
+    } catch (err) {
+      _logger.default.error('RedisCacheAdapter error on shutdown', {
+        error: err
       });
-    });
+    }
   }
 
-  get(key) {
+  async get(key) {
     debug('get', {
       key
     });
-    return this.queue.enqueue(key, () => new Promise(resolve => {
-      this.client.get(key, function (err, res) {
-        debug('-> get', {
-          key,
-          res
-        });
-
-        if (!res) {
-          return resolve(null);
-        }
-
-        resolve(JSON.parse(res));
+
+    try {
+      await this.queue.enqueue(key);
+      const res = await this.client.get(key);
+
+      if (!res) {
+        return null;
+      }
+
+      return JSON.parse(res);
+    } catch (err) {
+      _logger.default.error('RedisCacheAdapter error on get', {
+        error: err
       });
-    }));
+    }
   }
 
-  put(key, value, ttl = this.ttl) {
+  async put(key, value, ttl = this.ttl) {
     value = JSON.stringify(value);
     debug('put', {
       key,
       value,
       ttl
     });
+    await this.queue.enqueue(key);
 
     if (ttl === 0) {
       // ttl of zero is a logical no-op, but redis cannot set expire time of zero
-      return this.queue.enqueue(key, () => Promise.resolve());
+      return;
     }
 
     if (ttl === Infinity) {
-      return this.queue.enqueue(key, () => new Promise(resolve => {
-        this.client.set(key, value, function () {
-          resolve();
-        });
-      }));
+      return this.client.set(key, value);
     }
 
     if (!isValidTTL(ttl)) {
       ttl = this.ttl;
     }
 
-    return this.queue.enqueue(key, () => new Promise(resolve => {
-      this.client.psetex(key, ttl, value, function () {
-        resolve();
-      });
-    }));
+    return this.client.set(key, value, {
+      PX: ttl
+    });
   }
 
-  del(key) {
+  async del(key) {
     debug('del', {
       key
     });
-    return this.queue.enqueue(key, () => new Promise(resolve => {
-      this.client.del(key, function () {
-        resolve();
-      });
-    }));
+    await this.queue.enqueue(key);
+    return this.client.del(key);
   }
 
-  clear() {
+  async clear() {
     debug('clear');
-    return this.queue.enqueue(FLUSH_DB_KEY, () => new Promise(resolve => {
-      this.client.flushdb(function () {
-        resolve();
-      });
-    }));
+    await this.queue.enqueue(FLUSH_DB_KEY);
+    return this.client.sendCommand(['FLUSHDB']);
   } // Used for testing
 
 
-  async getAllKeys() {
-    return new Promise((resolve, reject) => {
-      this.client.keys('*', (err, keys) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(keys);
-        }
-      });
-    });
+  getAllKeys() {
+    return this.client.keys('*');
   }
 
 }
@@ -140,4 +126,4 @@ class RedisCacheAdapter {
 exports.RedisCacheAdapter = RedisCacheAdapter;
 var _default = RedisCacheAdapter;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Adapters/Cache/RedisCacheAdapter.js"],"names":["DEFAULT_REDIS_TTL","FLUSH_DB_KEY","debug","args","message","arguments","concat","slice","length","logger","apply","isValidTTL","ttl","RedisCacheAdapter","constructor","redisCtx","client","redis","createClient","queue","KeyPromiseQueue","handleShutdown","Promise","resolve","quit","err","error","get","key","enqueue","res","JSON","parse","put","value","stringify","Infinity","set","psetex","del","clear","flushdb","getAllKeys","reject","keys"],"mappings":"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","sourcesContent":["import redis from 'redis';\nimport logger from '../../logger';\nimport { KeyPromiseQueue } from '../../KeyPromiseQueue';\n\nconst DEFAULT_REDIS_TTL = 30 * 1000; // 30 seconds in milliseconds\nconst FLUSH_DB_KEY = '__flush_db__';\n\nfunction debug(...args: any) {\n  const message = ['RedisCacheAdapter: ' + arguments[0]].concat(args.slice(1, args.length));\n  logger.debug.apply(logger, message);\n}\n\nconst isValidTTL = ttl => typeof ttl === 'number' && ttl > 0;\n\nexport class RedisCacheAdapter {\n  constructor(redisCtx, ttl = DEFAULT_REDIS_TTL) {\n    this.ttl = isValidTTL(ttl) ? ttl : DEFAULT_REDIS_TTL;\n    this.client = redis.createClient(redisCtx);\n    this.queue = new KeyPromiseQueue();\n  }\n\n  handleShutdown() {\n    if (!this.client) {\n      return Promise.resolve();\n    }\n    return new Promise(resolve => {\n      this.client.quit(err => {\n        if (err) {\n          logger.error('RedisCacheAdapter error on shutdown', { error: err });\n        }\n        resolve();\n      });\n    });\n  }\n\n  get(key) {\n    debug('get', { key });\n    return this.queue.enqueue(\n      key,\n      () =>\n        new Promise(resolve => {\n          this.client.get(key, function (err, res) {\n            debug('-> get', { key, res });\n            if (!res) {\n              return resolve(null);\n            }\n            resolve(JSON.parse(res));\n          });\n        })\n    );\n  }\n\n  put(key, value, ttl = this.ttl) {\n    value = JSON.stringify(value);\n    debug('put', { key, value, ttl });\n\n    if (ttl === 0) {\n      // ttl of zero is a logical no-op, but redis cannot set expire time of zero\n      return this.queue.enqueue(key, () => Promise.resolve());\n    }\n\n    if (ttl === Infinity) {\n      return this.queue.enqueue(\n        key,\n        () =>\n          new Promise(resolve => {\n            this.client.set(key, value, function () {\n              resolve();\n            });\n          })\n      );\n    }\n\n    if (!isValidTTL(ttl)) {\n      ttl = this.ttl;\n    }\n\n    return this.queue.enqueue(\n      key,\n      () =>\n        new Promise(resolve => {\n          this.client.psetex(key, ttl, value, function () {\n            resolve();\n          });\n        })\n    );\n  }\n\n  del(key) {\n    debug('del', { key });\n    return this.queue.enqueue(\n      key,\n      () =>\n        new Promise(resolve => {\n          this.client.del(key, function () {\n            resolve();\n          });\n        })\n    );\n  }\n\n  clear() {\n    debug('clear');\n    return this.queue.enqueue(\n      FLUSH_DB_KEY,\n      () =>\n        new Promise(resolve => {\n          this.client.flushdb(function () {\n            resolve();\n          });\n        })\n    );\n  }\n\n  // Used for testing\n  async getAllKeys() {\n    return new Promise((resolve, reject) => {\n      this.client.keys('*', (err, keys) => {\n        if (err) {\n          reject(err);\n        } else {\n          resolve(keys);\n        }\n      });\n    });\n  }\n}\n\nexport default RedisCacheAdapter;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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