parse-server 2.8.4 → 8.6.2

package/lib/Auth.js

@@ -1,16 +1,30 @@
-'use strict';
+"use strict";
 
-const cryptoUtils = require('./cryptoUtils');
-const RestQuery = require('./RestQuery');
+var _util = require("util");
+var _triggers = require("./triggers");
+var _logger = require("./logger");
+var _lruCache = require("lru-cache");
+var _RestQuery = _interopRequireDefault(require("./RestQuery"));
+var _RestWrite = _interopRequireDefault(require("./RestWrite"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const Parse = require('parse/node');
-
 // An Auth object tells you who is requesting something and whether
 // the master key was used.
 // userObject is a Parse.User and can be null if there's no user.
-function Auth({ config, isMaster = false, isReadOnly = false, user, installationId } = {}) {
+function Auth({
+  config,
+  cacheController = undefined,
+  isMaster = false,
+  isMaintenance = false,
+  isReadOnly = false,
+  user,
+  installationId
+}) {
   this.config = config;
+  this.cacheController = cacheController || config && config.cacheController;
   this.installationId = installationId;
   this.isMaster = isMaster;
+  this.isMaintenance = isMaintenance;
   this.user = user;
   this.isReadOnly = isReadOnly;
 
@@ -27,6 +41,9 @@ Auth.prototype.isUnauthenticated = function () {
   if (this.isMaster) {
     return false;
   }
+  if (this.isMaintenance) {
+    return false;
+  }
   if (this.user) {
     return false;
   }
@@ -35,60 +52,200 @@ Auth.prototype.isUnauthenticated = function () {
 
 // A helper to get a master-level Auth object
 function master(config) {
-  return new Auth({ config, isMaster: true });
+  return new Auth({
+    config,
+    isMaster: true
+  });
+}
+
+// A helper to get a maintenance-level Auth object
+function maintenance(config) {
+  return new Auth({
+    config,
+    isMaintenance: true
+  });
 }
 
 // A helper to get a master-level Auth object
 function readOnly(config) {
-  return new Auth({ config, isMaster: true, isReadOnly: true });
+  return new Auth({
+    config,
+    isMaster: true,
+    isReadOnly: true
+  });
 }
 
 // A helper to get a nobody-level Auth object
 function nobody(config) {
-  return new Auth({ config, isMaster: false });
+  return new Auth({
+    config,
+    isMaster: false
+  });
+}
+const throttle = new _lruCache.LRUCache({
+  max: 10000,
+  ttl: 500
+});
+/**
+ * Checks whether session should be updated based on last update time & session length.
+ */
+function shouldUpdateSessionExpiry(config, session) {
+  const resetAfter = config.sessionLength / 2;
+  const lastUpdated = new Date(session?.updatedAt);
+  const skipRange = new Date();
+  skipRange.setTime(skipRange.getTime() - resetAfter * 1000);
+  return lastUpdated <= skipRange;
 }
+const renewSessionIfNeeded = async ({
+  config,
+  session,
+  sessionToken
+}) => {
+  if (!config?.extendSessionOnUse) {
+    return;
+  }
+  if (throttle.get(sessionToken)) {
+    return;
+  }
+  throttle.set(sessionToken, true);
+  try {
+    if (!session) {
+      const query = await (0, _RestQuery.default)({
+        method: _RestQuery.default.Method.get,
+        config,
+        auth: master(config),
+        runBeforeFind: false,
+        className: '_Session',
+        restWhere: {
+          sessionToken
+        },
+        restOptions: {
+          limit: 1
+        }
+      });
+      const {
+        results
+      } = await query.execute();
+      session = results[0];
+    }
+    if (!shouldUpdateSessionExpiry(config, session) || !session) {
+      return;
+    }
+    const expiresAt = config.generateSessionExpiresAt();
+    await new _RestWrite.default(config, master(config), '_Session', {
+      objectId: session.objectId
+    }, {
+      expiresAt: Parse._encode(expiresAt)
+    }).execute();
+  } catch (e) {
+    if (e?.code !== Parse.Error.OBJECT_NOT_FOUND) {
+      _logger.logger.error('Could not update session expiry: ', e);
+    }
+  }
+};
 
 // Returns a promise that resolves to an Auth object
-var getAuthForSessionToken = function ({ config, sessionToken, installationId } = {}) {
-  return config.cacheController.user.get(sessionToken).then(userJSON => {
+const getAuthForSessionToken = async function ({
+  config,
+  cacheController,
+  sessionToken,
+  installationId
+}) {
+  cacheController = cacheController || config && config.cacheController;
+  if (cacheController) {
+    const userJSON = await cacheController.user.get(sessionToken);
     if (userJSON) {
       const cachedUser = Parse.Object.fromJSON(userJSON);
-      return Promise.resolve(new Auth({ config, isMaster: false, installationId, user: cachedUser }));
+      renewSessionIfNeeded({
+        config,
+        sessionToken
+      });
+      return Promise.resolve(new Auth({
+        config,
+        cacheController,
+        isMaster: false,
+        installationId,
+        user: cachedUser
+      }));
     }
-
-    var restOptions = {
+  }
+  let results;
+  if (config) {
+    const restOptions = {
       limit: 1,
       include: 'user'
     };
-
-    var query = new RestQuery(config, master(config), '_Session', { sessionToken }, restOptions);
-    return query.execute().then(response => {
-      var results = response.results;
-      if (results.length !== 1 || !results[0]['user']) {
-        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');
-      }
-
-      var now = new Date(),
-          expiresAt = results[0].expiresAt ? new Date(results[0].expiresAt.iso) : undefined;
-      if (expiresAt < now) {
-        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token is expired.');
-      }
-      var obj = results[0]['user'];
-      delete obj.password;
-      obj['className'] = '_User';
-      obj['sessionToken'] = sessionToken;
-      config.cacheController.user.put(sessionToken, obj);
-      const userObject = Parse.Object.fromJSON(obj);
-      return new Auth({ config, isMaster: false, installationId, user: userObject });
+    const RestQuery = require('./RestQuery');
+    const query = await RestQuery({
+      method: RestQuery.Method.get,
+      config,
+      runBeforeFind: false,
+      auth: master(config),
+      className: '_Session',
+      restWhere: {
+        sessionToken
+      },
+      restOptions
     });
+    results = (await query.execute()).results;
+  } else {
+    results = (await new Parse.Query(Parse.Session).limit(1).include('user').equalTo('sessionToken', sessionToken).find({
+      useMasterKey: true
+    })).map(obj => obj.toJSON());
+  }
+  if (results.length !== 1 || !results[0]['user']) {
+    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');
+  }
+  const session = results[0];
+  const now = new Date(),
+    expiresAt = session.expiresAt ? new Date(session.expiresAt.iso) : undefined;
+  if (expiresAt < now) {
+    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token is expired.');
+  }
+  const obj = session.user;
+  if (typeof obj['objectId'] === 'string' && obj['objectId'].startsWith('role:')) {
+    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Invalid object ID.');
+  }
+  delete obj.password;
+  obj['className'] = '_User';
+  obj['sessionToken'] = sessionToken;
+  if (cacheController) {
+    cacheController.user.put(sessionToken, obj);
+  }
+  renewSessionIfNeeded({
+    config,
+    session,
+    sessionToken
+  });
+  const userObject = Parse.Object.fromJSON(obj);
+  return new Auth({
+    config,
+    cacheController,
+    isMaster: false,
+    installationId,
+    user: userObject
   });
 };
-
-var getAuthForLegacySessionToken = function ({ config, sessionToken, installationId } = {}) {
+var getAuthForLegacySessionToken = async function ({
+  config,
+  sessionToken,
+  installationId
+}) {
   var restOptions = {
     limit: 1
   };
-  var query = new RestQuery(config, master(config), '_User', { sessionToken: sessionToken }, restOptions);
+  const RestQuery = require('./RestQuery');
+  var query = await RestQuery({
+    method: RestQuery.Method.get,
+    config,
+    runBeforeFind: false,
+    auth: master(config),
+    className: '_User',
+    restWhere: {
+      _session_token: sessionToken
+    },
+    restOptions
+  });
   return query.execute().then(response => {
     var results = response.results;
     if (results.length !== 1) {
@@ -97,13 +254,18 @@ var getAuthForLegacySessionToken = function ({ config, sessionToken, installatio
     const obj = results[0];
     obj.className = '_User';
     const userObject = Parse.Object.fromJSON(obj);
-    return new Auth({ config, isMaster: false, installationId, user: userObject });
+    return new Auth({
+      config,
+      isMaster: false,
+      installationId,
+      user: userObject
+    });
   });
 };
 
 // Returns a promise that resolves to an array of role names
 Auth.prototype.getUserRoles = function () {
-  if (this.isMaster || !this.user) {
+  if (this.isMaster || this.isMaintenance || !this.user) {
     return Promise.resolve([]);
   }
   if (this.fetchedRoles) {
@@ -115,84 +277,140 @@ Auth.prototype.getUserRoles = function () {
   this.rolePromise = this._loadRoles();
   return this.rolePromise;
 };
+Auth.prototype.getRolesForUser = async function () {
+  //Stack all Parse.Role
+  const results = [];
+  if (this.config) {
+    const restWhere = {
+      users: {
+        __type: 'Pointer',
+        className: '_User',
+        objectId: this.user.id
+      }
+    };
+    const RestQuery = require('./RestQuery');
+    const query = await RestQuery({
+      method: RestQuery.Method.find,
+      runBeforeFind: false,
+      config: this.config,
+      auth: master(this.config),
+      className: '_Role',
+      restWhere
+    });
+    await query.each(result => results.push(result));
+  } else {
+    await new Parse.Query(Parse.Role).equalTo('users', this.user).each(result => results.push(result.toJSON()), {
+      useMasterKey: true
+    });
+  }
+  return results;
+};
 
-// Iterates through the role tree and compiles a users roles
-Auth.prototype._loadRoles = function () {
-  var cacheAdapter = this.config.cacheController;
-  return cacheAdapter.role.get(this.user.id).then(cachedRoles => {
+// Iterates through the role tree and compiles a user's roles
+Auth.prototype._loadRoles = async function () {
+  if (this.cacheController) {
+    const cachedRoles = await this.cacheController.role.get(this.user.id);
     if (cachedRoles != null) {
       this.fetchedRoles = true;
       this.userRoles = cachedRoles;
-      return Promise.resolve(cachedRoles);
+      return cachedRoles;
     }
+  }
+
+  // First get the role ids this user is directly a member of
+  const results = await this.getRolesForUser();
+  if (!results.length) {
+    this.userRoles = [];
+    this.fetchedRoles = true;
+    this.rolePromise = null;
+    this.cacheRoles();
+    return this.userRoles;
+  }
+  const rolesMap = results.reduce((m, r) => {
+    m.names.push(r.name);
+    m.ids.push(r.objectId);
+    return m;
+  }, {
+    ids: [],
+    names: []
+  });
 
-    var restWhere = {
-      'users': {
+  // run the recursive finding
+  const roleNames = await this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names);
+  this.userRoles = roleNames.map(r => {
+    return 'role:' + r;
+  });
+  this.fetchedRoles = true;
+  this.rolePromise = null;
+  this.cacheRoles();
+  return this.userRoles;
+};
+Auth.prototype.cacheRoles = function () {
+  if (!this.cacheController) {
+    return false;
+  }
+  this.cacheController.role.put(this.user.id, Array(...this.userRoles));
+  return true;
+};
+Auth.prototype.clearRoleCache = function (sessionToken) {
+  if (!this.cacheController) {
+    return false;
+  }
+  this.cacheController.role.del(this.user.id);
+  this.cacheController.user.del(sessionToken);
+  return true;
+};
+Auth.prototype.getRolesByIds = async function (ins) {
+  const results = [];
+  // Build an OR query across all parentRoles
+  if (!this.config) {
+    await new Parse.Query(Parse.Role).containedIn('roles', ins.map(id => {
+      const role = new Parse.Object(Parse.Role);
+      role.id = id;
+      return role;
+    })).each(result => results.push(result.toJSON()), {
+      useMasterKey: true
+    });
+  } else {
+    const roles = ins.map(id => {
+      return {
         __type: 'Pointer',
-        className: '_User',
-        objectId: this.user.id
+        className: '_Role',
+        objectId: id
+      };
+    });
+    const restWhere = {
+      roles: {
+        $in: roles
       }
     };
-    // First get the role ids this user is directly a member of
-    var query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});
-    return query.execute().then(response => {
-      var results = response.results;
-      if (!results.length) {
-        this.userRoles = [];
-        this.fetchedRoles = true;
-        this.rolePromise = null;
-
-        cacheAdapter.role.put(this.user.id, Array(...this.userRoles));
-        return Promise.resolve(this.userRoles);
-      }
-      var rolesMap = results.reduce((m, r) => {
-        m.names.push(r.name);
-        m.ids.push(r.objectId);
-        return m;
-      }, { ids: [], names: [] });
-
-      // run the recursive finding
-      return this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names).then(roleNames => {
-        this.userRoles = roleNames.map(r => {
-          return 'role:' + r;
-        });
-        this.fetchedRoles = true;
-        this.rolePromise = null;
-        cacheAdapter.role.put(this.user.id, Array(...this.userRoles));
-        return Promise.resolve(this.userRoles);
-      });
+    const RestQuery = require('./RestQuery');
+    const query = await RestQuery({
+      method: RestQuery.Method.find,
+      config: this.config,
+      runBeforeFind: false,
+      auth: master(this.config),
+      className: '_Role',
+      restWhere
     });
-  });
+    await query.each(result => results.push(result));
+  }
+  return results;
 };
 
 // Given a list of roleIds, find all the parent roles, returns a promise with all names
 Auth.prototype._getAllRolesNamesForRoleIds = function (roleIDs, names = [], queriedRoles = {}) {
   const ins = roleIDs.filter(roleID => {
-    return queriedRoles[roleID] !== true;
-  }).map(roleID => {
-    // mark as queried
+    const wasQueried = queriedRoles[roleID] !== true;
     queriedRoles[roleID] = true;
-    return {
-      __type: 'Pointer',
-      className: '_Role',
-      objectId: roleID
-    };
+    return wasQueried;
   });
 
   // all roles are accounted for, return the names
   if (ins.length == 0) {
     return Promise.resolve([...new Set(names)]);
   }
-  // Build an OR query across all parentRoles
-  let restWhere;
-  if (ins.length == 1) {
-    restWhere = { 'roles': ins[0] };
-  } else {
-    restWhere = { 'roles': { '$in': ins } };
-  }
-  const query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});
-  return query.execute().then(response => {
-    var results = response.results;
+  return this.getRolesByIds(ins).then(results => {
     // Nothing found
     if (!results.length) {
       return Promise.resolve(names);
@@ -202,7 +420,10 @@ Auth.prototype._getAllRolesNamesForRoleIds = function (roleIDs, names = [], quer
       memo.names.push(role.name);
       memo.ids.push(role.objectId);
       return memo;
-    }, { ids: [], names: [] });
+    }, {
+      ids: [],
+      names: []
+    });
     // store the new found names
     names = names.concat(resultMap.names);
     // find the next ones, circular roles will be cut
@@ -211,48 +432,190 @@ Auth.prototype._getAllRolesNamesForRoleIds = function (roleIDs, names = [], quer
     return Promise.resolve([...new Set(names)]);
   });
 };
+const findUsersWithAuthData = async (config, authData, beforeFind) => {
+  const providers = Object.keys(authData);
+  const queries = await Promise.all(providers.map(async provider => {
+    const providerAuthData = authData[provider];
+    const adapter = config.authDataManager.getValidatorForProvider(provider)?.adapter;
+    if (beforeFind && typeof adapter?.beforeFind === 'function') {
+      await adapter.beforeFind(providerAuthData);
+    }
+    if (!providerAuthData?.id) {
+      return null;
+    }
+    return {
+      [`authData.${provider}.id`]: providerAuthData.id
+    };
+  }));
 
-const createSession = function (config, {
-  userId,
-  createdWith,
-  installationId,
-  additionalSessionData
-}) {
-  const token = 'r:' + cryptoUtils.newToken();
-  const expiresAt = config.generateSessionExpiresAt();
-  const sessionData = {
-    sessionToken: token,
-    user: {
-      __type: 'Pointer',
-      className: '_User',
-      objectId: userId
-    },
-    createdWith,
-    restricted: false,
-    expiresAt: Parse._encode(expiresAt)
-  };
-
-  if (installationId) {
-    sessionData.installationId = installationId;
+  // Filter out null queries
+  const validQueries = queries.filter(query => query !== null);
+  if (!validQueries.length) {
+    return [];
   }
 
-  Object.assign(sessionData, additionalSessionData);
-  // We need to import RestWrite at this point for the cyclic dependency it has to it
-  const RestWrite = require('./RestWrite');
-
+  // Perform database query
+  return config.database.find('_User', {
+    $or: validQueries
+  }, {
+    limit: 2
+  });
+};
+const hasMutatedAuthData = (authData, userAuthData) => {
+  if (!userAuthData) {
+    return {
+      hasMutatedAuthData: true,
+      mutatedAuthData: authData
+    };
+  }
+  const mutatedAuthData = {};
+  Object.keys(authData).forEach(provider => {
+    // Anonymous provider is not handled this way
+    if (provider === 'anonymous') {
+      return;
+    }
+    const providerData = authData[provider];
+    const userProviderAuthData = userAuthData[provider];
+    if (!(0, _util.isDeepStrictEqual)(providerData, userProviderAuthData)) {
+      mutatedAuthData[provider] = providerData;
+    }
+  });
+  const hasMutatedAuthData = Object.keys(mutatedAuthData).length !== 0;
   return {
-    sessionData,
-    createSession: () => new RestWrite(config, master(config), '_Session', null, sessionData).execute()
+    hasMutatedAuthData,
+    mutatedAuthData
   };
 };
+const checkIfUserHasProvidedConfiguredProvidersForLogin = (req = {}, authData = {}, userAuthData = {}, config) => {
+  const savedUserProviders = Object.keys(userAuthData).map(provider => ({
+    name: provider,
+    adapter: config.authDataManager.getValidatorForProvider(provider).adapter
+  }));
+  const hasProvidedASoloProvider = savedUserProviders.some(provider => provider && provider.adapter && provider.adapter.policy === 'solo' && authData[provider.name]);
+
+  // Solo providers can be considered as safe, so we do not have to check if the user needs
+  // to provide an additional provider to login. An auth adapter with "solo" (like webauthn) means
+  // no "additional" auth needs to be provided to login (like OTP, MFA)
+  if (hasProvidedASoloProvider) {
+    return;
+  }
+  const additionProvidersNotFound = [];
+  const hasProvidedAtLeastOneAdditionalProvider = savedUserProviders.some(provider => {
+    let policy = provider.adapter.policy;
+    if (typeof policy === 'function') {
+      const requestObject = {
+        ip: req.config.ip,
+        user: req.auth.user,
+        master: req.auth.isMaster
+      };
+      policy = policy.call(provider.adapter, requestObject, userAuthData[provider.name]);
+    }
+    if (policy === 'additional') {
+      if (authData[provider.name]) {
+        return true;
+      } else {
+        // Push missing provider for error message
+        additionProvidersNotFound.push(provider.name);
+      }
+    }
+  });
+  if (hasProvidedAtLeastOneAdditionalProvider || !additionProvidersNotFound.length) {
+    return;
+  }
+  throw new Parse.Error(Parse.Error.OTHER_CAUSE, `Missing additional authData ${additionProvidersNotFound.join(',')}`);
+};
 
+// Validate each authData step-by-step and return the provider responses
+const handleAuthDataValidation = async (authData, req, foundUser) => {
+  let user;
+  if (foundUser) {
+    user = Parse.User.fromJSON({
+      className: '_User',
+      ...foundUser
+    });
+    // Find user by session and current objectId; only pass user if it's the current user or master key is provided
+  } else if (req.auth && req.auth.user && typeof req.getUserId === 'function' && req.getUserId() === req.auth.user.id || req.auth && req.auth.isMaster && typeof req.getUserId === 'function' && req.getUserId()) {
+    user = new Parse.User();
+    user.id = req.auth.isMaster ? req.getUserId() : req.auth.user.id;
+    await user.fetch({
+      useMasterKey: true
+    });
+  }
+  const {
+    updatedObject
+  } = req.buildParseObjects();
+  const requestObject = (0, _triggers.getRequestObject)(undefined, req.auth, updatedObject, user, req.config);
+  // Perform validation as step-by-step pipeline for better error consistency
+  // and also to avoid to trigger a provider (like OTP SMS) if another one fails
+  const acc = {
+    authData: {},
+    authDataResponse: {}
+  };
+  const authKeys = Object.keys(authData).sort();
+  for (const provider of authKeys) {
+    let method = '';
+    try {
+      if (authData[provider] === null) {
+        acc.authData[provider] = null;
+        continue;
+      }
+      const {
+        validator
+      } = req.config.authDataManager.getValidatorForProvider(provider) || {};
+      const authProvider = (req.config.auth || {})[provider] || {};
+      if (!validator || authProvider.enabled === false) {
+        throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE, 'This authentication method is unsupported.');
+      }
+      let validationResult = await validator(authData[provider], req, user, requestObject);
+      method = validationResult && validationResult.method;
+      requestObject.triggerName = method;
+      if (validationResult && validationResult.validator) {
+        validationResult = await validationResult.validator();
+      }
+      if (!validationResult) {
+        acc.authData[provider] = authData[provider];
+        continue;
+      }
+      if (!Object.keys(validationResult).length) {
+        acc.authData[provider] = authData[provider];
+        continue;
+      }
+      if (validationResult.response) {
+        acc.authDataResponse[provider] = validationResult.response;
+      }
+      // Some auth providers after initialization will avoid to replace authData already stored
+      if (!validationResult.doNotSave) {
+        acc.authData[provider] = validationResult.save || authData[provider];
+      }
+    } catch (err) {
+      const e = (0, _triggers.resolveError)(err, {
+        code: Parse.Error.SCRIPT_FAILED,
+        message: 'Auth failed. Unknown error.'
+      });
+      const userString = req.auth && req.auth.user ? req.auth.user.id : req.data.objectId || undefined;
+      _logger.logger.error(`Failed running auth step ${method} for ${provider} for user ${userString} with Error: ` + JSON.stringify(e), {
+        authenticationStep: method,
+        error: e,
+        user: userString,
+        provider
+      });
+      throw e;
+    }
+  }
+  return acc;
+};
 module.exports = {
   Auth,
   master,
+  maintenance,
   nobody,
   readOnly,
+  shouldUpdateSessionExpiry,
   getAuthForSessionToken,
   getAuthForLegacySessionToken,
-  createSession
+  findUsersWithAuthData,
+  hasMutatedAuthData,
+  checkIfUserHasProvidedConfiguredProvidersForLogin,
+  handleAuthDataValidation
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Auth.js"],"names":["cryptoUtils","require","RestQuery","Parse","Auth","config","isMaster","isReadOnly","user","installationId","userRoles","fetchedRoles","rolePromise","prototype","isUnauthenticated","master","readOnly","nobody","getAuthForSessionToken","sessionToken","cacheController","get","then","userJSON","cachedUser","Object","fromJSON","Promise","resolve","restOptions","limit","include","query","execute","response","results","length","Error","INVALID_SESSION_TOKEN","now","Date","expiresAt","iso","undefined","obj","password","put","userObject","getAuthForLegacySessionToken","className","getUserRoles","_loadRoles","cacheAdapter","role","id","cachedRoles","restWhere","__type","objectId","Array","rolesMap","reduce","m","r","names","push","name","ids","_getAllRolesNamesForRoleIds","roleNames","map","roleIDs","queriedRoles","ins","filter","roleID","Set","resultMap","memo","concat","createSession","userId","createdWith","additionalSessionData","token","newToken","generateSessionExpiresAt","sessionData","restricted","_encode","assign","RestWrite","module","exports"],"mappings":"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","file":"Auth.js","sourcesContent":["const cryptoUtils = require('./cryptoUtils');\nconst RestQuery = require('./RestQuery');\nconst Parse = require('parse/node');\n\n// An Auth object tells you who is requesting something and whether\n// the master key was used.\n// userObject is a Parse.User and can be null if there's no user.\nfunction Auth({ config, isMaster = false, isReadOnly = false, user, installationId } = {}) {\n  this.config = config;\n  this.installationId = installationId;\n  this.isMaster = isMaster;\n  this.user = user;\n  this.isReadOnly = isReadOnly;\n\n  // Assuming a users roles won't change during a single request, we'll\n  // only load them once.\n  this.userRoles = [];\n  this.fetchedRoles = false;\n  this.rolePromise = null;\n}\n\n// Whether this auth could possibly modify the given user id.\n// It still could be forbidden via ACLs even if this returns true.\nAuth.prototype.isUnauthenticated = function() {\n  if (this.isMaster) {\n    return false;\n  }\n  if (this.user) {\n    return false;\n  }\n  return true;\n};\n\n// A helper to get a master-level Auth object\nfunction master(config) {\n  return new Auth({ config, isMaster: true });\n}\n\n// A helper to get a master-level Auth object\nfunction readOnly(config) {\n  return new Auth({ config, isMaster: true, isReadOnly: true });\n}\n\n// A helper to get a nobody-level Auth object\nfunction nobody(config) {\n  return new Auth({ config, isMaster: false });\n}\n\n\n// Returns a promise that resolves to an Auth object\nvar getAuthForSessionToken = function({ config, sessionToken, installationId } = {}) {\n  return config.cacheController.user.get(sessionToken).then((userJSON) => {\n    if (userJSON) {\n      const cachedUser = Parse.Object.fromJSON(userJSON);\n      return Promise.resolve(new Auth({config, isMaster: false, installationId, user: cachedUser}));\n    }\n\n    var restOptions = {\n      limit: 1,\n      include: 'user'\n    };\n\n    var query = new RestQuery(config, master(config), '_Session', {sessionToken}, restOptions);\n    return query.execute().then((response) => {\n      var results = response.results;\n      if (results.length !== 1 || !results[0]['user']) {\n        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n      }\n\n      var now = new Date(),\n        expiresAt = results[0].expiresAt ? new Date(results[0].expiresAt.iso) : undefined;\n      if (expiresAt < now) {\n        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,\n          'Session token is expired.');\n      }\n      var obj = results[0]['user'];\n      delete obj.password;\n      obj['className'] = '_User';\n      obj['sessionToken'] = sessionToken;\n      config.cacheController.user.put(sessionToken, obj);\n      const userObject = Parse.Object.fromJSON(obj);\n      return new Auth({config, isMaster: false, installationId, user: userObject});\n    });\n  });\n};\n\nvar getAuthForLegacySessionToken = function({config, sessionToken, installationId } = {}) {\n  var restOptions = {\n    limit: 1\n  };\n  var query = new RestQuery(config, master(config), '_User', { sessionToken: sessionToken}, restOptions);\n  return query.execute().then((response) => {\n    var results = response.results;\n    if (results.length !== 1) {\n      throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid legacy session token');\n    }\n    const obj = results[0];\n    obj.className = '_User';\n    const userObject = Parse.Object.fromJSON(obj);\n    return new Auth({config, isMaster: false, installationId, user: userObject});\n  });\n}\n\n// Returns a promise that resolves to an array of role names\nAuth.prototype.getUserRoles = function() {\n  if (this.isMaster || !this.user) {\n    return Promise.resolve([]);\n  }\n  if (this.fetchedRoles) {\n    return Promise.resolve(this.userRoles);\n  }\n  if (this.rolePromise) {\n    return this.rolePromise;\n  }\n  this.rolePromise = this._loadRoles();\n  return this.rolePromise;\n};\n\n// Iterates through the role tree and compiles a users roles\nAuth.prototype._loadRoles = function() {\n  var cacheAdapter = this.config.cacheController;\n  return cacheAdapter.role.get(this.user.id).then((cachedRoles) => {\n    if (cachedRoles != null) {\n      this.fetchedRoles = true;\n      this.userRoles = cachedRoles;\n      return Promise.resolve(cachedRoles);\n    }\n\n    var restWhere = {\n      'users': {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: this.user.id\n      }\n    };\n    // First get the role ids this user is directly a member of\n    var query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});\n    return query.execute().then((response) => {\n      var results = response.results;\n      if (!results.length) {\n        this.userRoles = [];\n        this.fetchedRoles = true;\n        this.rolePromise = null;\n\n        cacheAdapter.role.put(this.user.id, Array(...this.userRoles));\n        return Promise.resolve(this.userRoles);\n      }\n      var rolesMap = results.reduce((m, r) => {\n        m.names.push(r.name);\n        m.ids.push(r.objectId);\n        return m;\n      }, {ids: [], names: []});\n\n      // run the recursive finding\n      return this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names)\n        .then((roleNames) => {\n          this.userRoles = roleNames.map((r) => {\n            return 'role:' + r;\n          });\n          this.fetchedRoles = true;\n          this.rolePromise = null;\n          cacheAdapter.role.put(this.user.id, Array(...this.userRoles));\n          return Promise.resolve(this.userRoles);\n        });\n    });\n  });\n};\n\n// Given a list of roleIds, find all the parent roles, returns a promise with all names\nAuth.prototype._getAllRolesNamesForRoleIds = function(roleIDs, names = [], queriedRoles = {}) {\n  const ins = roleIDs.filter((roleID) => {\n    return queriedRoles[roleID] !== true;\n  }).map((roleID) => {\n    // mark as queried\n    queriedRoles[roleID] = true;\n    return {\n      __type: 'Pointer',\n      className: '_Role',\n      objectId: roleID\n    }\n  });\n\n  // all roles are accounted for, return the names\n  if (ins.length == 0) {\n    return Promise.resolve([...new Set(names)]);\n  }\n  // Build an OR query across all parentRoles\n  let restWhere;\n  if (ins.length == 1) {\n    restWhere = { 'roles': ins[0] };\n  } else {\n    restWhere = { 'roles': { '$in': ins }}\n  }\n  const query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});\n  return query.execute().then((response) => {\n    var results = response.results;\n    // Nothing found\n    if (!results.length) {\n      return Promise.resolve(names);\n    }\n    // Map the results with all Ids and names\n    const resultMap = results.reduce((memo, role) => {\n      memo.names.push(role.name);\n      memo.ids.push(role.objectId);\n      return memo;\n    }, {ids: [], names: []});\n    // store the new found names\n    names = names.concat(resultMap.names);\n    // find the next ones, circular roles will be cut\n    return this._getAllRolesNamesForRoleIds(resultMap.ids, names, queriedRoles)\n  }).then((names) => {\n    return Promise.resolve([...new Set(names)])\n  })\n}\n\nconst createSession = function(config, {\n  userId,\n  createdWith,\n  installationId,\n  additionalSessionData,\n}) {\n  const token = 'r:' + cryptoUtils.newToken();\n  const expiresAt = config.generateSessionExpiresAt();\n  const sessionData = {\n    sessionToken: token,\n    user: {\n      __type: 'Pointer',\n      className: '_User',\n      objectId: userId\n    },\n    createdWith,\n    restricted: false,\n    expiresAt: Parse._encode(expiresAt)\n  };\n\n  if (installationId) {\n    sessionData.installationId = installationId\n  }\n\n  Object.assign(sessionData, additionalSessionData);\n  // We need to import RestWrite at this point for the cyclic dependency it has to it\n  const RestWrite = require('./RestWrite');\n\n  return {\n    sessionData,\n    createSession: () => new RestWrite(config, master(config), '_Session', null, sessionData).execute()\n  }\n}\n\nmodule.exports = {\n  Auth,\n  master,\n  nobody,\n  readOnly,\n  getAuthForSessionToken,\n  getAuthForLegacySessionToken,\n  createSession,\n};\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_util","require","_triggers","_logger","_lruCache","_RestQuery","_interopRequireDefault","_RestWrite","e","__esModule","default","Parse","Auth","config","cacheController","undefined","isMaster","isMaintenance","isReadOnly","user","installationId","userRoles","fetchedRoles","rolePromise","prototype","isUnauthenticated","master","maintenance","readOnly","nobody","throttle","LRU","max","ttl","shouldUpdateSessionExpiry","session","resetAfter","sessionLength","lastUpdated","Date","updatedAt","skipRange","setTime","getTime","renewSessionIfNeeded","sessionToken","extendSessionOnUse","get","set","query","RestQuery","method","Method","auth","runBeforeFind","className","restWhere","restOptions","limit","results","execute","expiresAt","generateSessionExpiresAt","RestWrite","objectId","_encode","code","Error","OBJECT_NOT_FOUND","logger","error","getAuthForSessionToken","userJSON","cachedUser","Object","fromJSON","Promise","resolve","include","Query","Session","equalTo","find","useMasterKey","map","obj","toJSON","length","INVALID_SESSION_TOKEN","now","iso","startsWith","INTERNAL_SERVER_ERROR","password","put","userObject","getAuthForLegacySessionToken","_session_token","then","response","getUserRoles","_loadRoles","getRolesForUser","users","__type","id","each","result","push","Role","cachedRoles","role","cacheRoles","rolesMap","reduce","m","r","names","name","ids","roleNames","_getAllRolesNamesForRoleIds","Array","clearRoleCache","del","getRolesByIds","ins","containedIn","roles","$in","roleIDs","queriedRoles","filter","roleID","wasQueried","Set","resultMap","memo","concat","findUsersWithAuthData","authData","beforeFind","providers","keys","queries","all","provider","providerAuthData","adapter","authDataManager","getValidatorForProvider","validQueries","database","$or","hasMutatedAuthData","userAuthData","mutatedAuthData","forEach","providerData","userProviderAuthData","isDeepStrictEqual","checkIfUserHasProvidedConfiguredProvidersForLogin","req","savedUserProviders","hasProvidedASoloProvider","some","policy","additionProvidersNotFound","hasProvidedAtLeastOneAdditionalProvider","requestObject","ip","call","OTHER_CAUSE","join","handleAuthDataValidation","foundUser","User","getUserId","fetch","updatedObject","buildParseObjects","getRequestObject","acc","authDataResponse","authKeys","sort","validator","authProvider","enabled","UNSUPPORTED_SERVICE","validationResult","triggerName","doNotSave","save","err","resolveError","SCRIPT_FAILED","message","userString","data","JSON","stringify","authenticationStep","module","exports"],"sources":["../src/Auth.js"],"sourcesContent":["const Parse = require('parse/node');\nimport { isDeepStrictEqual } from 'util';\nimport { getRequestObject, resolveError } from './triggers';\nimport { logger } from './logger';\nimport { LRUCache as LRU } from 'lru-cache';\nimport RestQuery from './RestQuery';\nimport RestWrite from './RestWrite';\n\n// An Auth object tells you who is requesting something and whether\n// the master key was used.\n// userObject is a Parse.User and can be null if there's no user.\nfunction Auth({\n  config,\n  cacheController = undefined,\n  isMaster = false,\n  isMaintenance = false,\n  isReadOnly = false,\n  user,\n  installationId,\n}) {\n  this.config = config;\n  this.cacheController = cacheController || (config && config.cacheController);\n  this.installationId = installationId;\n  this.isMaster = isMaster;\n  this.isMaintenance = isMaintenance;\n  this.user = user;\n  this.isReadOnly = isReadOnly;\n\n  // Assuming a users roles won't change during a single request, we'll\n  // only load them once.\n  this.userRoles = [];\n  this.fetchedRoles = false;\n  this.rolePromise = null;\n}\n\n// Whether this auth could possibly modify the given user id.\n// It still could be forbidden via ACLs even if this returns true.\nAuth.prototype.isUnauthenticated = function () {\n  if (this.isMaster) {\n    return false;\n  }\n  if (this.isMaintenance) {\n    return false;\n  }\n  if (this.user) {\n    return false;\n  }\n  return true;\n};\n\n// A helper to get a master-level Auth object\nfunction master(config) {\n  return new Auth({ config, isMaster: true });\n}\n\n// A helper to get a maintenance-level Auth object\nfunction maintenance(config) {\n  return new Auth({ config, isMaintenance: true });\n}\n\n// A helper to get a master-level Auth object\nfunction readOnly(config) {\n  return new Auth({ config, isMaster: true, isReadOnly: true });\n}\n\n// A helper to get a nobody-level Auth object\nfunction nobody(config) {\n  return new Auth({ config, isMaster: false });\n}\n\nconst throttle = new LRU({\n  max: 10000,\n  ttl: 500,\n});\n/**\n * Checks whether session should be updated based on last update time & session length.\n */\nfunction shouldUpdateSessionExpiry(config, session) {\n  const resetAfter = config.sessionLength / 2;\n  const lastUpdated = new Date(session?.updatedAt);\n  const skipRange = new Date();\n  skipRange.setTime(skipRange.getTime() - resetAfter * 1000);\n  return lastUpdated <= skipRange;\n}\n\nconst renewSessionIfNeeded = async ({ config, session, sessionToken }) => {\n  if (!config?.extendSessionOnUse) {\n    return;\n  }\n  if (throttle.get(sessionToken)) {\n    return;\n  }\n  throttle.set(sessionToken, true);\n  try {\n    if (!session) {\n      const query = await RestQuery({\n        method: RestQuery.Method.get,\n        config,\n        auth: master(config),\n        runBeforeFind: false,\n        className: '_Session',\n        restWhere: { sessionToken },\n        restOptions: { limit: 1 },\n      });\n      const { results } = await query.execute();\n      session = results[0];\n    }\n\n    if (!shouldUpdateSessionExpiry(config, session) || !session) {\n      return;\n    }\n    const expiresAt = config.generateSessionExpiresAt();\n    await new RestWrite(\n      config,\n      master(config),\n      '_Session',\n      { objectId: session.objectId },\n      { expiresAt: Parse._encode(expiresAt) }\n    ).execute();\n  } catch (e) {\n    if (e?.code !== Parse.Error.OBJECT_NOT_FOUND) {\n      logger.error('Could not update session expiry: ', e);\n    }\n  }\n};\n\n// Returns a promise that resolves to an Auth object\nconst getAuthForSessionToken = async function ({\n  config,\n  cacheController,\n  sessionToken,\n  installationId,\n}) {\n  cacheController = cacheController || (config && config.cacheController);\n  if (cacheController) {\n    const userJSON = await cacheController.user.get(sessionToken);\n    if (userJSON) {\n      const cachedUser = Parse.Object.fromJSON(userJSON);\n      renewSessionIfNeeded({ config, sessionToken });\n      return Promise.resolve(\n        new Auth({\n          config,\n          cacheController,\n          isMaster: false,\n          installationId,\n          user: cachedUser,\n        })\n      );\n    }\n  }\n\n  let results;\n  if (config) {\n    const restOptions = {\n      limit: 1,\n      include: 'user',\n    };\n    const RestQuery = require('./RestQuery');\n    const query = await RestQuery({\n      method: RestQuery.Method.get,\n      config,\n      runBeforeFind: false,\n      auth: master(config),\n      className: '_Session',\n      restWhere: { sessionToken },\n      restOptions,\n    });\n    results = (await query.execute()).results;\n  } else {\n    results = (\n      await new Parse.Query(Parse.Session)\n        .limit(1)\n        .include('user')\n        .equalTo('sessionToken', sessionToken)\n        .find({ useMasterKey: true })\n    ).map(obj => obj.toJSON());\n  }\n\n  if (results.length !== 1 || !results[0]['user']) {\n    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n  }\n  const session = results[0];\n  const now = new Date(),\n    expiresAt = session.expiresAt ? new Date(session.expiresAt.iso) : undefined;\n  if (expiresAt < now) {\n    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token is expired.');\n  }\n  const obj = session.user;\n\n  if (typeof obj['objectId'] === 'string' && obj['objectId'].startsWith('role:')) {\n    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Invalid object ID.');\n  }\n\n  delete obj.password;\n  obj['className'] = '_User';\n  obj['sessionToken'] = sessionToken;\n  if (cacheController) {\n    cacheController.user.put(sessionToken, obj);\n  }\n  renewSessionIfNeeded({ config, session, sessionToken });\n  const userObject = Parse.Object.fromJSON(obj);\n  return new Auth({\n    config,\n    cacheController,\n    isMaster: false,\n    installationId,\n    user: userObject,\n  });\n};\n\nvar getAuthForLegacySessionToken = async function ({ config, sessionToken, installationId }) {\n  var restOptions = {\n    limit: 1,\n  };\n  const RestQuery = require('./RestQuery');\n  var query = await RestQuery({\n    method: RestQuery.Method.get,\n    config,\n    runBeforeFind: false,\n    auth: master(config),\n    className: '_User',\n    restWhere: { _session_token: sessionToken },\n    restOptions,\n  });\n  return query.execute().then(response => {\n    var results = response.results;\n    if (results.length !== 1) {\n      throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid legacy session token');\n    }\n    const obj = results[0];\n    obj.className = '_User';\n    const userObject = Parse.Object.fromJSON(obj);\n    return new Auth({\n      config,\n      isMaster: false,\n      installationId,\n      user: userObject,\n    });\n  });\n};\n\n// Returns a promise that resolves to an array of role names\nAuth.prototype.getUserRoles = function () {\n  if (this.isMaster || this.isMaintenance || !this.user) {\n    return Promise.resolve([]);\n  }\n  if (this.fetchedRoles) {\n    return Promise.resolve(this.userRoles);\n  }\n  if (this.rolePromise) {\n    return this.rolePromise;\n  }\n  this.rolePromise = this._loadRoles();\n  return this.rolePromise;\n};\n\nAuth.prototype.getRolesForUser = async function () {\n  //Stack all Parse.Role\n  const results = [];\n  if (this.config) {\n    const restWhere = {\n      users: {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: this.user.id,\n      },\n    };\n    const RestQuery = require('./RestQuery');\n    const query = await RestQuery({\n      method: RestQuery.Method.find,\n      runBeforeFind: false,\n      config: this.config,\n      auth: master(this.config),\n      className: '_Role',\n      restWhere,\n    });\n    await query.each(result => results.push(result));\n  } else {\n    await new Parse.Query(Parse.Role)\n      .equalTo('users', this.user)\n      .each(result => results.push(result.toJSON()), { useMasterKey: true });\n  }\n  return results;\n};\n\n// Iterates through the role tree and compiles a user's roles\nAuth.prototype._loadRoles = async function () {\n  if (this.cacheController) {\n    const cachedRoles = await this.cacheController.role.get(this.user.id);\n    if (cachedRoles != null) {\n      this.fetchedRoles = true;\n      this.userRoles = cachedRoles;\n      return cachedRoles;\n    }\n  }\n\n  // First get the role ids this user is directly a member of\n  const results = await this.getRolesForUser();\n  if (!results.length) {\n    this.userRoles = [];\n    this.fetchedRoles = true;\n    this.rolePromise = null;\n\n    this.cacheRoles();\n    return this.userRoles;\n  }\n\n  const rolesMap = results.reduce(\n    (m, r) => {\n      m.names.push(r.name);\n      m.ids.push(r.objectId);\n      return m;\n    },\n    { ids: [], names: [] }\n  );\n\n  // run the recursive finding\n  const roleNames = await this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names);\n  this.userRoles = roleNames.map(r => {\n    return 'role:' + r;\n  });\n  this.fetchedRoles = true;\n  this.rolePromise = null;\n  this.cacheRoles();\n  return this.userRoles;\n};\n\nAuth.prototype.cacheRoles = function () {\n  if (!this.cacheController) {\n    return false;\n  }\n  this.cacheController.role.put(this.user.id, Array(...this.userRoles));\n  return true;\n};\n\nAuth.prototype.clearRoleCache = function (sessionToken) {\n  if (!this.cacheController) {\n    return false;\n  }\n  this.cacheController.role.del(this.user.id);\n  this.cacheController.user.del(sessionToken);\n  return true;\n};\n\nAuth.prototype.getRolesByIds = async function (ins) {\n  const results = [];\n  // Build an OR query across all parentRoles\n  if (!this.config) {\n    await new Parse.Query(Parse.Role)\n      .containedIn(\n        'roles',\n        ins.map(id => {\n          const role = new Parse.Object(Parse.Role);\n          role.id = id;\n          return role;\n        })\n      )\n      .each(result => results.push(result.toJSON()), { useMasterKey: true });\n  } else {\n    const roles = ins.map(id => {\n      return {\n        __type: 'Pointer',\n        className: '_Role',\n        objectId: id,\n      };\n    });\n    const restWhere = { roles: { $in: roles } };\n    const RestQuery = require('./RestQuery');\n    const query = await RestQuery({\n      method: RestQuery.Method.find,\n      config: this.config,\n      runBeforeFind: false,\n      auth: master(this.config),\n      className: '_Role',\n      restWhere,\n    });\n    await query.each(result => results.push(result));\n  }\n  return results;\n};\n\n// Given a list of roleIds, find all the parent roles, returns a promise with all names\nAuth.prototype._getAllRolesNamesForRoleIds = function (roleIDs, names = [], queriedRoles = {}) {\n  const ins = roleIDs.filter(roleID => {\n    const wasQueried = queriedRoles[roleID] !== true;\n    queriedRoles[roleID] = true;\n    return wasQueried;\n  });\n\n  // all roles are accounted for, return the names\n  if (ins.length == 0) {\n    return Promise.resolve([...new Set(names)]);\n  }\n\n  return this.getRolesByIds(ins)\n    .then(results => {\n      // Nothing found\n      if (!results.length) {\n        return Promise.resolve(names);\n      }\n      // Map the results with all Ids and names\n      const resultMap = results.reduce(\n        (memo, role) => {\n          memo.names.push(role.name);\n          memo.ids.push(role.objectId);\n          return memo;\n        },\n        { ids: [], names: [] }\n      );\n      // store the new found names\n      names = names.concat(resultMap.names);\n      // find the next ones, circular roles will be cut\n      return this._getAllRolesNamesForRoleIds(resultMap.ids, names, queriedRoles);\n    })\n    .then(names => {\n      return Promise.resolve([...new Set(names)]);\n    });\n};\n\nconst findUsersWithAuthData = async (config, authData, beforeFind) => {\n  const providers = Object.keys(authData);\n\n  const queries = await Promise.all(\n    providers.map(async provider => {\n      const providerAuthData = authData[provider];\n\n      const adapter = config.authDataManager.getValidatorForProvider(provider)?.adapter;\n      if (beforeFind && typeof adapter?.beforeFind === 'function') {\n        await adapter.beforeFind(providerAuthData);\n      }\n\n      if (!providerAuthData?.id) {\n        return null;\n      }\n\n      return { [`authData.${provider}.id`]: providerAuthData.id };\n    })\n  );\n\n  // Filter out null queries\n  const validQueries = queries.filter(query => query !== null);\n\n  if (!validQueries.length) {\n    return [];\n  }\n\n  // Perform database query\n  return config.database.find('_User', { $or: validQueries }, { limit: 2 });\n};\n\nconst hasMutatedAuthData = (authData, userAuthData) => {\n  if (!userAuthData) { return { hasMutatedAuthData: true, mutatedAuthData: authData }; }\n  const mutatedAuthData = {};\n  Object.keys(authData).forEach(provider => {\n    // Anonymous provider is not handled this way\n    if (provider === 'anonymous') { return; }\n    const providerData = authData[provider];\n    const userProviderAuthData = userAuthData[provider];\n    if (!isDeepStrictEqual(providerData, userProviderAuthData)) {\n      mutatedAuthData[provider] = providerData;\n    }\n  });\n  const hasMutatedAuthData = Object.keys(mutatedAuthData).length !== 0;\n  return { hasMutatedAuthData, mutatedAuthData };\n};\n\nconst checkIfUserHasProvidedConfiguredProvidersForLogin = (\n  req = {},\n  authData = {},\n  userAuthData = {},\n  config\n) => {\n  const savedUserProviders = Object.keys(userAuthData).map(provider => ({\n    name: provider,\n    adapter: config.authDataManager.getValidatorForProvider(provider).adapter,\n  }));\n\n  const hasProvidedASoloProvider = savedUserProviders.some(\n    provider =>\n      provider && provider.adapter && provider.adapter.policy === 'solo' && authData[provider.name]\n  );\n\n  // Solo providers can be considered as safe, so we do not have to check if the user needs\n  // to provide an additional provider to login. An auth adapter with \"solo\" (like webauthn) means\n  // no \"additional\" auth needs to be provided to login (like OTP, MFA)\n  if (hasProvidedASoloProvider) {\n    return;\n  }\n\n  const additionProvidersNotFound = [];\n  const hasProvidedAtLeastOneAdditionalProvider = savedUserProviders.some(provider => {\n    let policy = provider.adapter.policy;\n    if (typeof policy === 'function') {\n      const requestObject = {\n        ip: req.config.ip,\n        user: req.auth.user,\n        master: req.auth.isMaster,\n      };\n      policy = policy.call(provider.adapter, requestObject, userAuthData[provider.name]);\n    }\n    if (policy === 'additional') {\n      if (authData[provider.name]) {\n        return true;\n      } else {\n        // Push missing provider for error message\n        additionProvidersNotFound.push(provider.name);\n      }\n    }\n  });\n  if (hasProvidedAtLeastOneAdditionalProvider || !additionProvidersNotFound.length) {\n    return;\n  }\n\n  throw new Parse.Error(\n    Parse.Error.OTHER_CAUSE,\n    `Missing additional authData ${additionProvidersNotFound.join(',')}`\n  );\n};\n\n// Validate each authData step-by-step and return the provider responses\nconst handleAuthDataValidation = async (authData, req, foundUser) => {\n  let user;\n  if (foundUser) {\n    user = Parse.User.fromJSON({ className: '_User', ...foundUser });\n    // Find user by session and current objectId; only pass user if it's the current user or master key is provided\n  } else if (\n    (req.auth &&\n      req.auth.user &&\n      typeof req.getUserId === 'function' &&\n      req.getUserId() === req.auth.user.id) ||\n    (req.auth && req.auth.isMaster && typeof req.getUserId === 'function' && req.getUserId())\n  ) {\n    user = new Parse.User();\n    user.id = req.auth.isMaster ? req.getUserId() : req.auth.user.id;\n    await user.fetch({ useMasterKey: true });\n  }\n\n  const { updatedObject } = req.buildParseObjects();\n  const requestObject = getRequestObject(undefined, req.auth, updatedObject, user, req.config);\n  // Perform validation as step-by-step pipeline for better error consistency\n  // and also to avoid to trigger a provider (like OTP SMS) if another one fails\n  const acc = { authData: {}, authDataResponse: {} };\n  const authKeys = Object.keys(authData).sort();\n  for (const provider of authKeys) {\n    let method = '';\n    try {\n      if (authData[provider] === null) {\n        acc.authData[provider] = null;\n        continue;\n      }\n      const { validator } = req.config.authDataManager.getValidatorForProvider(provider) || {};\n      const authProvider = (req.config.auth || {})[provider] || {};\n      if (!validator || authProvider.enabled === false) {\n        throw new Parse.Error(\n          Parse.Error.UNSUPPORTED_SERVICE,\n          'This authentication method is unsupported.'\n        );\n      }\n      let validationResult = await validator(authData[provider], req, user, requestObject);\n      method = validationResult && validationResult.method;\n      requestObject.triggerName = method;\n      if (validationResult && validationResult.validator) {\n        validationResult = await validationResult.validator();\n      }\n      if (!validationResult) {\n        acc.authData[provider] = authData[provider];\n        continue;\n      }\n      if (!Object.keys(validationResult).length) {\n        acc.authData[provider] = authData[provider];\n        continue;\n      }\n\n      if (validationResult.response) {\n        acc.authDataResponse[provider] = validationResult.response;\n      }\n      // Some auth providers after initialization will avoid to replace authData already stored\n      if (!validationResult.doNotSave) {\n        acc.authData[provider] = validationResult.save || authData[provider];\n      }\n    } catch (err) {\n      const e = resolveError(err, {\n        code: Parse.Error.SCRIPT_FAILED,\n        message: 'Auth failed. Unknown error.',\n      });\n      const userString =\n        req.auth && req.auth.user ? req.auth.user.id : req.data.objectId || undefined;\n      logger.error(\n        `Failed running auth step ${method} for ${provider} for user ${userString} with Error: ` +\n          JSON.stringify(e),\n        {\n          authenticationStep: method,\n          error: e,\n          user: userString,\n          provider,\n        }\n      );\n      throw e;\n    }\n  }\n  return acc;\n};\n\nmodule.exports = {\n  Auth,\n  master,\n  maintenance,\n  nobody,\n  readOnly,\n  shouldUpdateSessionExpiry,\n  getAuthForSessionToken,\n  getAuthForLegacySessionToken,\n  findUsersWithAuthData,\n  hasMutatedAuthData,\n  checkIfUserHasProvidedConfiguredProvidersForLogin,\n  handleAuthDataValidation,\n};\n"],"mappings":"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","ignoreList":[]}