parse-server 2.8.4 → 8.6.2

package/lib/Routers/UsersRouter.js

@@ -1,42 +1,25 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.UsersRouter = undefined;
-
-var _node = require('parse/node');
-
-var _node2 = _interopRequireDefault(_node);
-
-var _Config = require('../Config');
-
-var _Config2 = _interopRequireDefault(_Config);
-
-var _AccountLockout = require('../AccountLockout');
-
-var _AccountLockout2 = _interopRequireDefault(_AccountLockout);
-
-var _ClassesRouter = require('./ClassesRouter');
-
-var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter);
-
-var _rest = require('../rest');
-
-var _rest2 = _interopRequireDefault(_rest);
-
-var _Auth = require('../Auth');
-
-var _Auth2 = _interopRequireDefault(_Auth);
-
-var _password = require('../password');
-
-var _password2 = _interopRequireDefault(_password);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class UsersRouter extends _ClassesRouter2.default {
-
+exports.default = exports.UsersRouter = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+var _Config = _interopRequireDefault(require("../Config"));
+var _AccountLockout = _interopRequireDefault(require("../AccountLockout"));
+var _ClassesRouter = _interopRequireDefault(require("./ClassesRouter"));
+var _rest = _interopRequireDefault(require("../rest"));
+var _Auth = _interopRequireDefault(require("../Auth"));
+var _password = _interopRequireDefault(require("../password"));
+var _triggers = require("../triggers");
+var _middlewares = require("../middlewares");
+var _RestWrite = _interopRequireDefault(require("../RestWrite"));
+var _logger = require("../logger");
+var _Error = require("../Error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// These methods handle the User-related routes.
+
+class UsersRouter extends _ClassesRouter.default {
   className() {
     return '_User';
   }
@@ -47,15 +30,37 @@ class UsersRouter extends _ClassesRouter2.default {
    */
   static removeHiddenProperties(obj) {
     for (var key in obj) {
-      if (obj.hasOwnProperty(key)) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
         // Regexp comes from Parse.Object.prototype.validate
-        if (key !== "__type" && !/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) {
+        if (key !== '__type' && !/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) {
           delete obj[key];
         }
       }
     }
   }
 
+  /**
+   * After retrieving a user directly from the database, we need to remove the
+   * password from the object (for security), and fix an issue some SDKs have
+   * with null values
+   */
+  _sanitizeAuthData(user) {
+    delete user.password;
+
+    // Sometimes the authData still has null on that keys
+    // https://github.com/parse-community/parse-server/issues/935
+    if (user.authData) {
+      Object.keys(user.authData).forEach(provider => {
+        if (user.authData[provider] === null) {
+          delete user.authData[provider];
+        }
+      });
+      if (Object.keys(user.authData).length == 0) {
+        delete user.authData;
+      }
+    }
+  }
+
   /**
    * Validates a password request in login and verifyPassword
    * @param {Object} req The request
@@ -65,100 +70,115 @@ class UsersRouter extends _ClassesRouter2.default {
   _authenticateUserFromRequest(req) {
     return new Promise((resolve, reject) => {
       // Use query parameters instead if provided in url
-      let payload = req.body;
-      if (!payload.username && req.query.username || !payload.email && req.query.email) {
+      let payload = req.body || {};
+      if (!payload.username && req.query && req.query.username || !payload.email && req.query && req.query.email) {
         payload = req.query;
       }
       const {
         username,
         email,
-        password
+        password,
+        ignoreEmailVerification
       } = payload;
 
       // TODO: use the right error codes / descriptions.
       if (!username && !email) {
-        throw new _node2.default.Error(_node2.default.Error.USERNAME_MISSING, 'username/email is required.');
+        throw new _node.default.Error(_node.default.Error.USERNAME_MISSING, 'username/email is required.');
       }
       if (!password) {
-        throw new _node2.default.Error(_node2.default.Error.PASSWORD_MISSING, 'password is required.');
+        throw new _node.default.Error(_node.default.Error.PASSWORD_MISSING, 'password is required.');
       }
       if (typeof password !== 'string' || email && typeof email !== 'string' || username && typeof username !== 'string') {
-        throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
+        throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
       }
-
       let user;
       let isValidPassword = false;
       let query;
       if (email && username) {
-        query = { email, username };
+        query = {
+          email,
+          username
+        };
       } else if (email) {
-        query = { email };
+        query = {
+          email
+        };
       } else {
-        query = { $or: [{ username }, { email: username }] };
+        query = {
+          $or: [{
+            username
+          }, {
+            email: username
+          }]
+        };
       }
-      return req.config.database.find('_User', query).then(results => {
+      return req.config.database.find('_User', query, {}, _Auth.default.maintenance(req.config)).then(results => {
         if (!results.length) {
-          throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
+          throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
         }
-
         if (results.length > 1) {
           // corner case where user1 has username == user2 email
-          req.config.loggerController.warn('There is a user which email is the same as another user\'s username, logging in based on username');
+          req.config.loggerController.warn("There is a user which email is the same as another user's username, logging in based on username");
           user = results.filter(user => user.username === username)[0];
         } else {
           user = results[0];
         }
-
-        return _password2.default.compare(password, user.password);
+        return _password.default.compare(password, user.password);
       }).then(correct => {
         isValidPassword = correct;
-        const accountLockoutPolicy = new _AccountLockout2.default(user, req.config);
+        const accountLockoutPolicy = new _AccountLockout.default(user, req.config);
         return accountLockoutPolicy.handleLoginAttempt(isValidPassword);
-      }).then(() => {
+      }).then(async () => {
         if (!isValidPassword) {
-          throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
+          throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
         }
         // Ensure the user isn't locked out
         // A locked out user won't be able to login
         // To lock a user out, just set the ACL to `masterKey` only  ({}).
         // Empty ACL is OK
         if (!req.auth.isMaster && user.ACL && Object.keys(user.ACL).length == 0) {
-          throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
+          throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');
         }
-        if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) {
-          throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, 'User email is not verified.');
-        }
-
-        delete user.password;
-
-        // Sometimes the authData still has null on that keys
-        // https://github.com/parse-community/parse-server/issues/935
-        if (user.authData) {
-          Object.keys(user.authData).forEach(provider => {
-            if (user.authData[provider] === null) {
-              delete user.authData[provider];
-            }
-          });
-          if (Object.keys(user.authData).length == 0) {
-            delete user.authData;
+        // Create request object for verification functions
+        const request = {
+          master: req.auth.isMaster,
+          ip: req.config.ip,
+          installationId: req.auth.installationId,
+          object: _node.default.User.fromJSON(Object.assign({
+            className: '_User'
+          }, user))
+        };
+
+        // If request doesn't use master or maintenance key with ignoring email verification
+        if (!((req.auth.isMaster || req.auth.isMaintenance) && ignoreEmailVerification)) {
+          // Get verification conditions which can be booleans or functions; the purpose of this async/await
+          // structure is to avoid unnecessarily executing subsequent functions if previous ones fail in the
+          // conditional statement below, as a developer may decide to execute expensive operations in them
+          const verifyUserEmails = async () => req.config.verifyUserEmails === true || typeof req.config.verifyUserEmails === 'function' && (await Promise.resolve(req.config.verifyUserEmails(request))) === true;
+          const preventLoginWithUnverifiedEmail = async () => req.config.preventLoginWithUnverifiedEmail === true || typeof req.config.preventLoginWithUnverifiedEmail === 'function' && (await Promise.resolve(req.config.preventLoginWithUnverifiedEmail(request))) === true;
+          if ((await verifyUserEmails()) && (await preventLoginWithUnverifiedEmail()) && !user.emailVerified) {
+            throw new _node.default.Error(_node.default.Error.EMAIL_NOT_FOUND, 'User email is not verified.');
           }
         }
-
+        this._sanitizeAuthData(user);
         return resolve(user);
       }).catch(error => {
         return reject(error);
       });
     });
   }
-
   handleMe(req) {
     if (!req.info || !req.info.sessionToken) {
-      throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token');
+      throw (0, _Error.createSanitizedError)(_node.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token', req.config);
     }
     const sessionToken = req.info.sessionToken;
-    return _rest2.default.find(req.config, _Auth2.default.master(req.config), '_Session', { sessionToken }, { include: 'user' }, req.info.clientSDK).then(response => {
+    return _rest.default.find(req.config, _Auth.default.master(req.config), '_Session', {
+      sessionToken
+    }, {
+      include: 'user'
+    }, req.info.clientSDK, req.info.context).then(response => {
       if (!response.results || response.results.length == 0 || !response.results[0].user) {
-        throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token');
+        throw (0, _Error.createSanitizedError)(_node.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token', req.config);
       } else {
         const user = response.results[0].user;
         // Send token back on the login, because SDKs expect that.
@@ -166,168 +186,414 @@ class UsersRouter extends _ClassesRouter2.default {
 
         // Remove hidden properties.
         UsersRouter.removeHiddenProperties(user);
-
-        return { response: user };
+        return {
+          response: user
+        };
       }
     });
   }
+  async handleLogIn(req) {
+    const user = await this._authenticateUserFromRequest(req);
+    const authData = req.body && req.body.authData;
+    // Check if user has provided their required auth providers
+    _Auth.default.checkIfUserHasProvidedConfiguredProvidersForLogin(req, authData, user.authData, req.config);
+    let authDataResponse;
+    let validatedAuthData;
+    if (authData) {
+      const res = await _Auth.default.handleAuthDataValidation(authData, new _RestWrite.default(req.config, req.auth, '_User', {
+        objectId: user.objectId
+      }, req.body || {}, user, req.info.clientSDK, req.info.context), user);
+      authDataResponse = res.authDataResponse;
+      validatedAuthData = res.authData;
+    }
 
-  handleLogIn(req) {
-    let user;
-    return this._authenticateUserFromRequest(req).then(res => {
-
-      user = res;
-
-      // handle password expiry policy
-      if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) {
-        let changedAt = user._password_changed_at;
-
-        if (!changedAt) {
-          // password was created before expiry policy was enabled.
-          // simply update _User object so that it will start enforcing from now
-          changedAt = new Date();
-          req.config.database.update('_User', { username: user.username }, { _password_changed_at: _node2.default._encode(changedAt) });
-        } else {
-          // check whether the password has expired
-          if (changedAt.__type == 'Date') {
-            changedAt = new Date(changedAt.iso);
-          }
-          // Calculate the expiry time.
-          const expiresAt = new Date(changedAt.getTime() + 86400000 * req.config.passwordPolicy.maxPasswordAge);
-          if (expiresAt < new Date()) // fail of current time is past password expiry time
-            throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Your password has expired. Please reset your password.');
+    // handle password expiry policy
+    if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) {
+      let changedAt = user._password_changed_at;
+      if (!changedAt) {
+        // password was created before expiry policy was enabled.
+        // simply update _User object so that it will start enforcing from now
+        changedAt = new Date();
+        req.config.database.update('_User', {
+          username: user.username
+        }, {
+          _password_changed_at: _node.default._encode(changedAt)
+        });
+      } else {
+        // check whether the password has expired
+        if (changedAt.__type == 'Date') {
+          changedAt = new Date(changedAt.iso);
         }
+        // Calculate the expiry time.
+        const expiresAt = new Date(changedAt.getTime() + 86400000 * req.config.passwordPolicy.maxPasswordAge);
+        if (expiresAt < new Date())
+          // fail of current time is past password expiry time
+          {
+            throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Your password has expired. Please reset your password.');
+          }
       }
+    }
 
-      // Remove hidden properties.
-      UsersRouter.removeHiddenProperties(user);
-
-      const {
-        sessionData,
-        createSession
-      } = _Auth2.default.createSession(req.config, {
-        userId: user.objectId, createdWith: {
-          'action': 'login',
-          'authProvider': 'password'
-        }, installationId: req.info.installationId
-      });
-
-      user.sessionToken = sessionData.sessionToken;
-
-      req.config.filesController.expandFilesInObject(req.config, user);
-
-      return createSession();
-    }).then(() => {
-      return { response: user };
+    // Remove hidden properties.
+    UsersRouter.removeHiddenProperties(user);
+    await req.config.filesController.expandFilesInObject(req.config, user);
+
+    // Before login trigger; throws if failure
+    await (0, _triggers.maybeRunTrigger)(_triggers.Types.beforeLogin, req.auth, _node.default.User.fromJSON(Object.assign({
+      className: '_User'
+    }, user)), null, req.config, req.info.context);
+
+    // If we have some new validated authData update directly
+    if (validatedAuthData && Object.keys(validatedAuthData).length) {
+      await req.config.database.update('_User', {
+        objectId: user.objectId
+      }, {
+        authData: validatedAuthData
+      }, {});
+    }
+    const {
+      sessionData,
+      createSession
+    } = _RestWrite.default.createSession(req.config, {
+      userId: user.objectId,
+      createdWith: {
+        action: 'login',
+        authProvider: 'password'
+      },
+      installationId: req.info.installationId
     });
+    user.sessionToken = sessionData.sessionToken;
+    await createSession();
+    const afterLoginUser = _node.default.User.fromJSON(Object.assign({
+      className: '_User'
+    }, user));
+    await (0, _triggers.maybeRunTrigger)(_triggers.Types.afterLogin, {
+      ...req.auth,
+      user: afterLoginUser
+    }, afterLoginUser, null, req.config, req.info.context);
+    if (authDataResponse) {
+      user.authDataResponse = authDataResponse;
+    }
+    await req.config.authDataManager.runAfterFind(req, user.authData);
+    return {
+      response: user
+    };
   }
 
+  /**
+   * This allows master-key clients to create user sessions without access to
+   * user credentials. This enables systems that can authenticate access another
+   * way (API key, app administrators) to act on a user's behalf.
+   *
+   * We create a new session rather than looking for an existing session; we
+   * want this to work in situations where the user is logged out on all
+   * devices, since this can be used by automated systems acting on the user's
+   * behalf.
+   *
+   * For the moment, we're omitting event hooks and lockout checks, since
+   * immediate use cases suggest /loginAs could be used for semantically
+   * different reasons from /login
+   */
+  async handleLogInAs(req) {
+    if (!req.auth.isMaster) {
+      throw (0, _Error.createSanitizedError)(_node.default.Error.OPERATION_FORBIDDEN, 'master key is required', req.config);
+    }
+    const userId = req.body?.userId || req.query.userId;
+    if (!userId) {
+      throw new _node.default.Error(_node.default.Error.INVALID_VALUE, 'userId must not be empty, null, or undefined');
+    }
+    const queryResults = await req.config.database.find('_User', {
+      objectId: userId
+    });
+    const user = queryResults[0];
+    if (!user) {
+      throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'user not found');
+    }
+    this._sanitizeAuthData(user);
+    const {
+      sessionData,
+      createSession
+    } = _RestWrite.default.createSession(req.config, {
+      userId,
+      createdWith: {
+        action: 'login',
+        authProvider: 'masterkey'
+      },
+      installationId: req.info.installationId
+    });
+    user.sessionToken = sessionData.sessionToken;
+    await createSession();
+    return {
+      response: user
+    };
+  }
   handleVerifyPassword(req) {
     return this._authenticateUserFromRequest(req).then(user => {
-
       // Remove hidden properties.
       UsersRouter.removeHiddenProperties(user);
-
-      return { response: user };
+      return {
+        response: user
+      };
     }).catch(error => {
       throw error;
     });
   }
-
-  handleLogOut(req) {
-    const success = { response: {} };
+  async handleLogOut(req) {
+    const success = {
+      response: {}
+    };
     if (req.info && req.info.sessionToken) {
-      return _rest2.default.find(req.config, _Auth2.default.master(req.config), '_Session', { sessionToken: req.info.sessionToken }, undefined, req.info.clientSDK).then(records => {
-        if (records.results && records.results.length) {
-          return _rest2.default.del(req.config, _Auth2.default.master(req.config), '_Session', records.results[0].objectId).then(() => {
-            return Promise.resolve(success);
-          });
-        }
-        return Promise.resolve(success);
-      });
+      const records = await _rest.default.find(req.config, _Auth.default.master(req.config), '_Session', {
+        sessionToken: req.info.sessionToken
+      }, undefined, req.info.clientSDK, req.info.context);
+      if (records.results && records.results.length) {
+        await _rest.default.del(req.config, _Auth.default.master(req.config), '_Session', records.results[0].objectId, req.info.context);
+        await (0, _triggers.maybeRunTrigger)(_triggers.Types.afterLogout, req.auth, _node.default.Session.fromJSON(Object.assign({
+          className: '_Session'
+        }, records.results[0])), null, req.config);
+      }
     }
-    return Promise.resolve(success);
+    return success;
   }
-
   _throwOnBadEmailConfig(req) {
     try {
-      _Config2.default.validateEmailConfiguration({
+      _Config.default.validateEmailConfiguration({
         emailAdapter: req.config.userController.adapter,
         appName: req.config.appName,
-        publicServerURL: req.config.publicServerURL,
-        emailVerifyTokenValidityDuration: req.config.emailVerifyTokenValidityDuration
+        publicServerURL: req.config.publicServerURL || req.config._publicServerURL,
+        emailVerifyTokenValidityDuration: req.config.emailVerifyTokenValidityDuration,
+        emailVerifyTokenReuseIfValid: req.config.emailVerifyTokenReuseIfValid
       });
     } catch (e) {
       if (typeof e === 'string') {
         // Maybe we need a Bad Configuration error, but the SDKs won't understand it. For now, Internal Server Error.
-        throw new _node2.default.Error(_node2.default.Error.INTERNAL_SERVER_ERROR, 'An appName, publicServerURL, and emailAdapter are required for password reset and email verification functionality.');
+        throw new _node.default.Error(_node.default.Error.INTERNAL_SERVER_ERROR, 'An appName, publicServerURL, and emailAdapter are required for password reset and email verification functionality.');
       } else {
         throw e;
       }
     }
   }
-
-  handleResetRequest(req) {
+  async handleResetRequest(req) {
     this._throwOnBadEmailConfig(req);
-
-    const { email } = req.body;
-    if (!email) {
-      throw new _node2.default.Error(_node2.default.Error.EMAIL_MISSING, "you must provide an email");
+    let email = req.body?.email;
+    const token = req.body?.token;
+    if (!email && !token) {
+      throw new _node.default.Error(_node.default.Error.EMAIL_MISSING, 'you must provide an email');
+    }
+    let userResults = null;
+    let userData = null;
+
+    // We can find the user using token
+    if (token) {
+      userResults = await req.config.database.find('_User', {
+        _perishable_token: token,
+        _perishable_token_expires_at: {
+          $lt: _node.default._encode(new Date())
+        }
+      });
+      if (userResults?.length > 0) {
+        userData = userResults[0];
+        if (userData.email) {
+          email = userData.email;
+        }
+      }
+      // Or using email if no token provided
+    } else if (typeof email === 'string') {
+      userResults = await req.config.database.find('_User', {
+        $or: [{
+          email
+        }, {
+          username: email,
+          email: {
+            $exists: false
+          }
+        }]
+      }, {
+        limit: 1
+      }, _Auth.default.maintenance(req.config));
+      if (userResults?.length > 0) {
+        userData = userResults[0];
+      }
     }
     if (typeof email !== 'string') {
-      throw new _node2.default.Error(_node2.default.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');
+      throw new _node.default.Error(_node.default.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');
+    }
+    if (userData) {
+      this._sanitizeAuthData(userData);
+      // Get files attached to user
+      await req.config.filesController.expandFilesInObject(req.config, userData);
+      const user = (0, _triggers.inflate)('_User', userData);
+      await (0, _triggers.maybeRunTrigger)(_triggers.Types.beforePasswordResetRequest, req.auth, user, null, req.config, req.info.context);
     }
     const userController = req.config.userController;
-    return userController.sendPasswordResetEmail(email).then(() => {
-      return Promise.resolve({
+    try {
+      await userController.sendPasswordResetEmail(email);
+      return {
         response: {}
-      });
-    }, err => {
-      if (err.code === _node2.default.Error.OBJECT_NOT_FOUND) {
-        throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, `No user found with email ${email}.`);
-      } else {
-        throw err;
+      };
+    } catch (err) {
+      if (err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+        if (req.config.passwordPolicy?.resetPasswordSuccessOnInvalidEmail ?? true) {
+          return {
+            response: {}
+          };
+        }
+        err.message = `A user with that email does not exist.`;
       }
-    });
+      throw err;
+    }
   }
-
-  handleVerificationEmailRequest(req) {
+  async handleVerificationEmailRequest(req) {
     this._throwOnBadEmailConfig(req);
-
-    const { email } = req.body;
+    const {
+      email
+    } = req.body || {};
     if (!email) {
-      throw new _node2.default.Error(_node2.default.Error.EMAIL_MISSING, 'you must provide an email');
+      throw new _node.default.Error(_node.default.Error.EMAIL_MISSING, 'you must provide an email');
     }
     if (typeof email !== 'string') {
-      throw new _node2.default.Error(_node2.default.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');
+      throw new _node.default.Error(_node.default.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');
     }
+    const results = await req.config.database.find('_User', {
+      email: email
+    }, {}, _Auth.default.maintenance(req.config));
+    if (!results.length || results.length < 1) {
+      throw new _node.default.Error(_node.default.Error.EMAIL_NOT_FOUND, `No user found with email ${email}`);
+    }
+    const user = results[0];
 
-    return req.config.database.find('_User', { email: email }).then(results => {
-      if (!results.length || results.length < 1) {
-        throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, `No user found with email ${email}`);
+    // remove password field, messes with saving on postgres
+    delete user.password;
+    if (user.emailVerified) {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, `Email ${email} is already verified.`);
+    }
+    const userController = req.config.userController;
+    const send = await userController.regenerateEmailVerifyToken(user, req.auth.isMaster, req.auth.installationId, req.ip);
+    if (send) {
+      userController.sendVerificationEmail(user, req);
+    }
+    return {
+      response: {}
+    };
+  }
+  async handleChallenge(req) {
+    const {
+      username,
+      email,
+      password,
+      authData,
+      challengeData
+    } = req.body || {};
+
+    // if username or email provided with password try to authenticate the user by username
+    let user;
+    if (username || email) {
+      if (!password) {
+        throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'You provided username or email, you need to also provide password.');
       }
-      const user = results[0];
-
-      // remove password field, messes with saving on postgres
-      delete user.password;
+      user = await this._authenticateUserFromRequest(req);
+    }
+    if (!challengeData) {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'Nothing to challenge.');
+    }
+    if (typeof challengeData !== 'object') {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'challengeData should be an object.');
+    }
+    let request;
+    let parseUser;
 
-      if (user.emailVerified) {
-        throw new _node2.default.Error(_node2.default.Error.OTHER_CAUSE, `Email ${email} is already verified.`);
+    // Try to find user by authData
+    if (authData) {
+      if (typeof authData !== 'object') {
+        throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'authData should be an object.');
       }
-
-      const userController = req.config.userController;
-      return userController.regenerateEmailVerifyToken(user).then(() => {
-        userController.sendVerificationEmail(user);
-        return { response: {} };
-      });
-    });
+      if (user) {
+        throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'You cannot provide username/email and authData, only use one identification method.');
+      }
+      if (Object.keys(authData).filter(key => authData[key].id).length > 1) {
+        throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'You cannot provide more than one authData provider with an id.');
+      }
+      const results = await _Auth.default.findUsersWithAuthData(req.config, authData);
+      try {
+        if (!results[0] || results.length > 1) {
+          throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'User not found.');
+        }
+        // Find the provider used to find the user
+        const provider = Object.keys(authData).find(key => authData[key].id);
+        parseUser = _node.default.User.fromJSON({
+          className: '_User',
+          ...results[0]
+        });
+        request = (0, _triggers.getRequestObject)(undefined, req.auth, parseUser, parseUser, req.config);
+        request.isChallenge = true;
+        // Validate authData used to identify the user to avoid brute-force attack on `id`
+        const {
+          validator
+        } = req.config.authDataManager.getValidatorForProvider(provider);
+        const validatorResponse = await validator(authData[provider], req, parseUser, request);
+        if (validatorResponse && validatorResponse.validator) {
+          await validatorResponse.validator();
+        }
+      } catch (e) {
+        // Rewrite the error to avoid guess id attack
+        _logger.logger.error(e);
+        throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'User not found.');
+      }
+    }
+    if (!parseUser) {
+      parseUser = user ? _node.default.User.fromJSON({
+        className: '_User',
+        ...user
+      }) : undefined;
+    }
+    if (!request) {
+      request = (0, _triggers.getRequestObject)(undefined, req.auth, parseUser, parseUser, req.config);
+      request.isChallenge = true;
+    }
+    const acc = {};
+    // Execute challenge step-by-step with consistent order for better error feedback
+    // and to avoid to trigger others challenges if one of them fails
+    for (const provider of Object.keys(challengeData).sort()) {
+      try {
+        const authAdapter = req.config.authDataManager.getValidatorForProvider(provider);
+        if (!authAdapter) {
+          continue;
+        }
+        const {
+          adapter: {
+            challenge
+          }
+        } = authAdapter;
+        if (typeof challenge === 'function') {
+          const providerChallengeResponse = await challenge(challengeData[provider], authData && authData[provider], req.config.auth[provider], request);
+          acc[provider] = providerChallengeResponse || true;
+        }
+      } catch (err) {
+        const e = (0, _triggers.resolveError)(err, {
+          code: _node.default.Error.SCRIPT_FAILED,
+          message: 'Challenge failed. Unknown error.'
+        });
+        const userString = req.auth && req.auth.user ? req.auth.user.id : undefined;
+        _logger.logger.error(`Failed running auth step challenge for ${provider} for user ${userString} with Error: ` + JSON.stringify(e), {
+          authenticationStep: 'challenge',
+          error: e,
+          user: userString,
+          provider
+        });
+        throw e;
+      }
+    }
+    return {
+      response: {
+        challengeData: acc
+      }
+    };
   }
-
   mountRoutes() {
     this.route('GET', '/users', req => {
       return this.handleFind(req);
     });
-    this.route('POST', '/users', req => {
+    this.route('POST', '/users', _middlewares.promiseEnsureIdempotency, req => {
       return this.handleCreate(req);
     });
     this.route('GET', '/users/me', req => {
@@ -336,7 +602,7 @@ class UsersRouter extends _ClassesRouter2.default {
     this.route('GET', '/users/:objectId', req => {
       return this.handleGet(req);
     });
-    this.route('PUT', '/users/:objectId', req => {
+    this.route('PUT', '/users/:objectId', _middlewares.promiseEnsureIdempotency, req => {
       return this.handleUpdate(req);
     });
     this.route('DELETE', '/users/:objectId', req => {
@@ -348,6 +614,9 @@ class UsersRouter extends _ClassesRouter2.default {
     this.route('POST', '/login', req => {
       return this.handleLogIn(req);
     });
+    this.route('POST', '/loginAs', req => {
+      return this.handleLogInAs(req);
+    });
     this.route('POST', '/logout', req => {
       return this.handleLogOut(req);
     });
@@ -360,10 +629,14 @@ class UsersRouter extends _ClassesRouter2.default {
     this.route('GET', '/verifyPassword', req => {
       return this.handleVerifyPassword(req);
     });
+    this.route('POST', '/verifyPassword', req => {
+      return this.handleVerifyPassword(req);
+    });
+    this.route('POST', '/challenge', req => {
+      return this.handleChallenge(req);
+    });
   }
 }
-
-exports.UsersRouter = UsersRouter; // These methods handle the User-related routes.
-
-exports.default = UsersRouter;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/UsersRouter.js"],"names":["UsersRouter","ClassesRouter","className","removeHiddenProperties","obj","key","hasOwnProperty","test","_authenticateUserFromRequest","req","Promise","resolve","reject","payload","body","username","query","email","password","Parse","Error","USERNAME_MISSING","PASSWORD_MISSING","OBJECT_NOT_FOUND","user","isValidPassword","$or","config","database","find","then","results","length","loggerController","warn","filter","passwordCrypto","compare","correct","accountLockoutPolicy","AccountLockout","handleLoginAttempt","auth","isMaster","ACL","Object","keys","verifyUserEmails","preventLoginWithUnverifiedEmail","emailVerified","EMAIL_NOT_FOUND","authData","forEach","provider","catch","error","handleMe","info","sessionToken","INVALID_SESSION_TOKEN","rest","Auth","master","include","clientSDK","response","handleLogIn","res","passwordPolicy","maxPasswordAge","changedAt","_password_changed_at","Date","update","_encode","__type","iso","expiresAt","getTime","sessionData","createSession","userId","objectId","createdWith","installationId","filesController","expandFilesInObject","handleVerifyPassword","handleLogOut","success","undefined","records","del","_throwOnBadEmailConfig","Config","validateEmailConfiguration","emailAdapter","userController","adapter","appName","publicServerURL","emailVerifyTokenValidityDuration","e","INTERNAL_SERVER_ERROR","handleResetRequest","EMAIL_MISSING","INVALID_EMAIL_ADDRESS","sendPasswordResetEmail","err","code","handleVerificationEmailRequest","OTHER_CAUSE","regenerateEmailVerifyToken","sendVerificationEmail","mountRoutes","route","handleFind","handleCreate","handleGet","handleUpdate","handleDelete"],"mappings":"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","file":"UsersRouter.js","sourcesContent":["// These methods handle the User-related routes.\n\nimport Parse from 'parse/node';\nimport Config from '../Config';\nimport AccountLockout from '../AccountLockout';\nimport ClassesRouter from './ClassesRouter';\nimport rest from '../rest';\nimport Auth from '../Auth';\nimport passwordCrypto from '../password';\n\nexport class UsersRouter extends ClassesRouter {\n\n  className() {\n    return '_User';\n  }\n\n  /**\n   * Removes all \"_\" prefixed properties from an object, except \"__type\"\n   * @param {Object} obj An object.\n   */\n  static removeHiddenProperties(obj) {\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        // Regexp comes from Parse.Object.prototype.validate\n        if (key !== \"__type\" && !(/^[A-Za-z][0-9A-Za-z_]*$/).test(key)) {\n          delete obj[key];\n        }\n      }\n    }\n  }\n\n  /**\n   * Validates a password request in login and verifyPassword\n   * @param {Object} req The request\n   * @returns {Object} User object\n   * @private\n   */\n  _authenticateUserFromRequest(req) {\n    return new Promise((resolve, reject) => {\n      // Use query parameters instead if provided in url\n      let payload = req.body;\n      if (!payload.username && req.query.username || !payload.email && req.query.email) {\n        payload = req.query;\n      }\n      const {\n        username,\n        email,\n        password,\n      } = payload;\n\n      // TODO: use the right error codes / descriptions.\n      if (!username && !email) {\n        throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'username/email is required.');\n      }\n      if (!password) {\n        throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required.');\n      }\n      if (typeof password !== 'string'\n        || email && typeof email !== 'string'\n        || username && typeof username !== 'string') {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n      }\n\n      let user;\n      let isValidPassword = false;\n      let query;\n      if (email && username) {\n        query = { email, username };\n      } else if (email) {\n        query = { email };\n      } else {\n        query = { $or: [{ username }, { email: username }] };\n      }\n      return req.config.database.find('_User', query)\n        .then((results) => {\n          if (!results.length) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n\n          if (results.length > 1) { // corner case where user1 has username == user2 email\n            req.config.loggerController.warn('There is a user which email is the same as another user\\'s username, logging in based on username');\n            user = results.filter((user) => user.username === username)[0];\n          } else {\n            user = results[0];\n          }\n\n          return passwordCrypto.compare(password, user.password);\n        })\n        .then((correct) => {\n          isValidPassword = correct;\n          const accountLockoutPolicy = new AccountLockout(user, req.config);\n          return accountLockoutPolicy.handleLoginAttempt(isValidPassword);\n        })\n        .then(() => {\n          if (!isValidPassword) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n          // Ensure the user isn't locked out\n          // A locked out user won't be able to login\n          // To lock a user out, just set the ACL to `masterKey` only  ({}).\n          // Empty ACL is OK\n          if (!req.auth.isMaster && user.ACL && Object.keys(user.ACL).length == 0) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n          if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) {\n            throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.');\n          }\n\n          delete user.password;\n\n          // Sometimes the authData still has null on that keys\n          // https://github.com/parse-community/parse-server/issues/935\n          if (user.authData) {\n            Object.keys(user.authData).forEach((provider) => {\n              if (user.authData[provider] === null) {\n                delete user.authData[provider];\n              }\n            });\n            if (Object.keys(user.authData).length == 0) {\n              delete user.authData;\n            }\n          }\n\n          return resolve(user);\n        }).catch((error) => {\n          return reject(error);\n        });\n    });\n  }\n\n  handleMe(req) {\n    if (!req.info || !req.info.sessionToken) {\n      throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n    }\n    const sessionToken = req.info.sessionToken;\n    return rest.find(req.config, Auth.master(req.config), '_Session',\n      { sessionToken },\n      { include: 'user' }, req.info.clientSDK)\n      .then((response) => {\n        if (!response.results ||\n          response.results.length == 0 ||\n          !response.results[0].user) {\n          throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n        } else {\n          const user = response.results[0].user;\n          // Send token back on the login, because SDKs expect that.\n          user.sessionToken = sessionToken;\n\n          // Remove hidden properties.\n          UsersRouter.removeHiddenProperties(user);\n\n          return { response: user };\n        }\n      });\n  }\n\n  handleLogIn(req) {\n    let user;\n    return this._authenticateUserFromRequest(req)\n      .then((res) => {\n\n        user = res;\n\n        // handle password expiry policy\n        if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) {\n          let changedAt = user._password_changed_at;\n\n          if (!changedAt) {\n            // password was created before expiry policy was enabled.\n            // simply update _User object so that it will start enforcing from now\n            changedAt = new Date();\n            req.config.database.update('_User', { username: user.username },\n              { _password_changed_at: Parse._encode(changedAt) });\n          } else {\n            // check whether the password has expired\n            if (changedAt.__type == 'Date') {\n              changedAt = new Date(changedAt.iso);\n            }\n            // Calculate the expiry time.\n            const expiresAt = new Date(changedAt.getTime() + 86400000 * req.config.passwordPolicy.maxPasswordAge);\n            if (expiresAt < new Date()) // fail of current time is past password expiry time\n              throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Your password has expired. Please reset your password.');\n          }\n        }\n\n        // Remove hidden properties.\n        UsersRouter.removeHiddenProperties(user);\n\n        const {\n          sessionData,\n          createSession\n        } = Auth.createSession(req.config, {\n          userId: user.objectId, createdWith: {\n            'action': 'login',\n            'authProvider': 'password'\n          }, installationId: req.info.installationId\n        });\n\n        user.sessionToken = sessionData.sessionToken;\n\n        req.config.filesController.expandFilesInObject(req.config, user);\n\n        return createSession();\n      })\n      .then(() => {\n        return { response: user };\n      });\n  }\n\n  handleVerifyPassword(req) {\n    return this._authenticateUserFromRequest(req)\n      .then((user) => {\n\n        // Remove hidden properties.\n        UsersRouter.removeHiddenProperties(user);\n\n        return { response: user };\n      }).catch((error) => {\n        throw error;\n      });\n  }\n\n  handleLogOut(req) {\n    const success = { response: {} };\n    if (req.info && req.info.sessionToken) {\n      return rest.find(req.config, Auth.master(req.config), '_Session',\n        { sessionToken: req.info.sessionToken }, undefined, req.info.clientSDK\n      ).then((records) => {\n        if (records.results && records.results.length) {\n          return rest.del(req.config, Auth.master(req.config), '_Session',\n            records.results[0].objectId\n          ).then(() => {\n            return Promise.resolve(success);\n          });\n        }\n        return Promise.resolve(success);\n      });\n    }\n    return Promise.resolve(success);\n  }\n\n  _throwOnBadEmailConfig(req) {\n    try {\n      Config.validateEmailConfiguration({\n        emailAdapter: req.config.userController.adapter,\n        appName: req.config.appName,\n        publicServerURL: req.config.publicServerURL,\n        emailVerifyTokenValidityDuration: req.config.emailVerifyTokenValidityDuration\n      });\n    } catch (e) {\n      if (typeof e === 'string') {\n        // Maybe we need a Bad Configuration error, but the SDKs won't understand it. For now, Internal Server Error.\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'An appName, publicServerURL, and emailAdapter are required for password reset and email verification functionality.');\n      } else {\n        throw e;\n      }\n    }\n  }\n\n  handleResetRequest(req) {\n    this._throwOnBadEmailConfig(req);\n\n    const { email } = req.body;\n    if (!email) {\n      throw new Parse.Error(Parse.Error.EMAIL_MISSING, \"you must provide an email\");\n    }\n    if (typeof email !== 'string') {\n      throw new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');\n    }\n    const userController = req.config.userController;\n    return userController.sendPasswordResetEmail(email).then(() => {\n      return Promise.resolve({\n        response: {}\n      });\n    }, err => {\n      if (err.code === Parse.Error.OBJECT_NOT_FOUND) {\n        throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, `No user found with email ${email}.`);\n      } else {\n        throw err;\n      }\n    });\n  }\n\n  handleVerificationEmailRequest(req) {\n    this._throwOnBadEmailConfig(req);\n\n    const { email } = req.body;\n    if (!email) {\n      throw new Parse.Error(Parse.Error.EMAIL_MISSING, 'you must provide an email');\n    }\n    if (typeof email !== 'string') {\n      throw new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');\n    }\n\n    return req.config.database.find('_User', { email: email }).then((results) => {\n      if (!results.length || results.length < 1) {\n        throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, `No user found with email ${email}`);\n      }\n      const user = results[0];\n\n      // remove password field, messes with saving on postgres\n      delete user.password;\n\n      if (user.emailVerified) {\n        throw new Parse.Error(Parse.Error.OTHER_CAUSE, `Email ${email} is already verified.`);\n      }\n\n      const userController = req.config.userController;\n      return userController.regenerateEmailVerifyToken(user).then(() => {\n        userController.sendVerificationEmail(user);\n        return { response: {} };\n      });\n    });\n  }\n\n\n  mountRoutes() {\n    this.route('GET', '/users', req => { return this.handleFind(req); });\n    this.route('POST', '/users', req => { return this.handleCreate(req); });\n    this.route('GET', '/users/me', req => { return this.handleMe(req); });\n    this.route('GET', '/users/:objectId', req => { return this.handleGet(req); });\n    this.route('PUT', '/users/:objectId', req => { return this.handleUpdate(req); });\n    this.route('DELETE', '/users/:objectId', req => { return this.handleDelete(req); });\n    this.route('GET', '/login', req => { return this.handleLogIn(req); });\n    this.route('POST', '/login', req => { return this.handleLogIn(req); });\n    this.route('POST', '/logout', req => { return this.handleLogOut(req); });\n    this.route('POST', '/requestPasswordReset', req => { return this.handleResetRequest(req); });\n    this.route('POST', '/verificationEmailRequest', req => { return this.handleVerificationEmailRequest(req); });\n    this.route('GET', '/verifyPassword', req => { return this.handleVerifyPassword(req); });\n  }\n}\n\nexport default UsersRouter;\n"]}
+exports.UsersRouter = UsersRouter;
+var _default = exports.default = UsersRouter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_Config","_AccountLockout","_ClassesRouter","_rest","_Auth","_password","_triggers","_middlewares","_RestWrite","_logger","_Error","e","__esModule","default","UsersRouter","ClassesRouter","className","removeHiddenProperties","obj","key","Object","prototype","hasOwnProperty","call","test","_sanitizeAuthData","user","password","authData","keys","forEach","provider","length","_authenticateUserFromRequest","req","Promise","resolve","reject","payload","body","username","query","email","ignoreEmailVerification","Parse","Error","USERNAME_MISSING","PASSWORD_MISSING","OBJECT_NOT_FOUND","isValidPassword","$or","config","database","find","Auth","maintenance","then","results","loggerController","warn","filter","passwordCrypto","compare","correct","accountLockoutPolicy","AccountLockout","handleLoginAttempt","auth","isMaster","ACL","request","master","ip","installationId","object","User","fromJSON","assign","isMaintenance","verifyUserEmails","preventLoginWithUnverifiedEmail","emailVerified","EMAIL_NOT_FOUND","catch","error","handleMe","info","sessionToken","createSanitizedError","INVALID_SESSION_TOKEN","rest","include","clientSDK","context","response","handleLogIn","checkIfUserHasProvidedConfiguredProvidersForLogin","authDataResponse","validatedAuthData","res","handleAuthDataValidation","RestWrite","objectId","passwordPolicy","maxPasswordAge","changedAt","_password_changed_at","Date","update","_encode","__type","iso","expiresAt","getTime","filesController","expandFilesInObject","maybeRunTrigger","TriggerTypes","beforeLogin","sessionData","createSession","userId","createdWith","action","authProvider","afterLoginUser","afterLogin","authDataManager","runAfterFind","handleLogInAs","OPERATION_FORBIDDEN","INVALID_VALUE","queryResults","handleVerifyPassword","handleLogOut","success","records","undefined","del","afterLogout","Session","_throwOnBadEmailConfig","Config","validateEmailConfiguration","emailAdapter","userController","adapter","appName","publicServerURL","_publicServerURL","emailVerifyTokenValidityDuration","emailVerifyTokenReuseIfValid","INTERNAL_SERVER_ERROR","handleResetRequest","token","EMAIL_MISSING","userResults","userData","_perishable_token","_perishable_token_expires_at","$lt","$exists","limit","INVALID_EMAIL_ADDRESS","inflate","beforePasswordResetRequest","sendPasswordResetEmail","err","code","resetPasswordSuccessOnInvalidEmail","message","handleVerificationEmailRequest","OTHER_CAUSE","send","regenerateEmailVerifyToken","sendVerificationEmail","handleChallenge","challengeData","parseUser","id","findUsersWithAuthData","getRequestObject","isChallenge","validator","getValidatorForProvider","validatorResponse","logger","acc","sort","authAdapter","challenge","providerChallengeResponse","resolveError","SCRIPT_FAILED","userString","JSON","stringify","authenticationStep","mountRoutes","route","handleFind","promiseEnsureIdempotency","handleCreate","handleGet","handleUpdate","handleDelete","exports","_default"],"sources":["../../src/Routers/UsersRouter.js"],"sourcesContent":["// These methods handle the User-related routes.\n\nimport Parse from 'parse/node';\nimport Config from '../Config';\nimport AccountLockout from '../AccountLockout';\nimport ClassesRouter from './ClassesRouter';\nimport rest from '../rest';\nimport Auth from '../Auth';\nimport passwordCrypto from '../password';\nimport {\n  maybeRunTrigger,\n  Types as TriggerTypes,\n  getRequestObject,\n  resolveError,\n  inflate,\n} from '../triggers';\nimport { promiseEnsureIdempotency } from '../middlewares';\nimport RestWrite from '../RestWrite';\nimport { logger } from '../logger';\nimport { createSanitizedError } from '../Error';\n\nexport class UsersRouter extends ClassesRouter {\n  className() {\n    return '_User';\n  }\n\n  /**\n   * Removes all \"_\" prefixed properties from an object, except \"__type\"\n   * @param {Object} obj An object.\n   */\n  static removeHiddenProperties(obj) {\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        // Regexp comes from Parse.Object.prototype.validate\n        if (key !== '__type' && !/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) {\n          delete obj[key];\n        }\n      }\n    }\n  }\n\n  /**\n   * After retrieving a user directly from the database, we need to remove the\n   * password from the object (for security), and fix an issue some SDKs have\n   * with null values\n   */\n  _sanitizeAuthData(user) {\n    delete user.password;\n\n    // Sometimes the authData still has null on that keys\n    // https://github.com/parse-community/parse-server/issues/935\n    if (user.authData) {\n      Object.keys(user.authData).forEach(provider => {\n        if (user.authData[provider] === null) {\n          delete user.authData[provider];\n        }\n      });\n      if (Object.keys(user.authData).length == 0) {\n        delete user.authData;\n      }\n    }\n  }\n\n  /**\n   * Validates a password request in login and verifyPassword\n   * @param {Object} req The request\n   * @returns {Object} User object\n   * @private\n   */\n  _authenticateUserFromRequest(req) {\n    return new Promise((resolve, reject) => {\n      // Use query parameters instead if provided in url\n      let payload = req.body || {};\n      if (\n        (!payload.username && req.query && req.query.username) ||\n        (!payload.email && req.query && req.query.email)\n      ) {\n        payload = req.query;\n      }\n      const { username, email, password, ignoreEmailVerification } = payload;\n\n      // TODO: use the right error codes / descriptions.\n      if (!username && !email) {\n        throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'username/email is required.');\n      }\n      if (!password) {\n        throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required.');\n      }\n      if (\n        typeof password !== 'string' ||\n        (email && typeof email !== 'string') ||\n        (username && typeof username !== 'string')\n      ) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n      }\n\n      let user;\n      let isValidPassword = false;\n      let query;\n      if (email && username) {\n        query = { email, username };\n      } else if (email) {\n        query = { email };\n      } else {\n        query = { $or: [{ username }, { email: username }] };\n      }\n      return req.config.database\n        .find('_User', query, {}, Auth.maintenance(req.config))\n        .then(results => {\n          if (!results.length) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n\n          if (results.length > 1) {\n            // corner case where user1 has username == user2 email\n            req.config.loggerController.warn(\n              \"There is a user which email is the same as another user's username, logging in based on username\"\n            );\n            user = results.filter(user => user.username === username)[0];\n          } else {\n            user = results[0];\n          }\n\n          return passwordCrypto.compare(password, user.password);\n        })\n        .then(correct => {\n          isValidPassword = correct;\n          const accountLockoutPolicy = new AccountLockout(user, req.config);\n          return accountLockoutPolicy.handleLoginAttempt(isValidPassword);\n        })\n        .then(async () => {\n          if (!isValidPassword) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n          // Ensure the user isn't locked out\n          // A locked out user won't be able to login\n          // To lock a user out, just set the ACL to `masterKey` only  ({}).\n          // Empty ACL is OK\n          if (!req.auth.isMaster && user.ACL && Object.keys(user.ACL).length == 0) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n          // Create request object for verification functions\n          const request = {\n            master: req.auth.isMaster,\n            ip: req.config.ip,\n            installationId: req.auth.installationId,\n            object: Parse.User.fromJSON(Object.assign({ className: '_User' }, user)),\n          };\n\n          // If request doesn't use master or maintenance key with ignoring email verification\n          if (!((req.auth.isMaster || req.auth.isMaintenance) && ignoreEmailVerification)) {\n\n            // Get verification conditions which can be booleans or functions; the purpose of this async/await\n            // structure is to avoid unnecessarily executing subsequent functions if previous ones fail in the\n            // conditional statement below, as a developer may decide to execute expensive operations in them\n            const verifyUserEmails = async () => req.config.verifyUserEmails === true || (typeof req.config.verifyUserEmails === 'function' && await Promise.resolve(req.config.verifyUserEmails(request)) === true);\n            const preventLoginWithUnverifiedEmail = async () => req.config.preventLoginWithUnverifiedEmail === true || (typeof req.config.preventLoginWithUnverifiedEmail === 'function' && await Promise.resolve(req.config.preventLoginWithUnverifiedEmail(request)) === true);\n            if (await verifyUserEmails() && await preventLoginWithUnverifiedEmail() && !user.emailVerified) {\n              throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.');\n            }\n          }\n\n          this._sanitizeAuthData(user);\n\n          return resolve(user);\n        })\n        .catch(error => {\n          return reject(error);\n        });\n    });\n  }\n\n  handleMe(req) {\n    if (!req.info || !req.info.sessionToken) {\n      throw createSanitizedError(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token', req.config);\n    }\n    const sessionToken = req.info.sessionToken;\n    return rest\n      .find(\n        req.config,\n        Auth.master(req.config),\n        '_Session',\n        { sessionToken },\n        { include: 'user' },\n        req.info.clientSDK,\n        req.info.context\n      )\n      .then(response => {\n        if (!response.results || response.results.length == 0 || !response.results[0].user) {\n          throw createSanitizedError(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token', req.config);\n        } else {\n          const user = response.results[0].user;\n          // Send token back on the login, because SDKs expect that.\n          user.sessionToken = sessionToken;\n\n          // Remove hidden properties.\n          UsersRouter.removeHiddenProperties(user);\n          return { response: user };\n        }\n      });\n  }\n\n  async handleLogIn(req) {\n    const user = await this._authenticateUserFromRequest(req);\n    const authData = req.body && req.body.authData;\n    // Check if user has provided their required auth providers\n    Auth.checkIfUserHasProvidedConfiguredProvidersForLogin(\n      req,\n      authData,\n      user.authData,\n      req.config\n    );\n\n    let authDataResponse;\n    let validatedAuthData;\n    if (authData) {\n      const res = await Auth.handleAuthDataValidation(\n        authData,\n        new RestWrite(\n          req.config,\n          req.auth,\n          '_User',\n          { objectId: user.objectId },\n          req.body || {},\n          user,\n          req.info.clientSDK,\n          req.info.context\n        ),\n        user\n      );\n      authDataResponse = res.authDataResponse;\n      validatedAuthData = res.authData;\n    }\n\n    // handle password expiry policy\n    if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) {\n      let changedAt = user._password_changed_at;\n\n      if (!changedAt) {\n        // password was created before expiry policy was enabled.\n        // simply update _User object so that it will start enforcing from now\n        changedAt = new Date();\n        req.config.database.update(\n          '_User',\n          { username: user.username },\n          { _password_changed_at: Parse._encode(changedAt) }\n        );\n      } else {\n        // check whether the password has expired\n        if (changedAt.__type == 'Date') {\n          changedAt = new Date(changedAt.iso);\n        }\n        // Calculate the expiry time.\n        const expiresAt = new Date(\n          changedAt.getTime() + 86400000 * req.config.passwordPolicy.maxPasswordAge\n        );\n        if (expiresAt < new Date())\n        // fail of current time is past password expiry time\n        { throw new Parse.Error(\n          Parse.Error.OBJECT_NOT_FOUND,\n          'Your password has expired. Please reset your password.'\n        ); }\n      }\n    }\n\n    // Remove hidden properties.\n    UsersRouter.removeHiddenProperties(user);\n\n    await req.config.filesController.expandFilesInObject(req.config, user);\n\n    // Before login trigger; throws if failure\n    await maybeRunTrigger(\n      TriggerTypes.beforeLogin,\n      req.auth,\n      Parse.User.fromJSON(Object.assign({ className: '_User' }, user)),\n      null,\n      req.config,\n      req.info.context\n    );\n\n    // If we have some new validated authData update directly\n    if (validatedAuthData && Object.keys(validatedAuthData).length) {\n      await req.config.database.update(\n        '_User',\n        { objectId: user.objectId },\n        { authData: validatedAuthData },\n        {}\n      );\n    }\n\n    const { sessionData, createSession } = RestWrite.createSession(req.config, {\n      userId: user.objectId,\n      createdWith: {\n        action: 'login',\n        authProvider: 'password',\n      },\n      installationId: req.info.installationId,\n    });\n\n    user.sessionToken = sessionData.sessionToken;\n\n    await createSession();\n\n    const afterLoginUser = Parse.User.fromJSON(Object.assign({ className: '_User' }, user));\n    await maybeRunTrigger(\n      TriggerTypes.afterLogin,\n      { ...req.auth, user: afterLoginUser },\n      afterLoginUser,\n      null,\n      req.config,\n      req.info.context\n    );\n\n    if (authDataResponse) {\n      user.authDataResponse = authDataResponse;\n    }\n    await req.config.authDataManager.runAfterFind(req, user.authData);\n\n    return { response: user };\n  }\n\n  /**\n   * This allows master-key clients to create user sessions without access to\n   * user credentials. This enables systems that can authenticate access another\n   * way (API key, app administrators) to act on a user's behalf.\n   *\n   * We create a new session rather than looking for an existing session; we\n   * want this to work in situations where the user is logged out on all\n   * devices, since this can be used by automated systems acting on the user's\n   * behalf.\n   *\n   * For the moment, we're omitting event hooks and lockout checks, since\n   * immediate use cases suggest /loginAs could be used for semantically\n   * different reasons from /login\n   */\n  async handleLogInAs(req) {\n    if (!req.auth.isMaster) {\n      throw createSanitizedError(\n        Parse.Error.OPERATION_FORBIDDEN,\n        'master key is required',\n        req.config\n      );\n    }\n\n    const userId = req.body?.userId || req.query.userId;\n    if (!userId) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_VALUE,\n        'userId must not be empty, null, or undefined'\n      );\n    }\n\n    const queryResults = await req.config.database.find('_User', { objectId: userId });\n    const user = queryResults[0];\n    if (!user) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'user not found');\n    }\n\n    this._sanitizeAuthData(user);\n\n    const { sessionData, createSession } = RestWrite.createSession(req.config, {\n      userId,\n      createdWith: {\n        action: 'login',\n        authProvider: 'masterkey',\n      },\n      installationId: req.info.installationId,\n    });\n\n    user.sessionToken = sessionData.sessionToken;\n\n    await createSession();\n\n    return { response: user };\n  }\n\n  handleVerifyPassword(req) {\n    return this._authenticateUserFromRequest(req)\n      .then(user => {\n        // Remove hidden properties.\n        UsersRouter.removeHiddenProperties(user);\n\n        return { response: user };\n      })\n      .catch(error => {\n        throw error;\n      });\n  }\n\n  async handleLogOut(req) {\n    const success = { response: {} };\n    if (req.info && req.info.sessionToken) {\n      const records = await rest.find(\n        req.config,\n        Auth.master(req.config),\n        '_Session',\n        { sessionToken: req.info.sessionToken },\n        undefined,\n        req.info.clientSDK,\n        req.info.context\n      );\n      if (records.results && records.results.length) {\n        await rest.del(\n          req.config,\n          Auth.master(req.config),\n          '_Session',\n          records.results[0].objectId,\n          req.info.context\n        );\n        await maybeRunTrigger(\n          TriggerTypes.afterLogout,\n          req.auth,\n          Parse.Session.fromJSON(Object.assign({ className: '_Session' }, records.results[0])),\n          null,\n          req.config\n        );\n      }\n    }\n    return success;\n  }\n\n  _throwOnBadEmailConfig(req) {\n    try {\n      Config.validateEmailConfiguration({\n        emailAdapter: req.config.userController.adapter,\n        appName: req.config.appName,\n        publicServerURL: req.config.publicServerURL || req.config._publicServerURL,\n        emailVerifyTokenValidityDuration: req.config.emailVerifyTokenValidityDuration,\n        emailVerifyTokenReuseIfValid: req.config.emailVerifyTokenReuseIfValid,\n      });\n    } catch (e) {\n      if (typeof e === 'string') {\n        // Maybe we need a Bad Configuration error, but the SDKs won't understand it. For now, Internal Server Error.\n        throw new Parse.Error(\n          Parse.Error.INTERNAL_SERVER_ERROR,\n          'An appName, publicServerURL, and emailAdapter are required for password reset and email verification functionality.'\n        );\n      } else {\n        throw e;\n      }\n    }\n  }\n\n  async handleResetRequest(req) {\n    this._throwOnBadEmailConfig(req);\n\n    let email = req.body?.email;\n    const token = req.body?.token;\n\n    if (!email && !token) {\n      throw new Parse.Error(Parse.Error.EMAIL_MISSING, 'you must provide an email');\n    }\n\n    let userResults = null;\n    let userData = null;\n\n    // We can find the user using token\n    if (token) {\n      userResults = await req.config.database.find('_User', {\n        _perishable_token: token,\n        _perishable_token_expires_at: { $lt: Parse._encode(new Date()) },\n      });\n      if (userResults?.length > 0) {\n        userData = userResults[0];\n        if (userData.email) {\n          email = userData.email;\n        }\n      }\n    // Or using email if no token provided\n    } else if (typeof email === 'string') {\n      userResults = await req.config.database.find(\n        '_User',\n        { $or: [{ email }, { username: email, email: { $exists: false } }] },\n        { limit: 1 },\n        Auth.maintenance(req.config)\n      );\n      if (userResults?.length > 0) {\n        userData = userResults[0];\n      }\n    }\n\n    if (typeof email !== 'string') {\n      throw new Parse.Error(\n        Parse.Error.INVALID_EMAIL_ADDRESS,\n        'you must provide a valid email string'\n      );\n    }\n\n    if (userData) {\n      this._sanitizeAuthData(userData);\n      // Get files attached to user\n      await req.config.filesController.expandFilesInObject(req.config, userData);\n\n      const user = inflate('_User', userData);\n\n      await maybeRunTrigger(\n        TriggerTypes.beforePasswordResetRequest,\n        req.auth,\n        user,\n        null,\n        req.config,\n        req.info.context\n      );\n    }\n\n    const userController = req.config.userController;\n    try {\n      await userController.sendPasswordResetEmail(email);\n      return {\n        response: {},\n      };\n    } catch (err) {\n      if (err.code === Parse.Error.OBJECT_NOT_FOUND) {\n        if (req.config.passwordPolicy?.resetPasswordSuccessOnInvalidEmail ?? true) {\n          return {\n            response: {},\n          };\n        }\n        err.message = `A user with that email does not exist.`;\n      }\n      throw err;\n    }\n  }\n\n  async handleVerificationEmailRequest(req) {\n    this._throwOnBadEmailConfig(req);\n\n    const { email } = req.body || {};\n    if (!email) {\n      throw new Parse.Error(Parse.Error.EMAIL_MISSING, 'you must provide an email');\n    }\n    if (typeof email !== 'string') {\n      throw new Parse.Error(\n        Parse.Error.INVALID_EMAIL_ADDRESS,\n        'you must provide a valid email string'\n      );\n    }\n\n    const results = await req.config.database.find('_User', { email: email }, {}, Auth.maintenance(req.config));\n    if (!results.length || results.length < 1) {\n      throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, `No user found with email ${email}`);\n    }\n    const user = results[0];\n\n    // remove password field, messes with saving on postgres\n    delete user.password;\n\n    if (user.emailVerified) {\n      throw new Parse.Error(Parse.Error.OTHER_CAUSE, `Email ${email} is already verified.`);\n    }\n\n    const userController = req.config.userController;\n    const send = await userController.regenerateEmailVerifyToken(user, req.auth.isMaster, req.auth.installationId, req.ip);\n    if (send) {\n      userController.sendVerificationEmail(user, req);\n    }\n    return { response: {} };\n  }\n\n  async handleChallenge(req) {\n    const { username, email, password, authData, challengeData } = req.body || {};\n\n    // if username or email provided with password try to authenticate the user by username\n    let user;\n    if (username || email) {\n      if (!password) {\n        throw new Parse.Error(\n          Parse.Error.OTHER_CAUSE,\n          'You provided username or email, you need to also provide password.'\n        );\n      }\n      user = await this._authenticateUserFromRequest(req);\n    }\n\n    if (!challengeData) {\n      throw new Parse.Error(Parse.Error.OTHER_CAUSE, 'Nothing to challenge.');\n    }\n\n    if (typeof challengeData !== 'object') {\n      throw new Parse.Error(Parse.Error.OTHER_CAUSE, 'challengeData should be an object.');\n    }\n\n    let request;\n    let parseUser;\n\n    // Try to find user by authData\n    if (authData) {\n      if (typeof authData !== 'object') {\n        throw new Parse.Error(Parse.Error.OTHER_CAUSE, 'authData should be an object.');\n      }\n      if (user) {\n        throw new Parse.Error(\n          Parse.Error.OTHER_CAUSE,\n          'You cannot provide username/email and authData, only use one identification method.'\n        );\n      }\n\n      if (Object.keys(authData).filter(key => authData[key].id).length > 1) {\n        throw new Parse.Error(\n          Parse.Error.OTHER_CAUSE,\n          'You cannot provide more than one authData provider with an id.'\n        );\n      }\n\n      const results = await Auth.findUsersWithAuthData(req.config, authData);\n\n      try {\n        if (!results[0] || results.length > 1) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'User not found.');\n        }\n        // Find the provider used to find the user\n        const provider = Object.keys(authData).find(key => authData[key].id);\n\n        parseUser = Parse.User.fromJSON({ className: '_User', ...results[0] });\n        request = getRequestObject(undefined, req.auth, parseUser, parseUser, req.config);\n        request.isChallenge = true;\n        // Validate authData used to identify the user to avoid brute-force attack on `id`\n        const { validator } = req.config.authDataManager.getValidatorForProvider(provider);\n        const validatorResponse = await validator(authData[provider], req, parseUser, request);\n        if (validatorResponse && validatorResponse.validator) {\n          await validatorResponse.validator();\n        }\n      } catch (e) {\n        // Rewrite the error to avoid guess id attack\n        logger.error(e);\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'User not found.');\n      }\n    }\n\n    if (!parseUser) {\n      parseUser = user ? Parse.User.fromJSON({ className: '_User', ...user }) : undefined;\n    }\n\n    if (!request) {\n      request = getRequestObject(undefined, req.auth, parseUser, parseUser, req.config);\n      request.isChallenge = true;\n    }\n    const acc = {};\n    // Execute challenge step-by-step with consistent order for better error feedback\n    // and to avoid to trigger others challenges if one of them fails\n    for (const provider of Object.keys(challengeData).sort()) {\n      try {\n        const authAdapter = req.config.authDataManager.getValidatorForProvider(provider);\n        if (!authAdapter) {\n          continue;\n        }\n        const {\n          adapter: { challenge },\n        } = authAdapter;\n        if (typeof challenge === 'function') {\n          const providerChallengeResponse = await challenge(\n            challengeData[provider],\n            authData && authData[provider],\n            req.config.auth[provider],\n            request\n          );\n          acc[provider] = providerChallengeResponse || true;\n        }\n      } catch (err) {\n        const e = resolveError(err, {\n          code: Parse.Error.SCRIPT_FAILED,\n          message: 'Challenge failed. Unknown error.',\n        });\n        const userString = req.auth && req.auth.user ? req.auth.user.id : undefined;\n        logger.error(\n          `Failed running auth step challenge for ${provider} for user ${userString} with Error: ` +\n            JSON.stringify(e),\n          {\n            authenticationStep: 'challenge',\n            error: e,\n            user: userString,\n            provider,\n          }\n        );\n        throw e;\n      }\n    }\n    return { response: { challengeData: acc } };\n  }\n\n  mountRoutes() {\n    this.route('GET', '/users', req => {\n      return this.handleFind(req);\n    });\n    this.route('POST', '/users', promiseEnsureIdempotency, req => {\n      return this.handleCreate(req);\n    });\n    this.route('GET', '/users/me', req => {\n      return this.handleMe(req);\n    });\n    this.route('GET', '/users/:objectId', req => {\n      return this.handleGet(req);\n    });\n    this.route('PUT', '/users/:objectId', promiseEnsureIdempotency, req => {\n      return this.handleUpdate(req);\n    });\n    this.route('DELETE', '/users/:objectId', req => {\n      return this.handleDelete(req);\n    });\n    this.route('GET', '/login', req => {\n      return this.handleLogIn(req);\n    });\n    this.route('POST', '/login', req => {\n      return this.handleLogIn(req);\n    });\n    this.route('POST', '/loginAs', req => {\n      return this.handleLogInAs(req);\n    });\n    this.route('POST', '/logout', req => {\n      return this.handleLogOut(req);\n    });\n    this.route('POST', '/requestPasswordReset', req => {\n      return this.handleResetRequest(req);\n    });\n    this.route('POST', '/verificationEmailRequest', req => {\n      return this.handleVerificationEmailRequest(req);\n    });\n    this.route('GET', '/verifyPassword', req => {\n      return this.handleVerifyPassword(req);\n    });\n    this.route('POST', '/verifyPassword', req => {\n      return this.handleVerifyPassword(req);\n    });\n    this.route('POST', '/challenge', req => {\n      return this.handleChallenge(req);\n    });\n  }\n}\n\nexport default UsersRouter;\n"],"mappings":"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","ignoreList":[]}