parse-server 2.8.4 → 8.6.2

package/lib/RestWrite.js

@@ -1,38 +1,29 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
-var _RestQuery = require('./RestQuery');
-
-var _RestQuery2 = _interopRequireDefault(_RestQuery);
-
-var _lodash = require('lodash');
-
-var _lodash2 = _interopRequireDefault(_lodash);
-
-var _logger = require('./logger');
-
-var _logger2 = _interopRequireDefault(_logger);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+exports.default = void 0;
+var _RestQuery = _interopRequireDefault(require("./RestQuery"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _logger = _interopRequireDefault(require("./logger"));
+var _SchemaController = require("./Controllers/SchemaController");
+var _Error = require("./Error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // A RestWrite encapsulates everything we need to run an operation
 // that writes to the database.
 // This could be either a "create" or an "update".
 
 var SchemaController = require('./Controllers/SchemaController');
 var deepcopy = require('deepcopy');
-
 const Auth = require('./Auth');
+const Utils = require('./Utils');
 var cryptoUtils = require('./cryptoUtils');
 var passwordCrypto = require('./password');
 var Parse = require('parse/node');
 var triggers = require('./triggers');
 var ClientSDK = require('./ClientSDK');
-
-
+const util = require('util');
 // query and data are both provided in REST API format. So data
 // types are encoded by plain old objects.
 // If query is null, this is a "create" and the data in data should be
@@ -42,9 +33,9 @@ var ClientSDK = require('./ClientSDK');
 // RestWrite will handle objectId, createdAt, and updatedAt for
 // everything. It also knows to use triggers and special modifications
 // for the _User class.
-function RestWrite(config, auth, className, query, data, originalData, clientSDK) {
+function RestWrite(config, auth, className, query, data, originalData, clientSDK, context, action) {
   if (auth.isReadOnly) {
-    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform a write operation when using readOnlyMasterKey');
+    throw (0, _Error.createSanitizedError)(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform a write operation when using readOnlyMasterKey', config);
   }
   this.config = config;
   this.auth = auth;
@@ -52,8 +43,23 @@ function RestWrite(config, auth, className, query, data, originalData, clientSDK
   this.clientSDK = clientSDK;
   this.storage = {};
   this.runOptions = {};
-  if (!query && data.objectId) {
-    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.');
+  this.context = context || {};
+  if (action) {
+    this.runOptions.action = action;
+  }
+  if (!query) {
+    if (this.config.allowCustomObjectId) {
+      if (Object.prototype.hasOwnProperty.call(data, 'objectId') && !data.objectId) {
+        throw new Parse.Error(Parse.Error.MISSING_OBJECT_ID, 'objectId must not be empty, null or undefined');
+      }
+    } else {
+      if (data.objectId) {
+        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.');
+      }
+      if (data.id) {
+        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'id is an invalid field name.');
+      }
+    }
   }
 
   // When the operation is complete, this.response may have several
@@ -72,6 +78,14 @@ function RestWrite(config, auth, className, query, data, originalData, clientSDK
 
   // The timestamp we'll use for this whole operation
   this.updatedAt = Parse._encode(new Date()).iso;
+
+  // Shared SchemaController to be reused to reduce the number of loadSchema() calls per request
+  // Once set the schemaData should be immutable
+  this.validSchemaController = null;
+  this.pendingOps = {
+    operations: null,
+    identifier: null
+  };
 }
 
 // A convenient method to perform all the steps of processing the
@@ -90,10 +104,17 @@ RestWrite.prototype.execute = function () {
   }).then(() => {
     return this.validateAuthData();
   }).then(() => {
-    return this.runBeforeTrigger();
+    return this.checkRestrictedFields();
   }).then(() => {
-    return this.validateSchema();
+    return this.runBeforeSaveTrigger();
+  }).then(() => {
+    return this.ensureUniqueAuthDataId();
   }).then(() => {
+    return this.deleteEmailResetTokenIfNeeded();
+  }).then(() => {
+    return this.validateSchema();
+  }).then(schemaController => {
+    this.validSchemaController = schemaController;
     return this.setRequiredFieldsIfNeeded();
   }).then(() => {
     return this.transformUser();
@@ -108,22 +129,29 @@ RestWrite.prototype.execute = function () {
   }).then(() => {
     return this.handleFollowup();
   }).then(() => {
-    return this.runAfterTrigger();
+    return this.runAfterSaveTrigger();
   }).then(() => {
     return this.cleanUserAuthData();
   }).then(() => {
+    // Append the authDataResponse if exists
+    if (this.authDataResponse) {
+      if (this.response && this.response.response) {
+        this.response.response.authDataResponse = this.authDataResponse;
+      }
+    }
+    if (this.storage.rejectSignup && this.config.preventSignupWithUnverifiedEmail) {
+      throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.');
+    }
     return this.response;
   });
 };
 
 // Uses the Auth object to get the list of roles, adds the user id
 RestWrite.prototype.getUserAndRoleACL = function () {
-  if (this.auth.isMaster) {
+  if (this.auth.isMaster || this.auth.isMaintenance) {
     return Promise.resolve();
   }
-
   this.runOptions.acl = ['*'];
-
   if (this.auth.user) {
     return this.auth.getUserRoles().then(roles => {
       this.runOptions.acl = this.runOptions.acl.concat(roles, [this.auth.user.id]);
@@ -136,10 +164,10 @@ RestWrite.prototype.getUserAndRoleACL = function () {
 
 // Validates this operation against the allowClientClassCreation config.
 RestWrite.prototype.validateClientClassCreation = function () {
-  if (this.config.allowClientClassCreation === false && !this.auth.isMaster && SchemaController.systemClasses.indexOf(this.className) === -1) {
+  if (this.config.allowClientClassCreation === false && !this.auth.isMaster && !this.auth.isMaintenance && SchemaController.systemClasses.indexOf(this.className) === -1) {
     return this.config.database.loadSchema().then(schemaController => schemaController.hasClass(this.className)).then(hasClass => {
       if (hasClass !== true) {
-        throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'This user is not allowed to access ' + 'non-existent class: ' + this.className);
+        throw (0, _Error.createSanitizedError)(Parse.Error.OPERATION_FORBIDDEN, 'This user is not allowed to access non-existent class: ' + this.className, this.config);
       }
     });
   } else {
@@ -149,13 +177,13 @@ RestWrite.prototype.validateClientClassCreation = function () {
 
 // Validates this operation against the schema.
 RestWrite.prototype.validateSchema = function () {
-  return this.config.database.validateObject(this.className, this.data, this.query, this.runOptions);
+  return this.config.database.validateObject(this.className, this.data, this.query, this.runOptions, this.auth.isMaintenance);
 };
 
 // Runs any beforeSave triggers against this operation.
 // Any change leads to our data being mutated.
-RestWrite.prototype.runBeforeTrigger = function () {
-  if (this.response) {
+RestWrite.prototype.runBeforeSaveTrigger = function () {
+  if (this.response || this.runOptions.many) {
     return;
   }
 
@@ -163,26 +191,41 @@ RestWrite.prototype.runBeforeTrigger = function () {
   if (!triggers.triggerExists(this.className, triggers.Types.beforeSave, this.config.applicationId)) {
     return Promise.resolve();
   }
-
-  // Cloud code gets a bit of extra data for its objects
-  var extraData = { className: this.className };
-  if (this.query && this.query.objectId) {
-    extraData.objectId = this.query.objectId;
-  }
-
-  let originalObject = null;
-  const updatedObject = this.buildUpdatedObject(extraData);
-  if (this.query && this.query.objectId) {
-    // This is an update for existing object.
-    originalObject = triggers.inflate(extraData, this.originalData);
-  }
-
+  const {
+    originalObject,
+    updatedObject
+  } = this.buildParseObjects();
+  const identifier = updatedObject._getStateIdentifier();
+  const stateController = Parse.CoreManager.getObjectStateController();
+  const [pending] = stateController.getPendingOps(identifier);
+  this.pendingOps = {
+    operations: {
+      ...pending
+    },
+    identifier
+  };
   return Promise.resolve().then(() => {
-    return triggers.maybeRunTrigger(triggers.Types.beforeSave, this.auth, updatedObject, originalObject, this.config);
+    // Before calling the trigger, validate the permissions for the save operation
+    let databasePromise = null;
+    if (this.query) {
+      // Validate for updating
+      databasePromise = this.config.database.update(this.className, this.query, this.data, this.runOptions, true, true);
+    } else {
+      // Validate for creating
+      databasePromise = this.config.database.create(this.className, this.data, this.runOptions, true);
+    }
+    // In the case that there is no permission for the operation, it throws an error
+    return databasePromise.then(result => {
+      if (!result || result.length <= 0) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');
+      }
+    });
+  }).then(() => {
+    return triggers.maybeRunTrigger(triggers.Types.beforeSave, this.auth, updatedObject, originalObject, this.config, this.context);
   }).then(response => {
     if (response && response.object) {
-      this.storage.fieldsChangedByTrigger = _lodash2.default.reduce(response.object, (result, value, key) => {
-        if (!_lodash2.default.isEqual(this.data[key], value)) {
+      this.storage.fieldsChangedByTrigger = _lodash.default.reduce(response.object, (result, value, key) => {
+        if (!_lodash.default.isEqual(this.data[key], value)) {
           result.push(key);
         }
         return result;
@@ -193,21 +236,106 @@ RestWrite.prototype.runBeforeTrigger = function () {
         delete this.data.objectId;
       }
     }
+    try {
+      Utils.checkProhibitedKeywords(this.config, this.data);
+    } catch (error) {
+      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, error);
+    }
   });
 };
+RestWrite.prototype.runBeforeLoginTrigger = async function (userData) {
+  // Avoid doing any setup for triggers if there is no 'beforeLogin' trigger
+  if (!triggers.triggerExists(this.className, triggers.Types.beforeLogin, this.config.applicationId)) {
+    return;
+  }
+
+  // Cloud code gets a bit of extra data for its objects
+  const extraData = {
+    className: this.className
+  };
+
+  // Expand file objects
+  await this.config.filesController.expandFilesInObject(this.config, userData);
+  const user = triggers.inflate(extraData, userData);
 
+  // no need to return a response
+  await triggers.maybeRunTrigger(triggers.Types.beforeLogin, this.auth, user, null, this.config, this.context);
+};
 RestWrite.prototype.setRequiredFieldsIfNeeded = function () {
   if (this.data) {
-    // Add default fields
-    this.data.updatedAt = this.updatedAt;
-    if (!this.query) {
-      this.data.createdAt = this.updatedAt;
+    return this.validSchemaController.getAllClasses().then(allClasses => {
+      const schema = allClasses.find(oneClass => oneClass.className === this.className);
+      const setRequiredFieldIfNeeded = (fieldName, setDefault) => {
+        if (this.data[fieldName] === undefined || this.data[fieldName] === null || this.data[fieldName] === '' || typeof this.data[fieldName] === 'object' && this.data[fieldName].__op === 'Delete') {
+          if (setDefault && schema.fields[fieldName] && schema.fields[fieldName].defaultValue !== null && schema.fields[fieldName].defaultValue !== undefined && (this.data[fieldName] === undefined || typeof this.data[fieldName] === 'object' && this.data[fieldName].__op === 'Delete')) {
+            this.data[fieldName] = schema.fields[fieldName].defaultValue;
+            this.storage.fieldsChangedByTrigger = this.storage.fieldsChangedByTrigger || [];
+            if (this.storage.fieldsChangedByTrigger.indexOf(fieldName) < 0) {
+              this.storage.fieldsChangedByTrigger.push(fieldName);
+            }
+          } else if (schema.fields[fieldName] && schema.fields[fieldName].required === true) {
+            throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `${fieldName} is required`);
+          }
+        }
+      };
 
-      // Only assign new objectId if we are creating new object
-      if (!this.data.objectId) {
-        this.data.objectId = cryptoUtils.newObjectId(this.config.objectIdSize);
+      // add default ACL
+      if (schema?.classLevelPermissions?.ACL && !this.data.ACL && JSON.stringify(schema.classLevelPermissions.ACL) !== JSON.stringify({
+        '*': {
+          read: true,
+          write: true
+        }
+      })) {
+        const acl = deepcopy(schema.classLevelPermissions.ACL);
+        if (acl.currentUser) {
+          if (this.auth.user?.id) {
+            acl[this.auth.user?.id] = deepcopy(acl.currentUser);
+          }
+          delete acl.currentUser;
+        }
+        this.data.ACL = acl;
+        this.storage.fieldsChangedByTrigger = this.storage.fieldsChangedByTrigger || [];
+        this.storage.fieldsChangedByTrigger.push('ACL');
       }
-    }
+
+      // Add default fields
+      if (!this.query) {
+        // allow customizing createdAt and updatedAt when using maintenance key
+        if (this.auth.isMaintenance && this.data.createdAt && this.data.createdAt.__type === 'Date') {
+          this.data.createdAt = this.data.createdAt.iso;
+          if (this.data.updatedAt && this.data.updatedAt.__type === 'Date') {
+            const createdAt = new Date(this.data.createdAt);
+            const updatedAt = new Date(this.data.updatedAt.iso);
+            if (updatedAt < createdAt) {
+              throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'updatedAt cannot occur before createdAt');
+            }
+            this.data.updatedAt = this.data.updatedAt.iso;
+          }
+          // if no updatedAt is provided, set it to createdAt to match default behavior
+          else {
+            this.data.updatedAt = this.data.createdAt;
+          }
+        } else {
+          this.data.updatedAt = this.updatedAt;
+          this.data.createdAt = this.updatedAt;
+        }
+
+        // Only assign new objectId if we are creating new object
+        if (!this.data.objectId) {
+          this.data.objectId = cryptoUtils.newObjectId(this.config.objectIdSize);
+        }
+        if (schema) {
+          Object.keys(schema.fields).forEach(fieldName => {
+            setRequiredFieldIfNeeded(fieldName, true);
+          });
+        }
+      } else if (schema) {
+        this.data.updatedAt = this.updatedAt;
+        Object.keys(this.data).forEach(fieldName => {
+          setRequiredFieldIfNeeded(fieldName, false);
+        });
+      }
+    });
   }
   return Promise.resolve();
 };
@@ -219,74 +347,37 @@ RestWrite.prototype.validateAuthData = function () {
   if (this.className !== '_User') {
     return;
   }
-
-  if (!this.query && !this.data.authData) {
-    if (typeof this.data.username !== 'string' || _lodash2.default.isEmpty(this.data.username)) {
+  const authData = this.data.authData;
+  const hasUsernameAndPassword = typeof this.data.username === 'string' && typeof this.data.password === 'string';
+  if (!this.query && !authData) {
+    if (typeof this.data.username !== 'string' || _lodash.default.isEmpty(this.data.username)) {
       throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'bad or missing username');
     }
-    if (typeof this.data.password !== 'string' || _lodash2.default.isEmpty(this.data.password)) {
+    if (typeof this.data.password !== 'string' || _lodash.default.isEmpty(this.data.password)) {
       throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required');
     }
   }
-
-  if (!this.data.authData || !Object.keys(this.data.authData).length) {
+  if (authData && !Object.keys(authData).length || !Object.prototype.hasOwnProperty.call(this.data, 'authData')) {
+    // Nothing to validate here
     return;
+  } else if (Object.prototype.hasOwnProperty.call(this.data, 'authData') && !this.data.authData) {
+    // Handle saving authData to null
+    throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE, 'This authentication method is unsupported.');
   }
-
-  var authData = this.data.authData;
   var providers = Object.keys(authData);
   if (providers.length > 0) {
-    const canHandleAuthData = providers.reduce((canHandle, provider) => {
-      var providerAuthData = authData[provider];
-      var hasToken = providerAuthData && providerAuthData.id;
-      return canHandle && (hasToken || providerAuthData == null);
-    }, true);
-    if (canHandleAuthData) {
+    const canHandleAuthData = providers.some(provider => {
+      const providerAuthData = authData[provider] || {};
+      return !!Object.keys(providerAuthData).length;
+    });
+    if (canHandleAuthData || hasUsernameAndPassword || this.auth.isMaster || this.getUserId()) {
       return this.handleAuthData(authData);
     }
   }
   throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE, 'This authentication method is unsupported.');
 };
-
-RestWrite.prototype.handleAuthDataValidation = function (authData) {
-  const validations = Object.keys(authData).map(provider => {
-    if (authData[provider] === null) {
-      return Promise.resolve();
-    }
-    const validateAuthData = this.config.authDataManager.getValidatorForProvider(provider);
-    if (!validateAuthData) {
-      throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE, 'This authentication method is unsupported.');
-    }
-    return validateAuthData(authData[provider]);
-  });
-  return Promise.all(validations);
-};
-
-RestWrite.prototype.findUsersWithAuthData = function (authData) {
-  const providers = Object.keys(authData);
-  const query = providers.reduce((memo, provider) => {
-    if (!authData[provider]) {
-      return memo;
-    }
-    const queryKey = `authData.${provider}.id`;
-    const query = {};
-    query[queryKey] = authData[provider].id;
-    memo.push(query);
-    return memo;
-  }, []).filter(q => {
-    return typeof q !== 'undefined';
-  });
-
-  let findPromise = Promise.resolve([]);
-  if (query.length > 0) {
-    findPromise = this.config.database.find(this.className, { '$or': query }, {});
-  }
-
-  return findPromise;
-};
-
 RestWrite.prototype.filteredObjectsByACL = function (objects) {
-  if (this.auth.isMaster) {
+  if (this.auth.isMaster || this.auth.isMaintenance) {
     return objects;
   }
   return objects.filter(object => {
@@ -297,134 +388,186 @@ RestWrite.prototype.filteredObjectsByACL = function (objects) {
     return object.ACL && Object.keys(object.ACL).length > 0;
   });
 };
+RestWrite.prototype.getUserId = function () {
+  if (this.query && this.query.objectId && this.className === '_User') {
+    return this.query.objectId;
+  } else if (this.auth && this.auth.user && this.auth.user.id) {
+    return this.auth.user.id;
+  }
+};
 
-RestWrite.prototype.handleAuthData = function (authData) {
-  let results;
-  return this.findUsersWithAuthData(authData).then(r => {
-    results = this.filteredObjectsByACL(r);
-    if (results.length > 1) {
-      // More than 1 user with the passed id's
-      throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');
-    }
+// Developers are allowed to change authData via before save trigger
+// we need after before save to ensure that the developer
+// is not currently duplicating auth data ID
+RestWrite.prototype.ensureUniqueAuthDataId = async function () {
+  if (this.className !== '_User' || !this.data.authData) {
+    return;
+  }
+  const hasAuthDataId = Object.keys(this.data.authData).some(key => this.data.authData[key] && this.data.authData[key].id);
+  if (!hasAuthDataId) {
+    return;
+  }
+  const r = await Auth.findUsersWithAuthData(this.config, this.data.authData);
+  const results = this.filteredObjectsByACL(r);
+  if (results.length > 1) {
+    throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');
+  }
+  // use data.objectId in case of login time and found user during handle validateAuthData
+  const userId = this.getUserId() || this.data.objectId;
+  if (results.length === 1 && userId !== results[0].objectId) {
+    throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');
+  }
+};
+RestWrite.prototype.handleAuthData = async function (authData) {
+  const r = await Auth.findUsersWithAuthData(this.config, authData, true);
+  const results = this.filteredObjectsByACL(r);
+  const userId = this.getUserId();
+  const userResult = results[0];
+  const foundUserIsNotCurrentUser = userId && userResult && userId !== userResult.objectId;
+  if (results.length > 1 || foundUserIsNotCurrentUser) {
+    // To avoid https://github.com/parse-community/parse-server/security/advisories/GHSA-8w3j-g983-8jh5
+    // Let's run some validation before throwing
+    await Auth.handleAuthDataValidation(authData, this, userResult);
+    throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');
+  }
+
+  // No user found with provided authData we need to validate
+  if (!results.length) {
+    const {
+      authData: validatedAuthData,
+      authDataResponse
+    } = await Auth.handleAuthDataValidation(authData, this);
+    this.authDataResponse = authDataResponse;
+    // Replace current authData by the new validated one
+    this.data.authData = validatedAuthData;
+    return;
+  }
 
-    this.storage['authProvider'] = Object.keys(authData).join(',');
+  // User found with provided authData
+  if (results.length === 1) {
+    this.storage.authProvider = Object.keys(authData).join(',');
+    const {
+      hasMutatedAuthData,
+      mutatedAuthData
+    } = Auth.hasMutatedAuthData(authData, userResult.authData);
+    const isCurrentUserLoggedOrMaster = this.auth && this.auth.user && this.auth.user.id === userResult.objectId || this.auth.isMaster;
+    const isLogin = !userId;
+    if (isLogin || isCurrentUserLoggedOrMaster) {
+      // no user making the call
+      // OR the user making the call is the right one
+      // Login with auth data
+      delete results[0].password;
+
+      // need to set the objectId first otherwise location has trailing undefined
+      this.data.objectId = userResult.objectId;
+      if (!this.query || !this.query.objectId) {
+        this.response = {
+          response: userResult,
+          location: this.location()
+        };
+        // Run beforeLogin hook before storing any updates
+        // to authData on the db; changes to userResult
+        // will be ignored.
+        await this.runBeforeLoginTrigger(deepcopy(userResult));
+
+        // If we are in login operation via authData
+        // we need to be sure that the user has provided
+        // required authData
+        Auth.checkIfUserHasProvidedConfiguredProvidersForLogin({
+          config: this.config,
+          auth: this.auth
+        }, authData, userResult.authData, this.config);
+      }
 
-    if (results.length > 0) {
-      const userResult = results[0];
-      const mutatedAuthData = {};
-      Object.keys(authData).forEach(provider => {
-        const providerData = authData[provider];
-        const userAuthData = userResult.authData[provider];
-        if (!_lodash2.default.isEqual(providerData, userAuthData)) {
-          mutatedAuthData[provider] = providerData;
-        }
-      });
-      const hasMutatedAuthData = Object.keys(mutatedAuthData).length !== 0;
-      let userId;
-      if (this.query && this.query.objectId) {
-        userId = this.query.objectId;
-      } else if (this.auth && this.auth.user && this.auth.user.id) {
-        userId = this.auth.user.id;
+      // Prevent validating if no mutated data detected on update
+      if (!hasMutatedAuthData && isCurrentUserLoggedOrMaster) {
+        return;
       }
-      if (!userId || userId === userResult.objectId) {
-        // no user making the call
-        // OR the user making the call is the right one
-        // Login with auth data
-        delete results[0].password;
 
-        // need to set the objectId first otherwise location has trailing undefined
-        this.data.objectId = userResult.objectId;
+      // Force to validate all provided authData on login
+      // on update only validate mutated ones
+      if (hasMutatedAuthData || !this.config.allowExpiredAuthDataToken) {
+        const res = await Auth.handleAuthDataValidation(isLogin ? authData : mutatedAuthData, this, userResult);
+        this.data.authData = res.authData;
+        this.authDataResponse = res.authDataResponse;
+      }
 
-        if (!this.query || !this.query.objectId) {
-          // this a login call, no userId passed
-          this.response = {
-            response: userResult,
-            location: this.location()
-          };
-        }
-        // If we didn't change the auth data, just keep going
-        if (!hasMutatedAuthData) {
-          return;
-        }
-        // We have authData that is updated on login
-        // that can happen when token are refreshed,
-        // We should update the token and let the user in
-        // We should only check the mutated keys
-        return this.handleAuthDataValidation(mutatedAuthData).then(() => {
-          // IF we have a response, we'll skip the database operation / beforeSave / afterSave etc...
-          // we need to set it up there.
-          // We are supposed to have a response only on LOGIN with authData, so we skip those
-          // If we're not logging in, but just updating the current user, we can safely skip that part
-          if (this.response) {
-            // Assign the new authData in the response
-            Object.keys(mutatedAuthData).forEach(provider => {
-              this.response.response.authData[provider] = mutatedAuthData[provider];
-            });
-            // Run the DB update directly, as 'master'
-            // Just update the authData part
-            // Then we're good for the user, early exit of sorts
-            return this.config.database.update(this.className, { objectId: this.data.objectId }, { authData: mutatedAuthData }, {});
-          }
+      // IF we are in login we'll skip the database operation / beforeSave / afterSave etc...
+      // we need to set it up there.
+      // We are supposed to have a response only on LOGIN with authData, so we skip those
+      // If we're not logging in, but just updating the current user, we can safely skip that part
+      if (this.response) {
+        // Assign the new authData in the response
+        Object.keys(mutatedAuthData).forEach(provider => {
+          this.response.response.authData[provider] = mutatedAuthData[provider];
         });
-      } else if (userId) {
-        // Trying to update auth data but users
-        // are different
-        if (userResult.objectId !== userId) {
-          throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');
-        }
-        // No auth data was mutated, just keep going
-        if (!hasMutatedAuthData) {
-          return;
+
+        // Run the DB update directly, as 'master' only if authData contains some keys
+        // authData could not contains keys after validation if the authAdapter
+        // uses the `doNotSave` option. Just update the authData part
+        // Then we're good for the user, early exit of sorts
+        if (Object.keys(this.data.authData).length) {
+          await this.config.database.update(this.className, {
+            objectId: this.data.objectId
+          }, {
+            authData: this.data.authData
+          }, {});
         }
       }
     }
-    return this.handleAuthDataValidation(authData);
-  });
+  }
+};
+RestWrite.prototype.checkRestrictedFields = async function () {
+  if (this.className !== '_User') {
+    return;
+  }
+  if (!this.auth.isMaintenance && !this.auth.isMaster && 'emailVerified' in this.data) {
+    throw (0, _Error.createSanitizedError)(Parse.Error.OPERATION_FORBIDDEN, "Clients aren't allowed to manually update email verification.", this.config);
+  }
 };
 
 // The non-third-party parts of User transformation
-RestWrite.prototype.transformUser = function () {
+RestWrite.prototype.transformUser = async function () {
   var promise = Promise.resolve();
-
   if (this.className !== '_User') {
     return promise;
   }
 
-  if (!this.auth.isMaster && "emailVerified" in this.data) {
-    const error = `Clients aren't allowed to manually update email verification.`;
-    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error);
-  }
-
   // Do not cleanup session if objectId is not set
   if (this.query && this.objectId()) {
     // If we're updating a _User object, we need to clear out the cache for that user. Find all their
     // session tokens, and remove them from the cache.
-    promise = new _RestQuery2.default(this.config, Auth.master(this.config), '_Session', {
-      user: {
-        __type: "Pointer",
-        className: "_User",
-        objectId: this.objectId()
+    const query = await (0, _RestQuery.default)({
+      method: _RestQuery.default.Method.find,
+      config: this.config,
+      auth: Auth.master(this.config),
+      className: '_Session',
+      runBeforeFind: false,
+      restWhere: {
+        user: {
+          __type: 'Pointer',
+          className: '_User',
+          objectId: this.objectId()
+        }
       }
-    }).execute().then(results => {
+    });
+    promise = query.execute().then(results => {
       results.results.forEach(session => this.config.cacheController.user.del(session.sessionToken));
     });
   }
-
   return promise.then(() => {
     // Transform the password
     if (this.data.password === undefined) {
       // ignore only if undefined. should proceed if empty ('')
       return Promise.resolve();
     }
-
     if (this.query) {
       this.storage['clearSessions'] = true;
       // Generate a new session only if the user requested
-      if (!this.auth.isMaster) {
+      if (!this.auth.isMaster && !this.auth.isMaintenance) {
         this.storage['generateNewSession'] = true;
       }
     }
-
     return this._validatePasswordPolicy().then(() => {
       return passwordCrypto.hash(this.data.password).then(hashedPassword => {
         this.data._hashed_password = hashedPassword;
@@ -437,7 +580,6 @@ RestWrite.prototype.transformUser = function () {
     return this._validateEmail();
   });
 };
-
 RestWrite.prototype._validateUserName = function () {
   // Check for username uniqueness
   if (!this.data.username) {
@@ -447,9 +589,21 @@ RestWrite.prototype._validateUserName = function () {
     }
     return Promise.resolve();
   }
-  // We need to a find to check for duplicate username in case they are missing the unique index on usernames
-  // TODO: Check if there is a unique index, and if so, skip this query.
-  return this.config.database.find(this.className, { username: this.data.username, objectId: { '$ne': this.objectId() } }, { limit: 1 }).then(results => {
+  /*
+    Usernames should be unique when compared case insensitively
+     Users should be able to make case sensitive usernames and
+    login using the case they entered.  I.e. 'Snoopy' should preclude
+    'snoopy' as a valid username.
+  */
+  return this.config.database.find(this.className, {
+    username: this.data.username,
+    objectId: {
+      $ne: this.objectId()
+    }
+  }, {
+    limit: 1,
+    caseInsensitive: true
+  }, {}, this.validSchemaController).then(results => {
     if (results.length > 0) {
       throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');
     }
@@ -457,6 +611,18 @@ RestWrite.prototype._validateUserName = function () {
   });
 };
 
+/*
+  As with usernames, Parse should not allow case insensitive collisions of email.
+  unlike with usernames (which can have case insensitive collisions in the case of
+  auth adapters), emails should never have a case insensitive collision.
+
+  This behavior can be enforced through a properly configured index see:
+  https://docs.mongodb.com/manual/core/index-case-insensitive/#create-a-case-insensitive-index
+  which could be implemented instead of this code based validation.
+
+  Given that this lookup should be a relatively low use case and that the case sensitive
+  unique index will be used by the db for the query, this is an adequate solution.
+*/
 RestWrite.prototype._validateEmail = function () {
   if (!this.data.email || this.data.email.__op === 'Delete') {
     return Promise.resolve();
@@ -465,29 +631,55 @@ RestWrite.prototype._validateEmail = function () {
   if (!this.data.email.match(/^.+@.+$/)) {
     return Promise.reject(new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'Email address format is invalid.'));
   }
-  // Same problem for email as above for username
-  return this.config.database.find(this.className, { email: this.data.email, objectId: { '$ne': this.objectId() } }, { limit: 1 }).then(results => {
+  // Case insensitive match, see note above function.
+  return this.config.database.find(this.className, {
+    email: this.data.email,
+    objectId: {
+      $ne: this.objectId()
+    }
+  }, {
+    limit: 1,
+    caseInsensitive: true
+  }, {}, this.validSchemaController).then(results => {
     if (results.length > 0) {
       throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');
     }
     if (!this.data.authData || !Object.keys(this.data.authData).length || Object.keys(this.data.authData).length === 1 && Object.keys(this.data.authData)[0] === 'anonymous') {
       // We updated the email, send a new validation
-      this.storage['sendVerificationEmail'] = true;
-      this.config.userController.setEmailVerifyToken(this.data);
+      const {
+        originalObject,
+        updatedObject
+      } = this.buildParseObjects();
+      const request = {
+        original: originalObject,
+        object: updatedObject,
+        master: this.auth.isMaster,
+        ip: this.config.ip,
+        installationId: this.auth.installationId
+      };
+      return this.config.userController.setEmailVerifyToken(this.data, request, this.storage);
     }
   });
 };
-
 RestWrite.prototype._validatePasswordPolicy = function () {
-  if (!this.config.passwordPolicy) return Promise.resolve();
+  if (!this.config.passwordPolicy) {
+    return Promise.resolve();
+  }
   return this._validatePasswordRequirements().then(() => {
     return this._validatePasswordHistory();
   });
 };
-
 RestWrite.prototype._validatePasswordRequirements = function () {
   // check if the password conforms to the defined password policy if configured
-  const policyError = 'Password does not meet the Password Policy requirements.';
+  // If we specified a custom error in our configuration use it.
+  // Example: "Passwords must include a Capital Letter, Lowercase Letter, and a number."
+  //
+  // This is especially useful on the generic "password reset" page,
+  // as it allows the programmer to communicate specific requirements instead of:
+  // a. making the user guess whats wrong
+  // b. making a custom password reset page that shows the requirements
+  const policyError = this.config.passwordPolicy.validationError ? this.config.passwordPolicy.validationError : 'Password does not meet the Password Policy requirements.';
+  const containsUsernameError = 'Password cannot contain your username.';
 
   // check whether the password meets the password strength requirements
   if (this.config.passwordPolicy.patternValidator && !this.config.passwordPolicy.patternValidator(this.data.password) || this.config.passwordPolicy.validatorCallback && !this.config.passwordPolicy.validatorCallback(this.data.password)) {
@@ -498,38 +690,52 @@ RestWrite.prototype._validatePasswordRequirements = function () {
   if (this.config.passwordPolicy.doNotAllowUsername === true) {
     if (this.data.username) {
       // username is not passed during password reset
-      if (this.data.password.indexOf(this.data.username) >= 0) return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));
+      if (this.data.password.indexOf(this.data.username) >= 0) {
+        return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, containsUsernameError));
+      }
     } else {
       // retrieve the User object using objectId during password reset
-      return this.config.database.find('_User', { objectId: this.objectId() }).then(results => {
+      return this.config.database.find('_User', {
+        objectId: this.objectId()
+      }).then(results => {
         if (results.length != 1) {
           throw undefined;
         }
-        if (this.data.password.indexOf(results[0].username) >= 0) return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));
+        if (this.data.password.indexOf(results[0].username) >= 0) {
+          return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, containsUsernameError));
+        }
         return Promise.resolve();
       });
     }
   }
   return Promise.resolve();
 };
-
 RestWrite.prototype._validatePasswordHistory = function () {
   // check whether password is repeating from specified history
   if (this.query && this.config.passwordPolicy.maxPasswordHistory) {
-    return this.config.database.find('_User', { objectId: this.objectId() }, { keys: ["_password_history", "_hashed_password"] }).then(results => {
+    return this.config.database.find('_User', {
+      objectId: this.objectId()
+    }, {
+      keys: ['_password_history', '_hashed_password']
+    }, Auth.maintenance(this.config)).then(results => {
       if (results.length != 1) {
         throw undefined;
       }
       const user = results[0];
       let oldPasswords = [];
-      if (user._password_history) oldPasswords = _lodash2.default.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory - 1);
+      if (user._password_history) {
+        oldPasswords = _lodash.default.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory - 1);
+      }
       oldPasswords.push(user.password);
       const newPassword = this.data.password;
       // compare the new password hash with all old password hashes
       const promises = oldPasswords.map(function (hash) {
         return passwordCrypto.compare(newPassword, hash).then(result => {
-          if (result) // reject if there is a match
-            return Promise.reject("REPEAT_PASSWORD");
+          if (result)
+            // reject if there is a match
+            {
+              return Promise.reject('REPEAT_PASSWORD');
+            }
           return Promise.resolve();
         });
       });
@@ -537,57 +743,127 @@ RestWrite.prototype._validatePasswordHistory = function () {
       return Promise.all(promises).then(() => {
         return Promise.resolve();
       }).catch(err => {
-        if (err === "REPEAT_PASSWORD") // a match was found
-          return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, `New password should not be the same as last ${this.config.passwordPolicy.maxPasswordHistory} passwords.`));
+        if (err === 'REPEAT_PASSWORD')
+          // a match was found
+          {
+            return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, `New password should not be the same as last ${this.config.passwordPolicy.maxPasswordHistory} passwords.`));
+          }
         throw err;
       });
     });
   }
   return Promise.resolve();
 };
-
-RestWrite.prototype.createSessionTokenIfNeeded = function () {
+RestWrite.prototype.createSessionTokenIfNeeded = async function () {
   if (this.className !== '_User') {
     return;
   }
-  if (this.query) {
+  // Don't generate session for updating user (this.query is set) unless authData exists
+  if (this.query && !this.data.authData) {
+    return;
+  }
+  // Don't generate new sessionToken if linking via sessionToken
+  if (this.auth.user && this.data.authData) {
     return;
   }
-  if (!this.storage['authProvider'] // signup call, with
-  && this.config.preventLoginWithUnverifiedEmail // no login without verification
-  && this.config.verifyUserEmails) {
-    // verification is on
-    return; // do not create the session token in that case!
+  // If sign-up call
+  if (!this.storage.authProvider) {
+    // Create request object for verification functions
+    const {
+      originalObject,
+      updatedObject
+    } = this.buildParseObjects();
+    const request = {
+      original: originalObject,
+      object: updatedObject,
+      master: this.auth.isMaster,
+      ip: this.config.ip,
+      installationId: this.auth.installationId
+    };
+    // 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 () => this.config.verifyUserEmails === true || typeof this.config.verifyUserEmails === 'function' && (await Promise.resolve(this.config.verifyUserEmails(request))) === true;
+    const preventLoginWithUnverifiedEmail = async () => this.config.preventLoginWithUnverifiedEmail === true || typeof this.config.preventLoginWithUnverifiedEmail === 'function' && (await Promise.resolve(this.config.preventLoginWithUnverifiedEmail(request))) === true;
+    // If verification is required
+    if ((await verifyUserEmails()) && (await preventLoginWithUnverifiedEmail())) {
+      this.storage.rejectSignup = true;
+      return;
+    }
   }
   return this.createSessionToken();
 };
-
-RestWrite.prototype.createSessionToken = function () {
+RestWrite.prototype.createSessionToken = async function () {
   // cloud installationId from Cloud Code,
   // never create session tokens from there.
   if (this.auth.installationId && this.auth.installationId === 'cloud') {
     return;
   }
-
+  if (this.storage.authProvider == null && this.data.authData) {
+    this.storage.authProvider = Object.keys(this.data.authData).join(',');
+  }
   const {
     sessionData,
     createSession
-  } = Auth.createSession(this.config, {
+  } = RestWrite.createSession(this.config, {
     userId: this.objectId(),
     createdWith: {
-      'action': this.storage['authProvider'] ? 'login' : 'signup',
-      'authProvider': this.storage['authProvider'] || 'password'
+      action: this.storage.authProvider ? 'login' : 'signup',
+      authProvider: this.storage.authProvider || 'password'
     },
     installationId: this.auth.installationId
   });
-
   if (this.response && this.response.response) {
     this.response.response.sessionToken = sessionData.sessionToken;
   }
-
   return createSession();
 };
+RestWrite.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,
+    expiresAt: Parse._encode(expiresAt)
+  };
+  if (installationId) {
+    sessionData.installationId = installationId;
+  }
+  Object.assign(sessionData, additionalSessionData);
+  return {
+    sessionData,
+    createSession: () => new RestWrite(config, Auth.master(config), '_Session', null, sessionData).execute()
+  };
+};
 
+// Delete email reset tokens if user is changing password or email.
+RestWrite.prototype.deleteEmailResetTokenIfNeeded = function () {
+  if (this.className !== '_User' || this.query === null) {
+    // null query means create
+    return;
+  }
+  if ('password' in this.data || 'email' in this.data) {
+    const addOps = {
+      _perishable_token: {
+        __op: 'Delete'
+      },
+      _perishable_token_expires_at: {
+        __op: 'Delete'
+      }
+    };
+    this.data = Object.assign(this.data, addOps);
+  }
+};
 RestWrite.prototype.destroyDuplicatedSessions = function () {
   // Only for _Session, and at creation time
   if (this.className != '_Session' || this.query) {
@@ -608,8 +884,10 @@ RestWrite.prototype.destroyDuplicatedSessions = function () {
   this.config.database.destroy('_Session', {
     user,
     installationId,
-    sessionToken: { '$ne': sessionToken }
-  });
+    sessionToken: {
+      $ne: sessionToken
+    }
+  }, {}, this.validSchemaController);
 };
 
 // Handles any followup logic
@@ -625,16 +903,16 @@ RestWrite.prototype.handleFollowup = function () {
     delete this.storage['clearSessions'];
     return this.config.database.destroy('_Session', sessionQuery).then(this.handleFollowup.bind(this));
   }
-
   if (this.storage && this.storage['generateNewSession']) {
     delete this.storage['generateNewSession'];
     return this.createSessionToken().then(this.handleFollowup.bind(this));
   }
-
   if (this.storage && this.storage['sendVerificationEmail']) {
     delete this.storage['sendVerificationEmail'];
     // Fire and forget!
-    this.config.userController.sendVerificationEmail(this.data);
+    this.config.userController.sendVerificationEmail(this.data, {
+      auth: this.auth
+    });
     return this.handleFollowup.bind(this);
   }
 };
@@ -645,8 +923,7 @@ RestWrite.prototype.handleSession = function () {
   if (this.response || this.className !== '_Session') {
     return;
   }
-
-  if (!this.auth.user && !this.auth.isMaster) {
+  if (!this.auth.user && !this.auth.isMaster && !this.auth.isMaintenance) {
     throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token required.');
   }
 
@@ -654,7 +931,6 @@ RestWrite.prototype.handleSession = function () {
   if (this.data.ACL) {
     throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'Cannot set ' + 'ACL on a Session.');
   }
-
   if (this.query) {
     if (this.data.user && !this.auth.isMaster && this.data.user.objectId != this.auth.user.id) {
       throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);
@@ -663,9 +939,19 @@ RestWrite.prototype.handleSession = function () {
     } else if (this.data.sessionToken) {
       throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);
     }
+    if (!this.auth.isMaster) {
+      this.query = {
+        $and: [this.query, {
+          user: {
+            __type: 'Pointer',
+            className: '_User',
+            objectId: this.auth.user.id
+          }
+        }]
+      };
+    }
   }
-
-  if (!this.query && !this.auth.isMaster) {
+  if (!this.query && !this.auth.isMaster && !this.auth.isMaintenance) {
     const additionalSessionData = {};
     for (var key in this.data) {
       if (key === 'objectId' || key === 'user') {
@@ -673,15 +959,16 @@ RestWrite.prototype.handleSession = function () {
       }
       additionalSessionData[key] = this.data[key];
     }
-
-    const { sessionData, createSession } = Auth.createSession(this.config, {
+    const {
+      sessionData,
+      createSession
+    } = RestWrite.createSession(this.config, {
       userId: this.auth.user.id,
       createdWith: {
         action: 'create'
       },
       additionalSessionData
     });
-
     return createSession().then(results => {
       if (!results.response) {
         throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Error creating session.');
@@ -705,7 +992,6 @@ RestWrite.prototype.handleInstallation = function () {
   if (this.response || this.className !== '_Installation') {
     return;
   }
-
   if (!this.query && !this.data.deviceToken && !this.data.installationId && !this.auth.installationId) {
     throw new Parse.Error(135, 'at least one ID field (deviceToken, installationId) ' + 'must be specified in this operation');
   }
@@ -720,14 +1006,12 @@ RestWrite.prototype.handleInstallation = function () {
   if (this.data.installationId) {
     this.data.installationId = this.data.installationId.toLowerCase();
   }
-
   let installationId = this.data.installationId;
 
   // If data.installationId is not set and we're not master, we can lookup in auth
-  if (!installationId && !this.auth.isMaster) {
+  if (!installationId && !this.auth.isMaster && !this.auth.isMaintenance) {
     installationId = this.auth.installationId;
   }
-
   if (installationId) {
     installationId = installationId.toLowerCase();
   }
@@ -736,9 +1020,7 @@ RestWrite.prototype.handleInstallation = function () {
   if (this.query && !this.data.deviceToken && !installationId && !this.data.deviceType) {
     return;
   }
-
   var promise = Promise.resolve();
-
   var idMatch; // Will be a match on either objectId or installationId
   var objectIdMatch;
   var installationIdMatch;
@@ -753,20 +1035,20 @@ RestWrite.prototype.handleInstallation = function () {
   }
   if (installationId) {
     orQueries.push({
-      'installationId': installationId
+      installationId: installationId
     });
   }
   if (this.data.deviceToken) {
-    orQueries.push({ 'deviceToken': this.data.deviceToken });
+    orQueries.push({
+      deviceToken: this.data.deviceToken
+    });
   }
-
   if (orQueries.length == 0) {
     return;
   }
-
   promise = promise.then(() => {
     return this.config.database.find('_Installation', {
-      '$or': orQueries
+      $or: orQueries
     }, {});
   }).then(results => {
     results.forEach(result => {
@@ -796,11 +1078,9 @@ RestWrite.prototype.handleInstallation = function () {
         throw new Parse.Error(136, 'deviceType may not be changed in this ' + 'operation');
       }
     }
-
     if (this.query && this.query.objectId && objectIdMatch) {
       idMatch = objectIdMatch;
     }
-
     if (installationId && installationIdMatch) {
       idMatch = installationIdMatch;
     }
@@ -826,9 +1106,9 @@ RestWrite.prototype.handleInstallation = function () {
         // the deviceToken, and return nil to signal that a new object should
         // be created.
         var delQuery = {
-          'deviceToken': this.data.deviceToken,
-          'installationId': {
-            '$ne': installationId
+          deviceToken: this.data.deviceToken,
+          installationId: {
+            $ne: installationId
           }
         };
         if (this.data.appIdentifier) {
@@ -849,7 +1129,9 @@ RestWrite.prototype.handleInstallation = function () {
         // Exactly one device token match and it doesn't have an installation
         // ID. This is the one case where we want to merge with the existing
         // object.
-        const delQuery = { objectId: idMatch.objectId };
+        const delQuery = {
+          objectId: idMatch.objectId
+        };
         return this.config.database.destroy('_Installation', delQuery).then(() => {
           return deviceTokenMatches[0]['objectId'];
         }).catch(err => {
@@ -866,18 +1148,18 @@ RestWrite.prototype.handleInstallation = function () {
           // we should try cleaning out old installations that match this
           // device token.
           const delQuery = {
-            'deviceToken': this.data.deviceToken
+            deviceToken: this.data.deviceToken
           };
           // We have a unique install Id, use that to preserve
           // the interesting installation
           if (this.data.installationId) {
             delQuery['installationId'] = {
-              '$ne': this.data.installationId
+              $ne: this.data.installationId
             };
           } else if (idMatch.objectId && this.data.objectId && idMatch.objectId == this.data.objectId) {
             // we passed an objectId, preserve that instalation
             delQuery['objectId'] = {
-              '$ne': idMatch.objectId
+              $ne: idMatch.objectId
             };
           } else {
             // What to do here? can't really clean up everything...
@@ -901,7 +1183,9 @@ RestWrite.prototype.handleInstallation = function () {
     }
   }).then(objId => {
     if (objId) {
-      this.query = { objectId: objId };
+      this.query = {
+        objectId: objId
+      };
       delete this.data.objectId;
       delete this.data.createdAt;
     }
@@ -910,29 +1194,28 @@ RestWrite.prototype.handleInstallation = function () {
   return promise;
 };
 
-// If we short-circuted the object response - then we need to make sure we expand all the files,
+// If we short-circuited the object response - then we need to make sure we expand all the files,
 // since this might not have a query, meaning it won't return the full result back.
 // TODO: (nlutsenko) This should die when we move to per-class based controllers on _Session/_User
-RestWrite.prototype.expandFilesForExistingObjects = function () {
+RestWrite.prototype.expandFilesForExistingObjects = async function () {
   // Check whether we have a short-circuited response - only then run expansion.
   if (this.response && this.response.response) {
-    this.config.filesController.expandFilesInObject(this.config, this.response.response);
+    await this.config.filesController.expandFilesInObject(this.config, this.response.response);
   }
 };
-
 RestWrite.prototype.runDatabaseOperation = function () {
   if (this.response) {
     return;
   }
-
   if (this.className === '_Role') {
     this.config.cacheController.role.clear();
+    if (this.config.liveQueryController) {
+      this.config.liveQueryController.clearCachedRoles(this.auth.user);
+    }
   }
-
   if (this.className === '_User' && this.query && this.auth.isUnauthenticated()) {
-    throw new Parse.Error(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`);
+    throw (0, _Error.createSanitizedError)(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`, this.config);
   }
-
   if (this.className === '_Product' && this.data.download) {
     this.data.downloadName = this.data.download.name;
   }
@@ -942,12 +1225,14 @@ RestWrite.prototype.runDatabaseOperation = function () {
   if (this.data.ACL && this.data.ACL['*unresolved']) {
     throw new Parse.Error(Parse.Error.INVALID_ACL, 'Invalid ACL.');
   }
-
   if (this.query) {
     // Force the user to not lockout
     // Matched with parse.com
-    if (this.className === '_User' && this.data.ACL && this.auth.isMaster !== true) {
-      this.data.ACL[this.query.objectId] = { read: true, write: true };
+    if (this.className === '_User' && this.data.ACL && this.auth.isMaster !== true && this.auth.isMaintenance !== true) {
+      this.data.ACL[this.query.objectId] = {
+        read: true,
+        write: true
+      };
     }
     // update password timestamp if user password is being changed
     if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {
@@ -955,34 +1240,38 @@ RestWrite.prototype.runDatabaseOperation = function () {
     }
     // Ignore createdAt when update
     delete this.data.createdAt;
-
     let defer = Promise.resolve();
     // if password history is enabled then save the current password to history
     if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordHistory) {
-      defer = this.config.database.find('_User', { objectId: this.objectId() }, { keys: ["_password_history", "_hashed_password"] }).then(results => {
+      defer = this.config.database.find('_User', {
+        objectId: this.objectId()
+      }, {
+        keys: ['_password_history', '_hashed_password']
+      }, Auth.maintenance(this.config)).then(results => {
         if (results.length != 1) {
           throw undefined;
         }
         const user = results[0];
         let oldPasswords = [];
         if (user._password_history) {
-          oldPasswords = _lodash2.default.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory);
+          oldPasswords = _lodash.default.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory);
         }
         //n-1 passwords go into history including last password
-        while (oldPasswords.length > this.config.passwordPolicy.maxPasswordHistory - 2) {
+        while (oldPasswords.length > Math.max(0, this.config.passwordPolicy.maxPasswordHistory - 2)) {
           oldPasswords.shift();
         }
         oldPasswords.push(user.password);
         this.data._password_history = oldPasswords;
       });
     }
-
     return defer.then(() => {
       // Run an update
-      return this.config.database.update(this.className, this.query, this.data, this.runOptions).then(response => {
+      return this.config.database.update(this.className, this.query, this.data, this.runOptions, false, false, this.validSchemaController).then(response => {
         response.updatedAt = this.updatedAt;
         this._updateResponseWithData(response, this.data);
-        this.response = { response };
+        this.response = {
+          response
+        };
       });
     });
   } else {
@@ -992,10 +1281,18 @@ RestWrite.prototype.runDatabaseOperation = function () {
       // default public r/w ACL
       if (!ACL) {
         ACL = {};
-        ACL['*'] = { read: true, write: false };
+        if (!this.config.enforcePrivateUsers) {
+          ACL['*'] = {
+            read: true,
+            write: false
+          };
+        }
       }
       // make sure the user is not locked down
-      ACL[this.data.objectId] = { read: true, write: true };
+      ACL[this.data.objectId] = {
+        read: true,
+        write: true
+      };
       this.data.ACL = ACL;
       // password timestamp to be used when password expiry policy is enforced
       if (this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {
@@ -1004,7 +1301,7 @@ RestWrite.prototype.runDatabaseOperation = function () {
     }
 
     // Run a create
-    return this.config.database.create(this.className, this.data, this.runOptions).catch(error => {
+    return this.config.database.create(this.className, this.data, this.runOptions, false, this.validSchemaController).catch(error => {
       if (this.className !== '_User' || error.code !== Parse.Error.DUPLICATE_VALUE) {
         throw error;
       }
@@ -1013,7 +1310,6 @@ RestWrite.prototype.runDatabaseOperation = function () {
       if (error && error.userInfo && error.userInfo.duplicated_field === 'username') {
         throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');
       }
-
       if (error && error.userInfo && error.userInfo.duplicated_field === 'email') {
         throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');
       }
@@ -1022,11 +1318,25 @@ RestWrite.prototype.runDatabaseOperation = function () {
       // check whether it was username or email and return the appropriate error.
       // Fallback to the original method
       // TODO: See if we can later do this without additional queries by using named indexes.
-      return this.config.database.find(this.className, { username: this.data.username, objectId: { '$ne': this.objectId() } }, { limit: 1 }).then(results => {
+      return this.config.database.find(this.className, {
+        username: this.data.username,
+        objectId: {
+          $ne: this.objectId()
+        }
+      }, {
+        limit: 1
+      }).then(results => {
         if (results.length > 0) {
           throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');
         }
-        return this.config.database.find(this.className, { email: this.data.email, objectId: { '$ne': this.objectId() } }, { limit: 1 });
+        return this.config.database.find(this.className, {
+          email: this.data.email,
+          objectId: {
+            $ne: this.objectId()
+          }
+        }, {
+          limit: 1
+        });
       }).then(results => {
         if (results.length > 0) {
           throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');
@@ -1036,7 +1346,6 @@ RestWrite.prototype.runDatabaseOperation = function () {
     }).then(response => {
       response.objectId = this.data.objectId;
       response.createdAt = this.data.createdAt;
-
       if (this.responseShouldHaveUsername) {
         response.username = this.data.username;
       }
@@ -1051,8 +1360,8 @@ RestWrite.prototype.runDatabaseOperation = function () {
 };
 
 // Returns nothing - doesn't wait for the trigger.
-RestWrite.prototype.runAfterTrigger = function () {
-  if (!this.response || !this.response.response) {
+RestWrite.prototype.runAfterSaveTrigger = function () {
+  if (!this.response || !this.response.response || this.runOptions.many) {
     return;
   }
 
@@ -1062,36 +1371,40 @@ RestWrite.prototype.runAfterTrigger = function () {
   if (!hasAfterSaveHook && !hasLiveQuery) {
     return Promise.resolve();
   }
-
-  var extraData = { className: this.className };
-  if (this.query && this.query.objectId) {
-    extraData.objectId = this.query.objectId;
+  const {
+    originalObject,
+    updatedObject
+  } = this.buildParseObjects();
+  updatedObject._handleSaveResponse(this.response.response, this.response.status || 200);
+  if (hasLiveQuery) {
+    this.config.database.loadSchema().then(schemaController => {
+      // Notify LiveQueryServer if possible
+      const perms = schemaController.getClassLevelPermissions(updatedObject.className);
+      this.config.liveQueryController.onAfterSave(updatedObject.className, updatedObject, originalObject, perms);
+    });
   }
-
-  // Build the original object, we only do this for a update write.
-  let originalObject;
-  if (this.query && this.query.objectId) {
-    originalObject = triggers.inflate(extraData, this.originalData);
+  if (!hasAfterSaveHook) {
+    return Promise.resolve();
   }
-
-  // Build the inflated object, different from beforeSave, originalData is not empty
-  // since developers can change data in the beforeSave.
-  const updatedObject = this.buildUpdatedObject(extraData);
-  updatedObject._handleSaveResponse(this.response.response, this.response.status || 200);
-
-  // Notifiy LiveQueryServer if possible
-  this.config.liveQueryController.onAfterSave(updatedObject.className, updatedObject, originalObject);
-
   // Run afterSave trigger
-  return triggers.maybeRunTrigger(triggers.Types.afterSave, this.auth, updatedObject, originalObject, this.config).catch(function (err) {
-    _logger2.default.warn('afterSave caught an error', err);
+  return triggers.maybeRunTrigger(triggers.Types.afterSave, this.auth, updatedObject, originalObject, this.config, this.context).then(result => {
+    const jsonReturned = result && !result._toFullJSON;
+    if (jsonReturned) {
+      this.pendingOps.operations = {};
+      this.response.response = result;
+    } else {
+      this.response.response = this._updateResponseWithData((result || updatedObject).toJSON(), this.data);
+    }
+  }).catch(function (err) {
+    _logger.default.warn('afterSave caught an error', err);
   });
 };
 
 // A helper to figure out what location this operation happens at.
 RestWrite.prototype.location = function () {
   var middle = this.className === '_User' ? '/users/' : '/classes/' + this.className + '/';
-  return this.config.mount + middle + this.data.objectId;
+  const mount = this.config.mount || this.config.serverURL;
+  return mount + middle + this.data.objectId;
 };
 
 // A helper to get the object id for this operation.
@@ -1113,28 +1426,62 @@ RestWrite.prototype.sanitizedData = function () {
 };
 
 // Returns an updated copy of the object
-RestWrite.prototype.buildUpdatedObject = function (extraData) {
+RestWrite.prototype.buildParseObjects = function () {
+  const extraData = {
+    className: this.className,
+    objectId: this.query?.objectId
+  };
+  let originalObject;
+  if (this.query && this.query.objectId) {
+    originalObject = triggers.inflate(extraData, this.originalData);
+  }
+  const className = Parse.Object.fromJSON(extraData);
+  const readOnlyAttributes = className.constructor.readOnlyAttributes ? className.constructor.readOnlyAttributes() : [];
+
+  // For _Role class, 'name' cannot be set after the role has an objectId.
+  // In afterSave context, _handleSaveResponse has already set the objectId,
+  // so we treat 'name' as read-only to avoid Parse SDK validation errors.
+  const isRoleAfterSave = this.className === '_Role' && this.response && !this.query;
+  if (isRoleAfterSave && this.data.name && !readOnlyAttributes.includes('name')) {
+    readOnlyAttributes.push('name');
+  }
+  if (!this.originalData) {
+    for (const attribute of readOnlyAttributes) {
+      extraData[attribute] = this.data[attribute];
+    }
+  }
   const updatedObject = triggers.inflate(extraData, this.originalData);
   Object.keys(this.data).reduce(function (data, key) {
-    if (key.indexOf(".") > 0) {
-      // subdocument key with dot notation ('x.y':v => 'x':{'y':v})
-      const splittedKey = key.split(".");
-      const parentProp = splittedKey[0];
-      let parentVal = updatedObject.get(parentProp);
-      if (typeof parentVal !== 'object') {
-        parentVal = {};
+    if (key.indexOf('.') > 0) {
+      if (typeof data[key].__op === 'string') {
+        if (!readOnlyAttributes.includes(key)) {
+          updatedObject.set(key, data[key]);
+        }
+      } else {
+        // subdocument key with dot notation { 'x.y': v } => { 'x': { 'y' : v } })
+        const splittedKey = key.split('.');
+        const parentProp = splittedKey[0];
+        let parentVal = updatedObject.get(parentProp);
+        if (typeof parentVal !== 'object') {
+          parentVal = {};
+        }
+        parentVal[splittedKey[1]] = data[key];
+        updatedObject.set(parentProp, parentVal);
       }
-      parentVal[splittedKey[1]] = data[key];
-      updatedObject.set(parentProp, parentVal);
       delete data[key];
     }
     return data;
   }, deepcopy(this.data));
-
-  updatedObject.set(this.sanitizedData());
-  return updatedObject;
+  const sanitized = this.sanitizedData();
+  for (const attribute of readOnlyAttributes) {
+    delete sanitized[attribute];
+  }
+  updatedObject.set(sanitized);
+  return {
+    updatedObject,
+    originalObject
+  };
 };
-
 RestWrite.prototype.cleanUserAuthData = function () {
   if (this.response && this.response.response && this.className === '_User') {
     const user = this.response.response;
@@ -1150,16 +1497,40 @@ RestWrite.prototype.cleanUserAuthData = function () {
     }
   }
 };
-
 RestWrite.prototype._updateResponseWithData = function (response, data) {
-  if (_lodash2.default.isEmpty(this.storage.fieldsChangedByTrigger)) {
+  const stateController = Parse.CoreManager.getObjectStateController();
+  const [pending] = stateController.getPendingOps(this.pendingOps.identifier);
+  for (const key in this.pendingOps.operations) {
+    if (!pending[key]) {
+      data[key] = this.originalData ? this.originalData[key] : {
+        __op: 'Delete'
+      };
+      this.storage.fieldsChangedByTrigger.push(key);
+    }
+  }
+  const skipKeys = [...(_SchemaController.requiredColumns.read[this.className] || [])];
+  if (!this.query) {
+    skipKeys.push('objectId', 'createdAt');
+  } else {
+    skipKeys.push('updatedAt');
+    delete response.objectId;
+  }
+  for (const key in response) {
+    if (skipKeys.includes(key)) {
+      continue;
+    }
+    const value = response[key];
+    if (value == null || value.__type && value.__type === 'Pointer' || util.isDeepStrictEqual(data[key], value) || util.isDeepStrictEqual((this.originalData || {})[key], value)) {
+      delete response[key];
+    }
+  }
+  if (_lodash.default.isEmpty(this.storage.fieldsChangedByTrigger)) {
     return response;
   }
   const clientSupportsDelete = ClientSDK.supportsForwardDelete(this.clientSDK);
   this.storage.fieldsChangedByTrigger.forEach(fieldName => {
     const dataValue = data[fieldName];
-
-    if (!response.hasOwnProperty(fieldName)) {
+    if (!Object.prototype.hasOwnProperty.call(response, fieldName)) {
       response[fieldName] = dataValue;
     }
 
@@ -1173,8 +1544,6 @@ RestWrite.prototype._updateResponseWithData = function (response, data) {
   });
   return response;
 };
-
-exports.default = RestWrite;
-
+var _default = exports.default = RestWrite;
 module.exports = RestWrite;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/RestWrite.js"],"names":["SchemaController","require","deepcopy","Auth","cryptoUtils","passwordCrypto","Parse","triggers","ClientSDK","RestWrite","config","auth","className","query","data","originalData","clientSDK","isReadOnly","Error","OPERATION_FORBIDDEN","storage","runOptions","objectId","INVALID_KEY_NAME","response","updatedAt","_encode","Date","iso","prototype","execute","Promise","resolve","then","getUserAndRoleACL","validateClientClassCreation","handleInstallation","handleSession","validateAuthData","runBeforeTrigger","validateSchema","setRequiredFieldsIfNeeded","transformUser","expandFilesForExistingObjects","destroyDuplicatedSessions","runDatabaseOperation","createSessionTokenIfNeeded","handleFollowup","runAfterTrigger","cleanUserAuthData","isMaster","acl","user","getUserRoles","roles","concat","id","allowClientClassCreation","systemClasses","indexOf","database","loadSchema","schemaController","hasClass","validateObject","triggerExists","Types","beforeSave","applicationId","extraData","originalObject","updatedObject","buildUpdatedObject","inflate","maybeRunTrigger","object","fieldsChangedByTrigger","_","reduce","result","value","key","isEqual","push","createdAt","newObjectId","objectIdSize","authData","username","isEmpty","USERNAME_MISSING","password","PASSWORD_MISSING","Object","keys","length","providers","canHandleAuthData","canHandle","provider","providerAuthData","hasToken","handleAuthData","UNSUPPORTED_SERVICE","handleAuthDataValidation","validations","map","authDataManager","getValidatorForProvider","all","findUsersWithAuthData","memo","queryKey","filter","q","findPromise","find","filteredObjectsByACL","objects","ACL","results","r","ACCOUNT_ALREADY_LINKED","join","userResult","mutatedAuthData","forEach","providerData","userAuthData","hasMutatedAuthData","userId","location","update","promise","error","RestQuery","master","__type","session","cacheController","del","sessionToken","undefined","_validatePasswordPolicy","hash","hashedPassword","_hashed_password","_validateUserName","_validateEmail","randomString","responseShouldHaveUsername","limit","USERNAME_TAKEN","email","__op","match","reject","INVALID_EMAIL_ADDRESS","EMAIL_TAKEN","userController","setEmailVerifyToken","passwordPolicy","_validatePasswordRequirements","_validatePasswordHistory","policyError","patternValidator","validatorCallback","VALIDATION_ERROR","doNotAllowUsername","maxPasswordHistory","oldPasswords","_password_history","take","newPassword","promises","compare","catch","err","preventLoginWithUnverifiedEmail","verifyUserEmails","createSessionToken","installationId","sessionData","createSession","createdWith","destroy","revokeSessionOnPasswordReset","sessionQuery","bind","sendVerificationEmail","INVALID_SESSION_TOKEN","additionalSessionData","action","INTERNAL_SERVER_ERROR","status","deviceToken","toLowerCase","deviceType","idMatch","objectIdMatch","installationIdMatch","deviceTokenMatches","orQueries","OBJECT_NOT_FOUND","delQuery","appIdentifier","code","objId","filesController","expandFilesInObject","role","clear","isUnauthenticated","SESSION_MISSING","download","downloadName","name","INVALID_ACL","read","write","maxPasswordAge","_password_changed_at","defer","shift","_updateResponseWithData","create","DUPLICATE_VALUE","userInfo","duplicated_field","hasAfterSaveHook","afterSave","hasLiveQuery","liveQueryController","_handleSaveResponse","onAfterSave","logger","warn","middle","mount","sanitizedData","test","_decode","splittedKey","split","parentProp","parentVal","get","set","clientSupportsDelete","supportsForwardDelete","fieldName","dataValue","hasOwnProperty","module","exports"],"mappings":"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","file":"RestWrite.js","sourcesContent":["// A RestWrite encapsulates everything we need to run an operation\n// that writes to the database.\n// This could be either a \"create\" or an \"update\".\n\nvar SchemaController = require('./Controllers/SchemaController');\nvar deepcopy = require('deepcopy');\n\nconst Auth = require('./Auth');\nvar cryptoUtils = require('./cryptoUtils');\nvar passwordCrypto = require('./password');\nvar Parse = require('parse/node');\nvar triggers = require('./triggers');\nvar ClientSDK = require('./ClientSDK');\nimport RestQuery from './RestQuery';\nimport _         from 'lodash';\nimport logger    from './logger';\n\n// query and data are both provided in REST API format. So data\n// types are encoded by plain old objects.\n// If query is null, this is a \"create\" and the data in data should be\n// created.\n// Otherwise this is an \"update\" - the object matching the query\n// should get updated with data.\n// RestWrite will handle objectId, createdAt, and updatedAt for\n// everything. It also knows to use triggers and special modifications\n// for the _User class.\nfunction RestWrite(config, auth, className, query, data, originalData, clientSDK) {\n  if (auth.isReadOnly) {\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform a write operation when using readOnlyMasterKey');\n  }\n  this.config = config;\n  this.auth = auth;\n  this.className = className;\n  this.clientSDK = clientSDK;\n  this.storage = {};\n  this.runOptions = {};\n  if (!query && data.objectId) {\n    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.');\n  }\n\n  // When the operation is complete, this.response may have several\n  // fields.\n  // response: the actual data to be returned\n  // status: the http status code. if not present, treated like a 200\n  // location: the location header. if not present, no location header\n  this.response = null;\n\n  // Processing this operation may mutate our data, so we operate on a\n  // copy\n  this.query = deepcopy(query);\n  this.data = deepcopy(data);\n  // We never change originalData, so we do not need a deep copy\n  this.originalData = originalData;\n\n  // The timestamp we'll use for this whole operation\n  this.updatedAt = Parse._encode(new Date()).iso;\n}\n\n// A convenient method to perform all the steps of processing the\n// write, in order.\n// Returns a promise for a {response, status, location} object.\n// status and location are optional.\nRestWrite.prototype.execute = function() {\n  return Promise.resolve().then(() => {\n    return this.getUserAndRoleACL();\n  }).then(() => {\n    return this.validateClientClassCreation();\n  }).then(() => {\n    return this.handleInstallation();\n  }).then(() => {\n    return this.handleSession();\n  }).then(() => {\n    return this.validateAuthData();\n  }).then(() => {\n    return this.runBeforeTrigger();\n  }).then(() => {\n    return this.validateSchema();\n  }).then(() => {\n    return this.setRequiredFieldsIfNeeded();\n  }).then(() => {\n    return this.transformUser();\n  }).then(() => {\n    return this.expandFilesForExistingObjects();\n  }).then(() => {\n    return this.destroyDuplicatedSessions();\n  }).then(() => {\n    return this.runDatabaseOperation();\n  }).then(() => {\n    return this.createSessionTokenIfNeeded();\n  }).then(() => {\n    return this.handleFollowup();\n  }).then(() => {\n    return this.runAfterTrigger();\n  }).then(() => {\n    return this.cleanUserAuthData();\n  }).then(() => {\n    return this.response;\n  })\n};\n\n// Uses the Auth object to get the list of roles, adds the user id\nRestWrite.prototype.getUserAndRoleACL = function() {\n  if (this.auth.isMaster) {\n    return Promise.resolve();\n  }\n\n  this.runOptions.acl = ['*'];\n\n  if (this.auth.user) {\n    return this.auth.getUserRoles().then((roles) => {\n      this.runOptions.acl = this.runOptions.acl.concat(roles, [this.auth.user.id]);\n      return;\n    });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Validates this operation against the allowClientClassCreation config.\nRestWrite.prototype.validateClientClassCreation = function() {\n  if (this.config.allowClientClassCreation === false && !this.auth.isMaster\n      && SchemaController.systemClasses.indexOf(this.className) === -1) {\n    return this.config.database.loadSchema()\n      .then(schemaController => schemaController.hasClass(this.className))\n      .then(hasClass => {\n        if (hasClass !== true) {\n          throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n            'This user is not allowed to access ' +\n                                'non-existent class: ' + this.className);\n        }\n      });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Validates this operation against the schema.\nRestWrite.prototype.validateSchema = function() {\n  return this.config.database.validateObject(this.className, this.data, this.query, this.runOptions);\n};\n\n// Runs any beforeSave triggers against this operation.\n// Any change leads to our data being mutated.\nRestWrite.prototype.runBeforeTrigger = function() {\n  if (this.response) {\n    return;\n  }\n\n  // Avoid doing any setup for triggers if there is no 'beforeSave' trigger for this class.\n  if (!triggers.triggerExists(this.className, triggers.Types.beforeSave, this.config.applicationId)) {\n    return Promise.resolve();\n  }\n\n  // Cloud code gets a bit of extra data for its objects\n  var extraData = {className: this.className};\n  if (this.query && this.query.objectId) {\n    extraData.objectId = this.query.objectId;\n  }\n\n  let originalObject = null;\n  const updatedObject = this.buildUpdatedObject(extraData);\n  if (this.query && this.query.objectId) {\n    // This is an update for existing object.\n    originalObject = triggers.inflate(extraData, this.originalData);\n  }\n\n  return Promise.resolve().then(() => {\n    return triggers.maybeRunTrigger(triggers.Types.beforeSave, this.auth, updatedObject, originalObject, this.config);\n  }).then((response) => {\n    if (response && response.object) {\n      this.storage.fieldsChangedByTrigger = _.reduce(response.object, (result, value, key) => {\n        if (!_.isEqual(this.data[key], value)) {\n          result.push(key);\n        }\n        return result;\n      }, []);\n      this.data = response.object;\n      // We should delete the objectId for an update write\n      if (this.query && this.query.objectId) {\n        delete this.data.objectId\n      }\n    }\n  });\n};\n\nRestWrite.prototype.setRequiredFieldsIfNeeded = function() {\n  if (this.data) {\n    // Add default fields\n    this.data.updatedAt = this.updatedAt;\n    if (!this.query) {\n      this.data.createdAt = this.updatedAt;\n\n      // Only assign new objectId if we are creating new object\n      if (!this.data.objectId) {\n        this.data.objectId = cryptoUtils.newObjectId(this.config.objectIdSize);\n      }\n    }\n  }\n  return Promise.resolve();\n};\n\n// Transforms auth data for a user object.\n// Does nothing if this isn't a user object.\n// Returns a promise for when we're done if it can't finish this tick.\nRestWrite.prototype.validateAuthData = function() {\n  if (this.className !== '_User') {\n    return;\n  }\n\n  if (!this.query && !this.data.authData) {\n    if (typeof this.data.username !== 'string' || _.isEmpty(this.data.username)) {\n      throw new Parse.Error(Parse.Error.USERNAME_MISSING,\n        'bad or missing username');\n    }\n    if (typeof this.data.password !== 'string' || _.isEmpty(this.data.password)) {\n      throw new Parse.Error(Parse.Error.PASSWORD_MISSING,\n        'password is required');\n    }\n  }\n\n  if (!this.data.authData || !Object.keys(this.data.authData).length) {\n    return;\n  }\n\n  var authData = this.data.authData;\n  var providers = Object.keys(authData);\n  if (providers.length > 0) {\n    const canHandleAuthData = providers.reduce((canHandle, provider) => {\n      var providerAuthData = authData[provider];\n      var hasToken = (providerAuthData && providerAuthData.id);\n      return canHandle && (hasToken || providerAuthData == null);\n    }, true);\n    if (canHandleAuthData) {\n      return this.handleAuthData(authData);\n    }\n  }\n  throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE,\n    'This authentication method is unsupported.');\n};\n\nRestWrite.prototype.handleAuthDataValidation = function(authData) {\n  const validations = Object.keys(authData).map((provider) => {\n    if (authData[provider] === null) {\n      return Promise.resolve();\n    }\n    const validateAuthData = this.config.authDataManager.getValidatorForProvider(provider);\n    if (!validateAuthData) {\n      throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE,\n        'This authentication method is unsupported.');\n    }\n    return validateAuthData(authData[provider]);\n  });\n  return Promise.all(validations);\n}\n\nRestWrite.prototype.findUsersWithAuthData = function(authData) {\n  const providers = Object.keys(authData);\n  const query = providers.reduce((memo, provider) => {\n    if (!authData[provider]) {\n      return memo;\n    }\n    const queryKey = `authData.${provider}.id`;\n    const query = {};\n    query[queryKey] = authData[provider].id;\n    memo.push(query);\n    return memo;\n  }, []).filter((q) => {\n    return typeof q !== 'undefined';\n  });\n\n  let findPromise = Promise.resolve([]);\n  if (query.length > 0) {\n    findPromise = this.config.database.find(\n      this.className,\n      {'$or': query}, {})\n  }\n\n  return findPromise;\n}\n\nRestWrite.prototype.filteredObjectsByACL = function(objects) {\n  if (this.auth.isMaster) {\n    return objects;\n  }\n  return objects.filter((object) => {\n    if (!object.ACL) {\n      return true; // legacy users that have no ACL field on them\n    }\n    // Regular users that have been locked out.\n    return object.ACL && Object.keys(object.ACL).length > 0;\n  });\n}\n\nRestWrite.prototype.handleAuthData = function(authData) {\n  let results;\n  return this.findUsersWithAuthData(authData).then((r) => {\n    results = this.filteredObjectsByACL(r);\n    if (results.length > 1) {\n      // More than 1 user with the passed id's\n      throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED,\n        'this auth is already used');\n    }\n\n    this.storage['authProvider'] = Object.keys(authData).join(',');\n\n    if (results.length > 0) {\n      const userResult = results[0];\n      const mutatedAuthData = {};\n      Object.keys(authData).forEach((provider) => {\n        const providerData = authData[provider];\n        const userAuthData = userResult.authData[provider];\n        if (!_.isEqual(providerData, userAuthData)) {\n          mutatedAuthData[provider] = providerData;\n        }\n      });\n      const hasMutatedAuthData = Object.keys(mutatedAuthData).length !== 0;\n      let userId;\n      if (this.query && this.query.objectId) {\n        userId = this.query.objectId;\n      } else if (this.auth && this.auth.user && this.auth.user.id) {\n        userId = this.auth.user.id;\n      }\n      if (!userId || userId === userResult.objectId) { // no user making the call\n        // OR the user making the call is the right one\n        // Login with auth data\n        delete results[0].password;\n\n        // need to set the objectId first otherwise location has trailing undefined\n        this.data.objectId = userResult.objectId;\n\n        if (!this.query || !this.query.objectId) { // this a login call, no userId passed\n          this.response = {\n            response: userResult,\n            location: this.location()\n          };\n        }\n        // If we didn't change the auth data, just keep going\n        if (!hasMutatedAuthData) {\n          return;\n        }\n        // We have authData that is updated on login\n        // that can happen when token are refreshed,\n        // We should update the token and let the user in\n        // We should only check the mutated keys\n        return this.handleAuthDataValidation(mutatedAuthData).then(() => {\n          // IF we have a response, we'll skip the database operation / beforeSave / afterSave etc...\n          // we need to set it up there.\n          // We are supposed to have a response only on LOGIN with authData, so we skip those\n          // If we're not logging in, but just updating the current user, we can safely skip that part\n          if (this.response) {\n            // Assign the new authData in the response\n            Object.keys(mutatedAuthData).forEach((provider) => {\n              this.response.response.authData[provider] = mutatedAuthData[provider];\n            });\n            // Run the DB update directly, as 'master'\n            // Just update the authData part\n            // Then we're good for the user, early exit of sorts\n            return this.config.database.update(this.className, {objectId: this.data.objectId}, {authData: mutatedAuthData}, {});\n          }\n        });\n      } else if (userId) {\n        // Trying to update auth data but users\n        // are different\n        if (userResult.objectId !== userId) {\n          throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED,\n            'this auth is already used');\n        }\n        // No auth data was mutated, just keep going\n        if (!hasMutatedAuthData) {\n          return;\n        }\n      }\n    }\n    return this.handleAuthDataValidation(authData);\n  });\n}\n\n\n// The non-third-party parts of User transformation\nRestWrite.prototype.transformUser = function() {\n  var promise = Promise.resolve();\n\n  if (this.className !== '_User') {\n    return promise;\n  }\n\n  if (!this.auth.isMaster && \"emailVerified\" in this.data) {\n    const error = `Clients aren't allowed to manually update email verification.`\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error);\n  }\n\n  // Do not cleanup session if objectId is not set\n  if (this.query && this.objectId()) {\n    // If we're updating a _User object, we need to clear out the cache for that user. Find all their\n    // session tokens, and remove them from the cache.\n    promise = new RestQuery(this.config, Auth.master(this.config), '_Session', {\n      user: {\n        __type: \"Pointer\",\n        className: \"_User\",\n        objectId: this.objectId(),\n      }\n    }).execute()\n      .then(results => {\n        results.results.forEach(session => this.config.cacheController.user.del(session.sessionToken));\n      });\n  }\n\n  return promise.then(() => {\n    // Transform the password\n    if (this.data.password === undefined) { // ignore only if undefined. should proceed if empty ('')\n      return Promise.resolve();\n    }\n\n    if (this.query) {\n      this.storage['clearSessions'] = true;\n      // Generate a new session only if the user requested\n      if (!this.auth.isMaster) {\n        this.storage['generateNewSession'] = true;\n      }\n    }\n\n    return this._validatePasswordPolicy().then(() => {\n      return passwordCrypto.hash(this.data.password).then((hashedPassword) => {\n        this.data._hashed_password = hashedPassword;\n        delete this.data.password;\n      });\n    });\n\n  }).then(() => {\n    return this._validateUserName();\n  }).then(() => {\n    return this._validateEmail();\n  });\n};\n\nRestWrite.prototype._validateUserName = function () {\n  // Check for username uniqueness\n  if (!this.data.username) {\n    if (!this.query) {\n      this.data.username = cryptoUtils.randomString(25);\n      this.responseShouldHaveUsername = true;\n    }\n    return Promise.resolve();\n  }\n  // We need to a find to check for duplicate username in case they are missing the unique index on usernames\n  // TODO: Check if there is a unique index, and if so, skip this query.\n  return this.config.database.find(\n    this.className,\n    {username: this.data.username, objectId: {'$ne': this.objectId()}},\n    {limit: 1}\n  ).then(results => {\n    if (results.length > 0) {\n      throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');\n    }\n    return;\n  });\n};\n\nRestWrite.prototype._validateEmail = function() {\n  if (!this.data.email || this.data.email.__op === 'Delete') {\n    return Promise.resolve();\n  }\n  // Validate basic email address format\n  if (!this.data.email.match(/^.+@.+$/)) {\n    return Promise.reject(new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'Email address format is invalid.'));\n  }\n  // Same problem for email as above for username\n  return this.config.database.find(\n    this.className,\n    {email: this.data.email, objectId: {'$ne': this.objectId()}},\n    {limit: 1}\n  ).then(results => {\n    if (results.length > 0) {\n      throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');\n    }\n    if (\n      !this.data.authData ||\n      !Object.keys(this.data.authData).length ||\n      Object.keys(this.data.authData).length === 1 && Object.keys(this.data.authData)[0] === 'anonymous'\n    ) {\n      // We updated the email, send a new validation\n      this.storage['sendVerificationEmail'] = true;\n      this.config.userController.setEmailVerifyToken(this.data);\n    }\n  });\n};\n\nRestWrite.prototype._validatePasswordPolicy = function() {\n  if (!this.config.passwordPolicy)\n    return Promise.resolve();\n  return this._validatePasswordRequirements().then(() => {\n    return this._validatePasswordHistory();\n  });\n};\n\n\nRestWrite.prototype._validatePasswordRequirements = function() {\n  // check if the password conforms to the defined password policy if configured\n  const policyError = 'Password does not meet the Password Policy requirements.';\n\n  // check whether the password meets the password strength requirements\n  if (this.config.passwordPolicy.patternValidator && !this.config.passwordPolicy.patternValidator(this.data.password) ||\n    this.config.passwordPolicy.validatorCallback && !this.config.passwordPolicy.validatorCallback(this.data.password)) {\n    return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n  }\n\n  // check whether password contain username\n  if (this.config.passwordPolicy.doNotAllowUsername === true) {\n    if (this.data.username) { // username is not passed during password reset\n      if (this.data.password.indexOf(this.data.username) >= 0)\n        return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n    } else { // retrieve the User object using objectId during password reset\n      return this.config.database.find('_User', {objectId: this.objectId()})\n        .then(results => {\n          if (results.length != 1) {\n            throw undefined;\n          }\n          if (this.data.password.indexOf(results[0].username) >= 0)\n            return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n          return Promise.resolve();\n        });\n    }\n  }\n  return Promise.resolve();\n};\n\nRestWrite.prototype._validatePasswordHistory = function() {\n  // check whether password is repeating from specified history\n  if (this.query && this.config.passwordPolicy.maxPasswordHistory) {\n    return this.config.database.find('_User', {objectId: this.objectId()}, {keys: [\"_password_history\", \"_hashed_password\"]})\n      .then(results => {\n        if (results.length != 1) {\n          throw undefined;\n        }\n        const user = results[0];\n        let oldPasswords = [];\n        if (user._password_history)\n          oldPasswords = _.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory - 1);\n        oldPasswords.push(user.password);\n        const newPassword = this.data.password;\n        // compare the new password hash with all old password hashes\n        const promises = oldPasswords.map(function (hash) {\n          return passwordCrypto.compare(newPassword, hash).then((result) => {\n            if (result) // reject if there is a match\n              return Promise.reject(\"REPEAT_PASSWORD\");\n            return Promise.resolve();\n          })\n        });\n        // wait for all comparisons to complete\n        return Promise.all(promises).then(() => {\n          return Promise.resolve();\n        }).catch(err => {\n          if (err === \"REPEAT_PASSWORD\") // a match was found\n            return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, `New password should not be the same as last ${this.config.passwordPolicy.maxPasswordHistory} passwords.`));\n          throw err;\n        });\n      });\n  }\n  return Promise.resolve();\n};\n\nRestWrite.prototype.createSessionTokenIfNeeded = function() {\n  if (this.className !== '_User') {\n    return;\n  }\n  if (this.query) {\n    return;\n  }\n  if (!this.storage['authProvider'] // signup call, with\n      && this.config.preventLoginWithUnverifiedEmail // no login without verification\n      && this.config.verifyUserEmails) { // verification is on\n    return; // do not create the session token in that case!\n  }\n  return this.createSessionToken();\n}\n\nRestWrite.prototype.createSessionToken = function() {\n  // cloud installationId from Cloud Code,\n  // never create session tokens from there.\n  if (this.auth.installationId && this.auth.installationId === 'cloud') {\n    return;\n  }\n\n  const {\n    sessionData,\n    createSession,\n  } = Auth.createSession(this.config, {\n    userId: this.objectId(),\n    createdWith: {\n      'action': this.storage['authProvider'] ? 'login' : 'signup',\n      'authProvider': this.storage['authProvider'] || 'password'\n    },\n    installationId: this.auth.installationId,\n  });\n\n  if (this.response && this.response.response) {\n    this.response.response.sessionToken = sessionData.sessionToken;\n  }\n\n  return createSession();\n}\n\nRestWrite.prototype.destroyDuplicatedSessions = function() {\n  // Only for _Session, and at creation time\n  if (this.className != '_Session' || this.query) {\n    return;\n  }\n  // Destroy the sessions in 'Background'\n  const {\n    user,\n    installationId,\n    sessionToken,\n  } = this.data;\n  if (!user || !installationId)  {\n    return;\n  }\n  if (!user.objectId) {\n    return;\n  }\n  this.config.database.destroy('_Session', {\n    user,\n    installationId,\n    sessionToken: { '$ne': sessionToken },\n  });\n}\n\n// Handles any followup logic\nRestWrite.prototype.handleFollowup = function() {\n  if (this.storage && this.storage['clearSessions'] && this.config.revokeSessionOnPasswordReset) {\n    var sessionQuery = {\n      user: {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: this.objectId()\n      }\n    };\n    delete this.storage['clearSessions'];\n    return this.config.database.destroy('_Session', sessionQuery)\n      .then(this.handleFollowup.bind(this));\n  }\n\n  if (this.storage && this.storage['generateNewSession']) {\n    delete this.storage['generateNewSession'];\n    return this.createSessionToken()\n      .then(this.handleFollowup.bind(this));\n  }\n\n  if (this.storage && this.storage['sendVerificationEmail']) {\n    delete this.storage['sendVerificationEmail'];\n    // Fire and forget!\n    this.config.userController.sendVerificationEmail(this.data);\n    return this.handleFollowup.bind(this);\n  }\n};\n\n// Handles the _Session class specialness.\n// Does nothing if this isn't an _Session object.\nRestWrite.prototype.handleSession = function() {\n  if (this.response || this.className !== '_Session') {\n    return;\n  }\n\n  if (!this.auth.user && !this.auth.isMaster) {\n    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,\n      'Session token required.');\n  }\n\n  // TODO: Verify proper error to throw\n  if (this.data.ACL) {\n    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'Cannot set ' +\n                          'ACL on a Session.');\n  }\n\n  if (this.query) {\n    if (this.data.user && !this.auth.isMaster && this.data.user.objectId != this.auth.user.id) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    } else if (this.data.installationId) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    } else if (this.data.sessionToken) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    }\n  }\n\n  if (!this.query && !this.auth.isMaster) {\n    const additionalSessionData = {};\n    for (var key in this.data) {\n      if (key === 'objectId' || key === 'user') {\n        continue;\n      }\n      additionalSessionData[key] = this.data[key];\n    }\n\n    const { sessionData, createSession } = Auth.createSession(this.config, {\n      userId: this.auth.user.id,\n      createdWith: {\n        action: 'create',\n      },\n      additionalSessionData\n    });\n\n    return createSession().then((results) => {\n      if (!results.response) {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR,\n          'Error creating session.');\n      }\n      sessionData['objectId'] = results.response['objectId'];\n      this.response = {\n        status: 201,\n        location: results.location,\n        response: sessionData\n      };\n    });\n  }\n};\n\n// Handles the _Installation class specialness.\n// Does nothing if this isn't an installation object.\n// If an installation is found, this can mutate this.query and turn a create\n// into an update.\n// Returns a promise for when we're done if it can't finish this tick.\nRestWrite.prototype.handleInstallation = function() {\n  if (this.response || this.className !== '_Installation') {\n    return;\n  }\n\n  if (!this.query && !this.data.deviceToken && !this.data.installationId && !this.auth.installationId) {\n    throw new Parse.Error(135,\n      'at least one ID field (deviceToken, installationId) ' +\n                          'must be specified in this operation');\n  }\n\n  // If the device token is 64 characters long, we assume it is for iOS\n  // and lowercase it.\n  if (this.data.deviceToken && this.data.deviceToken.length == 64) {\n    this.data.deviceToken = this.data.deviceToken.toLowerCase();\n  }\n\n  // We lowercase the installationId if present\n  if (this.data.installationId) {\n    this.data.installationId = this.data.installationId.toLowerCase();\n  }\n\n  let installationId = this.data.installationId;\n\n  // If data.installationId is not set and we're not master, we can lookup in auth\n  if (!installationId && !this.auth.isMaster) {\n    installationId = this.auth.installationId;\n  }\n\n  if (installationId) {\n    installationId = installationId.toLowerCase();\n  }\n\n  // Updating _Installation but not updating anything critical\n  if (this.query && !this.data.deviceToken\n                  && !installationId && !this.data.deviceType) {\n    return;\n  }\n\n  var promise = Promise.resolve();\n\n  var idMatch; // Will be a match on either objectId or installationId\n  var objectIdMatch;\n  var installationIdMatch;\n  var deviceTokenMatches = [];\n\n  // Instead of issuing 3 reads, let's do it with one OR.\n  const orQueries = [];\n  if (this.query && this.query.objectId) {\n    orQueries.push({\n      objectId: this.query.objectId\n    });\n  }\n  if (installationId) {\n    orQueries.push({\n      'installationId': installationId\n    });\n  }\n  if (this.data.deviceToken) {\n    orQueries.push({'deviceToken': this.data.deviceToken});\n  }\n\n  if (orQueries.length == 0) {\n    return;\n  }\n\n  promise = promise.then(() => {\n    return this.config.database.find('_Installation', {\n      '$or': orQueries\n    }, {});\n  }).then((results) => {\n    results.forEach((result) => {\n      if (this.query && this.query.objectId && result.objectId == this.query.objectId) {\n        objectIdMatch = result;\n      }\n      if (result.installationId == installationId) {\n        installationIdMatch = result;\n      }\n      if (result.deviceToken == this.data.deviceToken) {\n        deviceTokenMatches.push(result);\n      }\n    });\n\n    // Sanity checks when running a query\n    if (this.query && this.query.objectId) {\n      if (!objectIdMatch) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n          'Object not found for update.');\n      }\n      if (this.data.installationId && objectIdMatch.installationId &&\n          this.data.installationId !== objectIdMatch.installationId) {\n        throw new Parse.Error(136,\n          'installationId may not be changed in this ' +\n                                'operation');\n      }\n      if (this.data.deviceToken && objectIdMatch.deviceToken &&\n          this.data.deviceToken !== objectIdMatch.deviceToken &&\n          !this.data.installationId && !objectIdMatch.installationId) {\n        throw new Parse.Error(136,\n          'deviceToken may not be changed in this ' +\n                                'operation');\n      }\n      if (this.data.deviceType && this.data.deviceType &&\n          this.data.deviceType !== objectIdMatch.deviceType) {\n        throw new Parse.Error(136,\n          'deviceType may not be changed in this ' +\n                                'operation');\n      }\n    }\n\n    if (this.query && this.query.objectId && objectIdMatch) {\n      idMatch = objectIdMatch;\n    }\n\n    if (installationId && installationIdMatch) {\n      idMatch = installationIdMatch;\n    }\n    // need to specify deviceType only if it's new\n    if (!this.query && !this.data.deviceType && !idMatch) {\n      throw new Parse.Error(135,\n        'deviceType must be specified in this operation');\n    }\n\n  }).then(() => {\n    if (!idMatch) {\n      if (!deviceTokenMatches.length) {\n        return;\n      } else if (deviceTokenMatches.length == 1 &&\n        (!deviceTokenMatches[0]['installationId'] || !installationId)\n      ) {\n        // Single match on device token but none on installationId, and either\n        // the passed object or the match is missing an installationId, so we\n        // can just return the match.\n        return deviceTokenMatches[0]['objectId'];\n      } else if (!this.data.installationId) {\n        throw new Parse.Error(132,\n          'Must specify installationId when deviceToken ' +\n                              'matches multiple Installation objects');\n      } else {\n        // Multiple device token matches and we specified an installation ID,\n        // or a single match where both the passed and matching objects have\n        // an installation ID. Try cleaning out old installations that match\n        // the deviceToken, and return nil to signal that a new object should\n        // be created.\n        var delQuery = {\n          'deviceToken': this.data.deviceToken,\n          'installationId': {\n            '$ne': installationId\n          }\n        };\n        if (this.data.appIdentifier) {\n          delQuery['appIdentifier'] = this.data.appIdentifier;\n        }\n        this.config.database.destroy('_Installation', delQuery)\n          .catch(err => {\n            if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n              // no deletions were made. Can be ignored.\n              return;\n            }\n            // rethrow the error\n            throw err;\n          });\n        return;\n      }\n    } else {\n      if (deviceTokenMatches.length == 1 &&\n        !deviceTokenMatches[0]['installationId']) {\n        // Exactly one device token match and it doesn't have an installation\n        // ID. This is the one case where we want to merge with the existing\n        // object.\n        const delQuery = {objectId: idMatch.objectId};\n        return this.config.database.destroy('_Installation', delQuery)\n          .then(() => {\n            return deviceTokenMatches[0]['objectId'];\n          })\n          .catch(err => {\n            if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n              // no deletions were made. Can be ignored\n              return;\n            }\n            // rethrow the error\n            throw err;\n          });\n      } else {\n        if (this.data.deviceToken &&\n          idMatch.deviceToken != this.data.deviceToken) {\n          // We're setting the device token on an existing installation, so\n          // we should try cleaning out old installations that match this\n          // device token.\n          const delQuery = {\n            'deviceToken': this.data.deviceToken,\n          };\n          // We have a unique install Id, use that to preserve\n          // the interesting installation\n          if (this.data.installationId) {\n            delQuery['installationId'] = {\n              '$ne': this.data.installationId\n            }\n          } else if (idMatch.objectId && this.data.objectId\n                    && idMatch.objectId == this.data.objectId) {\n            // we passed an objectId, preserve that instalation\n            delQuery['objectId'] = {\n              '$ne': idMatch.objectId\n            }\n          } else {\n            // What to do here? can't really clean up everything...\n            return idMatch.objectId;\n          }\n          if (this.data.appIdentifier) {\n            delQuery['appIdentifier'] = this.data.appIdentifier;\n          }\n          this.config.database.destroy('_Installation', delQuery)\n            .catch(err => {\n              if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n                // no deletions were made. Can be ignored.\n                return;\n              }\n              // rethrow the error\n              throw err;\n            });\n        }\n        // In non-merge scenarios, just return the installation match id\n        return idMatch.objectId;\n      }\n    }\n  }).then((objId) => {\n    if (objId) {\n      this.query = {objectId: objId};\n      delete this.data.objectId;\n      delete this.data.createdAt;\n    }\n    // TODO: Validate ops (add/remove on channels, $inc on badge, etc.)\n  });\n  return promise;\n};\n\n// If we short-circuted the object response - then we need to make sure we expand all the files,\n// since this might not have a query, meaning it won't return the full result back.\n// TODO: (nlutsenko) This should die when we move to per-class based controllers on _Session/_User\nRestWrite.prototype.expandFilesForExistingObjects = function() {\n  // Check whether we have a short-circuited response - only then run expansion.\n  if (this.response && this.response.response) {\n    this.config.filesController.expandFilesInObject(this.config, this.response.response);\n  }\n};\n\nRestWrite.prototype.runDatabaseOperation = function() {\n  if (this.response) {\n    return;\n  }\n\n  if (this.className === '_Role') {\n    this.config.cacheController.role.clear();\n  }\n\n  if (this.className === '_User' &&\n      this.query &&\n      this.auth.isUnauthenticated()) {\n    throw new Parse.Error(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`);\n  }\n\n  if (this.className === '_Product' && this.data.download) {\n    this.data.downloadName = this.data.download.name;\n  }\n\n  // TODO: Add better detection for ACL, ensuring a user can't be locked from\n  //       their own user record.\n  if (this.data.ACL && this.data.ACL['*unresolved']) {\n    throw new Parse.Error(Parse.Error.INVALID_ACL, 'Invalid ACL.');\n  }\n\n  if (this.query) {\n    // Force the user to not lockout\n    // Matched with parse.com\n    if (this.className === '_User' && this.data.ACL && this.auth.isMaster !== true) {\n      this.data.ACL[this.query.objectId] = { read: true, write: true };\n    }\n    // update password timestamp if user password is being changed\n    if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {\n      this.data._password_changed_at = Parse._encode(new Date());\n    }\n    // Ignore createdAt when update\n    delete this.data.createdAt;\n\n    let defer = Promise.resolve();\n    // if password history is enabled then save the current password to history\n    if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordHistory) {\n      defer = this.config.database.find('_User', {objectId: this.objectId()}, {keys: [\"_password_history\", \"_hashed_password\"]}).then(results => {\n        if (results.length != 1) {\n          throw undefined;\n        }\n        const user = results[0];\n        let oldPasswords = [];\n        if (user._password_history) {\n          oldPasswords = _.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory);\n        }\n        //n-1 passwords go into history including last password\n        while (oldPasswords.length > this.config.passwordPolicy.maxPasswordHistory - 2) {\n          oldPasswords.shift();\n        }\n        oldPasswords.push(user.password);\n        this.data._password_history = oldPasswords;\n      });\n    }\n\n    return defer.then(() => {\n      // Run an update\n      return this.config.database.update(this.className, this.query, this.data, this.runOptions)\n        .then(response => {\n          response.updatedAt = this.updatedAt;\n          this._updateResponseWithData(response, this.data);\n          this.response = { response };\n        });\n    });\n  } else {\n    // Set the default ACL and password timestamp for the new _User\n    if (this.className === '_User') {\n      var ACL = this.data.ACL;\n      // default public r/w ACL\n      if (!ACL) {\n        ACL = {};\n        ACL['*'] = { read: true, write: false };\n      }\n      // make sure the user is not locked down\n      ACL[this.data.objectId] = { read: true, write: true };\n      this.data.ACL = ACL;\n      // password timestamp to be used when password expiry policy is enforced\n      if (this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {\n        this.data._password_changed_at = Parse._encode(new Date());\n      }\n    }\n\n    // Run a create\n    return this.config.database.create(this.className, this.data, this.runOptions)\n      .catch(error => {\n        if (this.className !== '_User' || error.code !== Parse.Error.DUPLICATE_VALUE) {\n          throw error;\n        }\n\n        // Quick check, if we were able to infer the duplicated field name\n        if (error && error.userInfo && error.userInfo.duplicated_field === 'username') {\n          throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');\n        }\n\n        if (error && error.userInfo && error.userInfo.duplicated_field === 'email') {\n          throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');\n        }\n\n        // If this was a failed user creation due to username or email already taken, we need to\n        // check whether it was username or email and return the appropriate error.\n        // Fallback to the original method\n        // TODO: See if we can later do this without additional queries by using named indexes.\n        return this.config.database.find(\n          this.className,\n          { username: this.data.username, objectId: {'$ne': this.objectId()} },\n          { limit: 1 }\n        )\n          .then(results => {\n            if (results.length > 0) {\n              throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');\n            }\n            return this.config.database.find(\n              this.className,\n              { email: this.data.email, objectId: {'$ne': this.objectId()} },\n              { limit: 1 }\n            );\n          })\n          .then(results => {\n            if (results.length > 0) {\n              throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');\n            }\n            throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          });\n      })\n      .then(response => {\n        response.objectId = this.data.objectId;\n        response.createdAt = this.data.createdAt;\n\n        if (this.responseShouldHaveUsername) {\n          response.username = this.data.username;\n        }\n        this._updateResponseWithData(response, this.data);\n        this.response = {\n          status: 201,\n          response,\n          location: this.location()\n        };\n      });\n  }\n};\n\n// Returns nothing - doesn't wait for the trigger.\nRestWrite.prototype.runAfterTrigger = function() {\n  if (!this.response || !this.response.response) {\n    return;\n  }\n\n  // Avoid doing any setup for triggers if there is no 'afterSave' trigger for this class.\n  const hasAfterSaveHook = triggers.triggerExists(this.className, triggers.Types.afterSave, this.config.applicationId);\n  const hasLiveQuery = this.config.liveQueryController.hasLiveQuery(this.className);\n  if (!hasAfterSaveHook && !hasLiveQuery) {\n    return Promise.resolve();\n  }\n\n  var extraData = {className: this.className};\n  if (this.query && this.query.objectId) {\n    extraData.objectId = this.query.objectId;\n  }\n\n  // Build the original object, we only do this for a update write.\n  let originalObject;\n  if (this.query && this.query.objectId) {\n    originalObject = triggers.inflate(extraData, this.originalData);\n  }\n\n  // Build the inflated object, different from beforeSave, originalData is not empty\n  // since developers can change data in the beforeSave.\n  const updatedObject = this.buildUpdatedObject(extraData);\n  updatedObject._handleSaveResponse(this.response.response, this.response.status || 200);\n\n  // Notifiy LiveQueryServer if possible\n  this.config.liveQueryController.onAfterSave(updatedObject.className, updatedObject, originalObject);\n\n  // Run afterSave trigger\n  return triggers.maybeRunTrigger(triggers.Types.afterSave, this.auth, updatedObject, originalObject, this.config)\n    .catch(function(err) {\n      logger.warn('afterSave caught an error', err);\n    })\n};\n\n// A helper to figure out what location this operation happens at.\nRestWrite.prototype.location = function() {\n  var middle = (this.className === '_User' ? '/users/' :\n    '/classes/' + this.className + '/');\n  return this.config.mount + middle + this.data.objectId;\n};\n\n// A helper to get the object id for this operation.\n// Because it could be either on the query or on the data\nRestWrite.prototype.objectId = function() {\n  return this.data.objectId || this.query.objectId;\n};\n\n// Returns a copy of the data and delete bad keys (_auth_data, _hashed_password...)\nRestWrite.prototype.sanitizedData = function() {\n  const data = Object.keys(this.data).reduce((data, key) => {\n    // Regexp comes from Parse.Object.prototype.validate\n    if (!(/^[A-Za-z][0-9A-Za-z_]*$/).test(key)) {\n      delete data[key];\n    }\n    return data;\n  }, deepcopy(this.data));\n  return Parse._decode(undefined, data);\n}\n\n// Returns an updated copy of the object\nRestWrite.prototype.buildUpdatedObject = function (extraData) {\n  const updatedObject = triggers.inflate(extraData, this.originalData);\n  Object.keys(this.data).reduce(function (data, key) {\n    if (key.indexOf(\".\") > 0) {\n      // subdocument key with dot notation ('x.y':v => 'x':{'y':v})\n      const splittedKey = key.split(\".\");\n      const parentProp = splittedKey[0];\n      let parentVal = updatedObject.get(parentProp);\n      if(typeof parentVal !== 'object') {\n        parentVal = {};\n      }\n      parentVal[splittedKey[1]] = data[key];\n      updatedObject.set(parentProp, parentVal);\n      delete data[key];\n    }\n    return data;\n  }, deepcopy(this.data));\n\n  updatedObject.set(this.sanitizedData());\n  return updatedObject;\n};\n\nRestWrite.prototype.cleanUserAuthData = function() {\n  if (this.response && this.response.response && this.className === '_User') {\n    const user = this.response.response;\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\nRestWrite.prototype._updateResponseWithData = function(response, data) {\n  if (_.isEmpty(this.storage.fieldsChangedByTrigger)) {\n    return response;\n  }\n  const clientSupportsDelete = ClientSDK.supportsForwardDelete(this.clientSDK);\n  this.storage.fieldsChangedByTrigger.forEach(fieldName => {\n    const dataValue = data[fieldName];\n\n    if(!response.hasOwnProperty(fieldName)) {\n      response[fieldName] = dataValue;\n    }\n\n    // Strips operations from responses\n    if (response[fieldName] && response[fieldName].__op) {\n      delete response[fieldName];\n      if (clientSupportsDelete && dataValue.__op == 'Delete') {\n        response[fieldName] = dataValue;\n      }\n    }\n  });\n  return response;\n}\n\nexport default RestWrite;\nmodule.exports = RestWrite;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_RestQuery","_interopRequireDefault","require","_lodash","_logger","_SchemaController","_Error","e","__esModule","default","SchemaController","deepcopy","Auth","Utils","cryptoUtils","passwordCrypto","Parse","triggers","ClientSDK","util","RestWrite","config","auth","className","query","data","originalData","clientSDK","context","action","isReadOnly","createSanitizedError","Error","OPERATION_FORBIDDEN","storage","runOptions","allowCustomObjectId","Object","prototype","hasOwnProperty","call","objectId","MISSING_OBJECT_ID","INVALID_KEY_NAME","id","response","updatedAt","_encode","Date","iso","validSchemaController","pendingOps","operations","identifier","execute","Promise","resolve","then","getUserAndRoleACL","validateClientClassCreation","handleInstallation","handleSession","validateAuthData","checkRestrictedFields","runBeforeSaveTrigger","ensureUniqueAuthDataId","deleteEmailResetTokenIfNeeded","validateSchema","schemaController","setRequiredFieldsIfNeeded","transformUser","expandFilesForExistingObjects","destroyDuplicatedSessions","runDatabaseOperation","createSessionTokenIfNeeded","handleFollowup","runAfterSaveTrigger","cleanUserAuthData","authDataResponse","rejectSignup","preventSignupWithUnverifiedEmail","EMAIL_NOT_FOUND","isMaster","isMaintenance","acl","user","getUserRoles","roles","concat","allowClientClassCreation","systemClasses","indexOf","database","loadSchema","hasClass","validateObject","many","triggerExists","Types","beforeSave","applicationId","originalObject","updatedObject","buildParseObjects","_getStateIdentifier","stateController","CoreManager","getObjectStateController","pending","getPendingOps","databasePromise","update","create","result","length","OBJECT_NOT_FOUND","maybeRunTrigger","object","fieldsChangedByTrigger","_","reduce","value","key","isEqual","push","checkProhibitedKeywords","error","runBeforeLoginTrigger","userData","beforeLogin","extraData","filesController","expandFilesInObject","inflate","getAllClasses","allClasses","schema","find","oneClass","setRequiredFieldIfNeeded","fieldName","setDefault","undefined","__op","fields","defaultValue","required","VALIDATION_ERROR","classLevelPermissions","ACL","JSON","stringify","read","write","currentUser","createdAt","__type","newObjectId","objectIdSize","keys","forEach","authData","hasUsernameAndPassword","username","password","isEmpty","USERNAME_MISSING","PASSWORD_MISSING","UNSUPPORTED_SERVICE","providers","canHandleAuthData","some","provider","providerAuthData","getUserId","handleAuthData","filteredObjectsByACL","objects","filter","hasAuthDataId","r","findUsersWithAuthData","results","ACCOUNT_ALREADY_LINKED","userId","userResult","foundUserIsNotCurrentUser","handleAuthDataValidation","validatedAuthData","authProvider","join","hasMutatedAuthData","mutatedAuthData","isCurrentUserLoggedOrMaster","isLogin","location","checkIfUserHasProvidedConfiguredProvidersForLogin","allowExpiredAuthDataToken","res","promise","RestQuery","method","Method","master","runBeforeFind","restWhere","session","cacheController","del","sessionToken","_validatePasswordPolicy","hash","hashedPassword","_hashed_password","_validateUserName","_validateEmail","randomString","responseShouldHaveUsername","$ne","limit","caseInsensitive","USERNAME_TAKEN","email","match","reject","INVALID_EMAIL_ADDRESS","EMAIL_TAKEN","request","original","ip","installationId","userController","setEmailVerifyToken","passwordPolicy","_validatePasswordRequirements","_validatePasswordHistory","policyError","validationError","containsUsernameError","patternValidator","validatorCallback","doNotAllowUsername","maxPasswordHistory","maintenance","oldPasswords","_password_history","take","newPassword","promises","map","compare","all","catch","err","verifyUserEmails","preventLoginWithUnverifiedEmail","createSessionToken","sessionData","createSession","createdWith","additionalSessionData","token","newToken","expiresAt","generateSessionExpiresAt","assign","addOps","_perishable_token","_perishable_token_expires_at","destroy","revokeSessionOnPasswordReset","sessionQuery","bind","sendVerificationEmail","INVALID_SESSION_TOKEN","$and","INTERNAL_SERVER_ERROR","status","deviceToken","toLowerCase","deviceType","idMatch","objectIdMatch","installationIdMatch","deviceTokenMatches","orQueries","$or","delQuery","appIdentifier","code","objId","role","clear","liveQueryController","clearCachedRoles","isUnauthenticated","SESSION_MISSING","download","downloadName","name","INVALID_ACL","maxPasswordAge","_password_changed_at","defer","Math","max","shift","_updateResponseWithData","enforcePrivateUsers","DUPLICATE_VALUE","userInfo","duplicated_field","hasAfterSaveHook","afterSave","hasLiveQuery","_handleSaveResponse","perms","getClassLevelPermissions","onAfterSave","jsonReturned","_toFullJSON","toJSON","logger","warn","middle","mount","serverURL","sanitizedData","test","_decode","fromJSON","readOnlyAttributes","constructor","isRoleAfterSave","includes","attribute","set","splittedKey","split","parentProp","parentVal","get","sanitized","skipKeys","requiredColumns","isDeepStrictEqual","clientSupportsDelete","supportsForwardDelete","dataValue","_default","exports","module"],"sources":["../src/RestWrite.js"],"sourcesContent":["// A RestWrite encapsulates everything we need to run an operation\n// that writes to the database.\n// This could be either a \"create\" or an \"update\".\n\nvar SchemaController = require('./Controllers/SchemaController');\nvar deepcopy = require('deepcopy');\n\nconst Auth = require('./Auth');\nconst Utils = require('./Utils');\nvar cryptoUtils = require('./cryptoUtils');\nvar passwordCrypto = require('./password');\nvar Parse = require('parse/node');\nvar triggers = require('./triggers');\nvar ClientSDK = require('./ClientSDK');\nconst util = require('util');\nimport RestQuery from './RestQuery';\nimport _ from 'lodash';\nimport logger from './logger';\nimport { requiredColumns } from './Controllers/SchemaController';\nimport { createSanitizedError } from './Error';\n\n// query and data are both provided in REST API format. So data\n// types are encoded by plain old objects.\n// If query is null, this is a \"create\" and the data in data should be\n// created.\n// Otherwise this is an \"update\" - the object matching the query\n// should get updated with data.\n// RestWrite will handle objectId, createdAt, and updatedAt for\n// everything. It also knows to use triggers and special modifications\n// for the _User class.\nfunction RestWrite(config, auth, className, query, data, originalData, clientSDK, context, action) {\n  if (auth.isReadOnly) {\n    throw createSanitizedError(\n      Parse.Error.OPERATION_FORBIDDEN,\n      'Cannot perform a write operation when using readOnlyMasterKey',\n      config\n    );\n  }\n  this.config = config;\n  this.auth = auth;\n  this.className = className;\n  this.clientSDK = clientSDK;\n  this.storage = {};\n  this.runOptions = {};\n  this.context = context || {};\n\n  if (action) {\n    this.runOptions.action = action;\n  }\n\n  if (!query) {\n    if (this.config.allowCustomObjectId) {\n      if (Object.prototype.hasOwnProperty.call(data, 'objectId') && !data.objectId) {\n        throw new Parse.Error(\n          Parse.Error.MISSING_OBJECT_ID,\n          'objectId must not be empty, null or undefined'\n        );\n      }\n    } else {\n      if (data.objectId) {\n        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.');\n      }\n      if (data.id) {\n        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'id is an invalid field name.');\n      }\n    }\n  }\n\n  // When the operation is complete, this.response may have several\n  // fields.\n  // response: the actual data to be returned\n  // status: the http status code. if not present, treated like a 200\n  // location: the location header. if not present, no location header\n  this.response = null;\n\n  // Processing this operation may mutate our data, so we operate on a\n  // copy\n  this.query = deepcopy(query);\n  this.data = deepcopy(data);\n  // We never change originalData, so we do not need a deep copy\n  this.originalData = originalData;\n\n  // The timestamp we'll use for this whole operation\n  this.updatedAt = Parse._encode(new Date()).iso;\n\n  // Shared SchemaController to be reused to reduce the number of loadSchema() calls per request\n  // Once set the schemaData should be immutable\n  this.validSchemaController = null;\n  this.pendingOps = {\n    operations: null,\n    identifier: null,\n  };\n}\n\n// A convenient method to perform all the steps of processing the\n// write, in order.\n// Returns a promise for a {response, status, location} object.\n// status and location are optional.\nRestWrite.prototype.execute = function () {\n  return Promise.resolve()\n    .then(() => {\n      return this.getUserAndRoleACL();\n    })\n    .then(() => {\n      return this.validateClientClassCreation();\n    })\n    .then(() => {\n      return this.handleInstallation();\n    })\n    .then(() => {\n      return this.handleSession();\n    })\n    .then(() => {\n      return this.validateAuthData();\n    })\n    .then(() => {\n      return this.checkRestrictedFields();\n    })\n    .then(() => {\n      return this.runBeforeSaveTrigger();\n    })\n    .then(() => {\n      return this.ensureUniqueAuthDataId();\n    })\n    .then(() => {\n      return this.deleteEmailResetTokenIfNeeded();\n    })\n    .then(() => {\n      return this.validateSchema();\n    })\n    .then(schemaController => {\n      this.validSchemaController = schemaController;\n      return this.setRequiredFieldsIfNeeded();\n    })\n    .then(() => {\n      return this.transformUser();\n    })\n    .then(() => {\n      return this.expandFilesForExistingObjects();\n    })\n    .then(() => {\n      return this.destroyDuplicatedSessions();\n    })\n    .then(() => {\n      return this.runDatabaseOperation();\n    })\n    .then(() => {\n      return this.createSessionTokenIfNeeded();\n    })\n    .then(() => {\n      return this.handleFollowup();\n    })\n    .then(() => {\n      return this.runAfterSaveTrigger();\n    })\n    .then(() => {\n      return this.cleanUserAuthData();\n    })\n    .then(() => {\n      // Append the authDataResponse if exists\n      if (this.authDataResponse) {\n        if (this.response && this.response.response) {\n          this.response.response.authDataResponse = this.authDataResponse;\n        }\n      }\n      if (this.storage.rejectSignup && this.config.preventSignupWithUnverifiedEmail) {\n        throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.');\n      }\n      return this.response;\n    });\n};\n\n// Uses the Auth object to get the list of roles, adds the user id\nRestWrite.prototype.getUserAndRoleACL = function () {\n  if (this.auth.isMaster || this.auth.isMaintenance) {\n    return Promise.resolve();\n  }\n\n  this.runOptions.acl = ['*'];\n\n  if (this.auth.user) {\n    return this.auth.getUserRoles().then(roles => {\n      this.runOptions.acl = this.runOptions.acl.concat(roles, [this.auth.user.id]);\n      return;\n    });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Validates this operation against the allowClientClassCreation config.\nRestWrite.prototype.validateClientClassCreation = function () {\n  if (\n    this.config.allowClientClassCreation === false &&\n    !this.auth.isMaster &&\n    !this.auth.isMaintenance &&\n    SchemaController.systemClasses.indexOf(this.className) === -1\n  ) {\n    return this.config.database\n      .loadSchema()\n      .then(schemaController => schemaController.hasClass(this.className))\n      .then(hasClass => {\n        if (hasClass !== true) {\n          throw createSanitizedError(\n            Parse.Error.OPERATION_FORBIDDEN,\n            'This user is not allowed to access non-existent class: ' + this.className,\n            this.config\n          );\n        }\n      });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Validates this operation against the schema.\nRestWrite.prototype.validateSchema = function () {\n  return this.config.database.validateObject(\n    this.className,\n    this.data,\n    this.query,\n    this.runOptions,\n    this.auth.isMaintenance\n  );\n};\n\n// Runs any beforeSave triggers against this operation.\n// Any change leads to our data being mutated.\nRestWrite.prototype.runBeforeSaveTrigger = function () {\n  if (this.response || this.runOptions.many) {\n    return;\n  }\n\n  // Avoid doing any setup for triggers if there is no 'beforeSave' trigger for this class.\n  if (\n    !triggers.triggerExists(this.className, triggers.Types.beforeSave, this.config.applicationId)\n  ) {\n    return Promise.resolve();\n  }\n\n  const { originalObject, updatedObject } = this.buildParseObjects();\n  const identifier = updatedObject._getStateIdentifier();\n  const stateController = Parse.CoreManager.getObjectStateController();\n  const [pending] = stateController.getPendingOps(identifier);\n  this.pendingOps = {\n    operations: { ...pending },\n    identifier,\n  };\n\n  return Promise.resolve()\n    .then(() => {\n      // Before calling the trigger, validate the permissions for the save operation\n      let databasePromise = null;\n      if (this.query) {\n        // Validate for updating\n        databasePromise = this.config.database.update(\n          this.className,\n          this.query,\n          this.data,\n          this.runOptions,\n          true,\n          true\n        );\n      } else {\n        // Validate for creating\n        databasePromise = this.config.database.create(\n          this.className,\n          this.data,\n          this.runOptions,\n          true\n        );\n      }\n      // In the case that there is no permission for the operation, it throws an error\n      return databasePromise.then(result => {\n        if (!result || result.length <= 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n      });\n    })\n    .then(() => {\n      return triggers.maybeRunTrigger(\n        triggers.Types.beforeSave,\n        this.auth,\n        updatedObject,\n        originalObject,\n        this.config,\n        this.context\n      );\n    })\n    .then(response => {\n      if (response && response.object) {\n        this.storage.fieldsChangedByTrigger = _.reduce(\n          response.object,\n          (result, value, key) => {\n            if (!_.isEqual(this.data[key], value)) {\n              result.push(key);\n            }\n            return result;\n          },\n          []\n        );\n        this.data = response.object;\n        // We should delete the objectId for an update write\n        if (this.query && this.query.objectId) {\n          delete this.data.objectId;\n        }\n      }\n      try {\n        Utils.checkProhibitedKeywords(this.config, this.data);\n      } catch (error) {\n        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, error);\n      }\n    });\n};\n\nRestWrite.prototype.runBeforeLoginTrigger = async function (userData) {\n  // Avoid doing any setup for triggers if there is no 'beforeLogin' trigger\n  if (\n    !triggers.triggerExists(this.className, triggers.Types.beforeLogin, this.config.applicationId)\n  ) {\n    return;\n  }\n\n  // Cloud code gets a bit of extra data for its objects\n  const extraData = { className: this.className };\n\n  // Expand file objects\n  await this.config.filesController.expandFilesInObject(this.config, userData);\n\n  const user = triggers.inflate(extraData, userData);\n\n  // no need to return a response\n  await triggers.maybeRunTrigger(\n    triggers.Types.beforeLogin,\n    this.auth,\n    user,\n    null,\n    this.config,\n    this.context\n  );\n};\n\nRestWrite.prototype.setRequiredFieldsIfNeeded = function () {\n  if (this.data) {\n    return this.validSchemaController.getAllClasses().then(allClasses => {\n      const schema = allClasses.find(oneClass => oneClass.className === this.className);\n      const setRequiredFieldIfNeeded = (fieldName, setDefault) => {\n        if (\n          this.data[fieldName] === undefined ||\n          this.data[fieldName] === null ||\n          this.data[fieldName] === '' ||\n          (typeof this.data[fieldName] === 'object' && this.data[fieldName].__op === 'Delete')\n        ) {\n          if (\n            setDefault &&\n            schema.fields[fieldName] &&\n            schema.fields[fieldName].defaultValue !== null &&\n            schema.fields[fieldName].defaultValue !== undefined &&\n            (this.data[fieldName] === undefined ||\n              (typeof this.data[fieldName] === 'object' && this.data[fieldName].__op === 'Delete'))\n          ) {\n            this.data[fieldName] = schema.fields[fieldName].defaultValue;\n            this.storage.fieldsChangedByTrigger = this.storage.fieldsChangedByTrigger || [];\n            if (this.storage.fieldsChangedByTrigger.indexOf(fieldName) < 0) {\n              this.storage.fieldsChangedByTrigger.push(fieldName);\n            }\n          } else if (schema.fields[fieldName] && schema.fields[fieldName].required === true) {\n            throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `${fieldName} is required`);\n          }\n        }\n      };\n\n      // add default ACL\n      if (\n        schema?.classLevelPermissions?.ACL &&\n        !this.data.ACL &&\n        JSON.stringify(schema.classLevelPermissions.ACL) !==\n          JSON.stringify({ '*': { read: true, write: true } })\n      ) {\n        const acl = deepcopy(schema.classLevelPermissions.ACL);\n        if (acl.currentUser) {\n          if (this.auth.user?.id) {\n            acl[this.auth.user?.id] = deepcopy(acl.currentUser);\n          }\n          delete acl.currentUser;\n        }\n        this.data.ACL = acl;\n        this.storage.fieldsChangedByTrigger = this.storage.fieldsChangedByTrigger || [];\n        this.storage.fieldsChangedByTrigger.push('ACL');\n      }\n\n      // Add default fields\n      if (!this.query) {\n        // allow customizing createdAt and updatedAt when using maintenance key\n        if (\n          this.auth.isMaintenance &&\n          this.data.createdAt &&\n          this.data.createdAt.__type === 'Date'\n        ) {\n          this.data.createdAt = this.data.createdAt.iso;\n\n          if (this.data.updatedAt && this.data.updatedAt.__type === 'Date') {\n            const createdAt = new Date(this.data.createdAt);\n            const updatedAt = new Date(this.data.updatedAt.iso);\n\n            if (updatedAt < createdAt) {\n              throw new Parse.Error(\n                Parse.Error.VALIDATION_ERROR,\n                'updatedAt cannot occur before createdAt'\n              );\n            }\n\n            this.data.updatedAt = this.data.updatedAt.iso;\n          }\n          // if no updatedAt is provided, set it to createdAt to match default behavior\n          else {\n            this.data.updatedAt = this.data.createdAt;\n          }\n        } else {\n          this.data.updatedAt = this.updatedAt;\n          this.data.createdAt = this.updatedAt;\n        }\n\n        // Only assign new objectId if we are creating new object\n        if (!this.data.objectId) {\n          this.data.objectId = cryptoUtils.newObjectId(this.config.objectIdSize);\n        }\n        if (schema) {\n          Object.keys(schema.fields).forEach(fieldName => {\n            setRequiredFieldIfNeeded(fieldName, true);\n          });\n        }\n      } else if (schema) {\n        this.data.updatedAt = this.updatedAt;\n\n        Object.keys(this.data).forEach(fieldName => {\n          setRequiredFieldIfNeeded(fieldName, false);\n        });\n      }\n    });\n  }\n  return Promise.resolve();\n};\n\n// Transforms auth data for a user object.\n// Does nothing if this isn't a user object.\n// Returns a promise for when we're done if it can't finish this tick.\nRestWrite.prototype.validateAuthData = function () {\n  if (this.className !== '_User') {\n    return;\n  }\n\n  const authData = this.data.authData;\n  const hasUsernameAndPassword =\n    typeof this.data.username === 'string' && typeof this.data.password === 'string';\n\n  if (!this.query && !authData) {\n    if (typeof this.data.username !== 'string' || _.isEmpty(this.data.username)) {\n      throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'bad or missing username');\n    }\n    if (typeof this.data.password !== 'string' || _.isEmpty(this.data.password)) {\n      throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required');\n    }\n  }\n\n  if (\n    (authData && !Object.keys(authData).length) ||\n    !Object.prototype.hasOwnProperty.call(this.data, 'authData')\n  ) {\n    // Nothing to validate here\n    return;\n  } else if (Object.prototype.hasOwnProperty.call(this.data, 'authData') && !this.data.authData) {\n    // Handle saving authData to null\n    throw new Parse.Error(\n      Parse.Error.UNSUPPORTED_SERVICE,\n      'This authentication method is unsupported.'\n    );\n  }\n\n  var providers = Object.keys(authData);\n  if (providers.length > 0) {\n    const canHandleAuthData = providers.some(provider => {\n      const providerAuthData = authData[provider] || {};\n      return !!Object.keys(providerAuthData).length;\n    });\n    if (canHandleAuthData || hasUsernameAndPassword || this.auth.isMaster || this.getUserId()) {\n      return this.handleAuthData(authData);\n    }\n  }\n  throw new Parse.Error(\n    Parse.Error.UNSUPPORTED_SERVICE,\n    'This authentication method is unsupported.'\n  );\n};\n\nRestWrite.prototype.filteredObjectsByACL = function (objects) {\n  if (this.auth.isMaster || this.auth.isMaintenance) {\n    return objects;\n  }\n  return objects.filter(object => {\n    if (!object.ACL) {\n      return true; // legacy users that have no ACL field on them\n    }\n    // Regular users that have been locked out.\n    return object.ACL && Object.keys(object.ACL).length > 0;\n  });\n};\n\nRestWrite.prototype.getUserId = function () {\n  if (this.query && this.query.objectId && this.className === '_User') {\n    return this.query.objectId;\n  } else if (this.auth && this.auth.user && this.auth.user.id) {\n    return this.auth.user.id;\n  }\n};\n\n// Developers are allowed to change authData via before save trigger\n// we need after before save to ensure that the developer\n// is not currently duplicating auth data ID\nRestWrite.prototype.ensureUniqueAuthDataId = async function () {\n  if (this.className !== '_User' || !this.data.authData) {\n    return;\n  }\n\n  const hasAuthDataId = Object.keys(this.data.authData).some(\n    key => this.data.authData[key] && this.data.authData[key].id\n  );\n\n  if (!hasAuthDataId) { return; }\n\n  const r = await Auth.findUsersWithAuthData(this.config, this.data.authData);\n  const results = this.filteredObjectsByACL(r);\n  if (results.length > 1) {\n    throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');\n  }\n  // use data.objectId in case of login time and found user during handle validateAuthData\n  const userId = this.getUserId() || this.data.objectId;\n  if (results.length === 1 && userId !== results[0].objectId) {\n    throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');\n  }\n};\n\nRestWrite.prototype.handleAuthData = async function (authData) {\n  const r = await Auth.findUsersWithAuthData(this.config, authData, true);\n  const results = this.filteredObjectsByACL(r);\n\n  const userId = this.getUserId();\n  const userResult = results[0];\n  const foundUserIsNotCurrentUser = userId && userResult && userId !== userResult.objectId;\n\n  if (results.length > 1 || foundUserIsNotCurrentUser) {\n    // To avoid https://github.com/parse-community/parse-server/security/advisories/GHSA-8w3j-g983-8jh5\n    // Let's run some validation before throwing\n    await Auth.handleAuthDataValidation(authData, this, userResult);\n    throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used');\n  }\n\n  // No user found with provided authData we need to validate\n  if (!results.length) {\n    const { authData: validatedAuthData, authDataResponse } = await Auth.handleAuthDataValidation(\n      authData,\n      this\n    );\n    this.authDataResponse = authDataResponse;\n    // Replace current authData by the new validated one\n    this.data.authData = validatedAuthData;\n    return;\n  }\n\n  // User found with provided authData\n  if (results.length === 1) {\n    this.storage.authProvider = Object.keys(authData).join(',');\n\n    const { hasMutatedAuthData, mutatedAuthData } = Auth.hasMutatedAuthData(\n      authData,\n      userResult.authData\n    );\n\n    const isCurrentUserLoggedOrMaster =\n      (this.auth && this.auth.user && this.auth.user.id === userResult.objectId) ||\n      this.auth.isMaster;\n\n    const isLogin = !userId;\n\n    if (isLogin || isCurrentUserLoggedOrMaster) {\n      // no user making the call\n      // OR the user making the call is the right one\n      // Login with auth data\n      delete results[0].password;\n\n      // need to set the objectId first otherwise location has trailing undefined\n      this.data.objectId = userResult.objectId;\n\n      if (!this.query || !this.query.objectId) {\n        this.response = {\n          response: userResult,\n          location: this.location(),\n        };\n        // Run beforeLogin hook before storing any updates\n        // to authData on the db; changes to userResult\n        // will be ignored.\n        await this.runBeforeLoginTrigger(deepcopy(userResult));\n\n        // If we are in login operation via authData\n        // we need to be sure that the user has provided\n        // required authData\n        Auth.checkIfUserHasProvidedConfiguredProvidersForLogin(\n          { config: this.config, auth: this.auth },\n          authData,\n          userResult.authData,\n          this.config\n        );\n      }\n\n      // Prevent validating if no mutated data detected on update\n      if (!hasMutatedAuthData && isCurrentUserLoggedOrMaster) {\n        return;\n      }\n\n      // Force to validate all provided authData on login\n      // on update only validate mutated ones\n      if (hasMutatedAuthData || !this.config.allowExpiredAuthDataToken) {\n        const res = await Auth.handleAuthDataValidation(\n          isLogin ? authData : mutatedAuthData,\n          this,\n          userResult\n        );\n        this.data.authData = res.authData;\n        this.authDataResponse = res.authDataResponse;\n      }\n\n      // IF we are in login we'll skip the database operation / beforeSave / afterSave etc...\n      // we need to set it up there.\n      // We are supposed to have a response only on LOGIN with authData, so we skip those\n      // If we're not logging in, but just updating the current user, we can safely skip that part\n      if (this.response) {\n        // Assign the new authData in the response\n        Object.keys(mutatedAuthData).forEach(provider => {\n          this.response.response.authData[provider] = mutatedAuthData[provider];\n        });\n\n        // Run the DB update directly, as 'master' only if authData contains some keys\n        // authData could not contains keys after validation if the authAdapter\n        // uses the `doNotSave` option. Just update the authData part\n        // Then we're good for the user, early exit of sorts\n        if (Object.keys(this.data.authData).length) {\n          await this.config.database.update(\n            this.className,\n            { objectId: this.data.objectId },\n            { authData: this.data.authData },\n            {}\n          );\n        }\n      }\n    }\n  }\n};\n\nRestWrite.prototype.checkRestrictedFields = async function () {\n  if (this.className !== '_User') {\n    return;\n  }\n\n  if (!this.auth.isMaintenance && !this.auth.isMaster && 'emailVerified' in this.data) {\n    throw createSanitizedError(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"Clients aren't allowed to manually update email verification.\",\n      this.config\n    );\n  }\n};\n\n// The non-third-party parts of User transformation\nRestWrite.prototype.transformUser = async function () {\n  var promise = Promise.resolve();\n  if (this.className !== '_User') {\n    return promise;\n  }\n\n  // Do not cleanup session if objectId is not set\n  if (this.query && this.objectId()) {\n    // If we're updating a _User object, we need to clear out the cache for that user. Find all their\n    // session tokens, and remove them from the cache.\n    const query = await RestQuery({\n      method: RestQuery.Method.find,\n      config: this.config,\n      auth: Auth.master(this.config),\n      className: '_Session',\n      runBeforeFind: false,\n      restWhere: {\n        user: {\n          __type: 'Pointer',\n          className: '_User',\n          objectId: this.objectId(),\n        },\n      },\n    });\n    promise = query.execute().then(results => {\n      results.results.forEach(session =>\n        this.config.cacheController.user.del(session.sessionToken)\n      );\n    });\n  }\n\n  return promise\n    .then(() => {\n      // Transform the password\n      if (this.data.password === undefined) {\n        // ignore only if undefined. should proceed if empty ('')\n        return Promise.resolve();\n      }\n\n      if (this.query) {\n        this.storage['clearSessions'] = true;\n        // Generate a new session only if the user requested\n        if (!this.auth.isMaster && !this.auth.isMaintenance) {\n          this.storage['generateNewSession'] = true;\n        }\n      }\n\n      return this._validatePasswordPolicy().then(() => {\n        return passwordCrypto.hash(this.data.password).then(hashedPassword => {\n          this.data._hashed_password = hashedPassword;\n          delete this.data.password;\n        });\n      });\n    })\n    .then(() => {\n      return this._validateUserName();\n    })\n    .then(() => {\n      return this._validateEmail();\n    });\n};\n\nRestWrite.prototype._validateUserName = function () {\n  // Check for username uniqueness\n  if (!this.data.username) {\n    if (!this.query) {\n      this.data.username = cryptoUtils.randomString(25);\n      this.responseShouldHaveUsername = true;\n    }\n    return Promise.resolve();\n  }\n  /*\n    Usernames should be unique when compared case insensitively\n\n    Users should be able to make case sensitive usernames and\n    login using the case they entered.  I.e. 'Snoopy' should preclude\n    'snoopy' as a valid username.\n  */\n  return this.config.database\n    .find(\n      this.className,\n      {\n        username: this.data.username,\n        objectId: { $ne: this.objectId() },\n      },\n      { limit: 1, caseInsensitive: true },\n      {},\n      this.validSchemaController\n    )\n    .then(results => {\n      if (results.length > 0) {\n        throw new Parse.Error(\n          Parse.Error.USERNAME_TAKEN,\n          'Account already exists for this username.'\n        );\n      }\n      return;\n    });\n};\n\n/*\n  As with usernames, Parse should not allow case insensitive collisions of email.\n  unlike with usernames (which can have case insensitive collisions in the case of\n  auth adapters), emails should never have a case insensitive collision.\n\n  This behavior can be enforced through a properly configured index see:\n  https://docs.mongodb.com/manual/core/index-case-insensitive/#create-a-case-insensitive-index\n  which could be implemented instead of this code based validation.\n\n  Given that this lookup should be a relatively low use case and that the case sensitive\n  unique index will be used by the db for the query, this is an adequate solution.\n*/\nRestWrite.prototype._validateEmail = function () {\n  if (!this.data.email || this.data.email.__op === 'Delete') {\n    return Promise.resolve();\n  }\n  // Validate basic email address format\n  if (!this.data.email.match(/^.+@.+$/)) {\n    return Promise.reject(\n      new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'Email address format is invalid.')\n    );\n  }\n  // Case insensitive match, see note above function.\n  return this.config.database\n    .find(\n      this.className,\n      {\n        email: this.data.email,\n        objectId: { $ne: this.objectId() },\n      },\n      { limit: 1, caseInsensitive: true },\n      {},\n      this.validSchemaController\n    )\n    .then(results => {\n      if (results.length > 0) {\n        throw new Parse.Error(\n          Parse.Error.EMAIL_TAKEN,\n          'Account already exists for this email address.'\n        );\n      }\n      if (\n        !this.data.authData ||\n        !Object.keys(this.data.authData).length ||\n        (Object.keys(this.data.authData).length === 1 &&\n          Object.keys(this.data.authData)[0] === 'anonymous')\n      ) {\n        // We updated the email, send a new validation\n        const { originalObject, updatedObject } = this.buildParseObjects();\n        const request = {\n          original: originalObject,\n          object: updatedObject,\n          master: this.auth.isMaster,\n          ip: this.config.ip,\n          installationId: this.auth.installationId,\n        };\n        return this.config.userController.setEmailVerifyToken(this.data, request, this.storage);\n      }\n    });\n};\n\nRestWrite.prototype._validatePasswordPolicy = function () {\n  if (!this.config.passwordPolicy) { return Promise.resolve(); }\n  return this._validatePasswordRequirements().then(() => {\n    return this._validatePasswordHistory();\n  });\n};\n\nRestWrite.prototype._validatePasswordRequirements = function () {\n  // check if the password conforms to the defined password policy if configured\n  // If we specified a custom error in our configuration use it.\n  // Example: \"Passwords must include a Capital Letter, Lowercase Letter, and a number.\"\n  //\n  // This is especially useful on the generic \"password reset\" page,\n  // as it allows the programmer to communicate specific requirements instead of:\n  // a. making the user guess whats wrong\n  // b. making a custom password reset page that shows the requirements\n  const policyError = this.config.passwordPolicy.validationError\n    ? this.config.passwordPolicy.validationError\n    : 'Password does not meet the Password Policy requirements.';\n  const containsUsernameError = 'Password cannot contain your username.';\n\n  // check whether the password meets the password strength requirements\n  if (\n    (this.config.passwordPolicy.patternValidator &&\n      !this.config.passwordPolicy.patternValidator(this.data.password)) ||\n    (this.config.passwordPolicy.validatorCallback &&\n      !this.config.passwordPolicy.validatorCallback(this.data.password))\n  ) {\n    return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n  }\n\n  // check whether password contain username\n  if (this.config.passwordPolicy.doNotAllowUsername === true) {\n    if (this.data.username) {\n      // username is not passed during password reset\n      if (this.data.password.indexOf(this.data.username) >= 0)\n      { return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, containsUsernameError)); }\n    } else {\n      // retrieve the User object using objectId during password reset\n      return this.config.database.find('_User', { objectId: this.objectId() }).then(results => {\n        if (results.length != 1) {\n          throw undefined;\n        }\n        if (this.data.password.indexOf(results[0].username) >= 0)\n        { return Promise.reject(\n          new Parse.Error(Parse.Error.VALIDATION_ERROR, containsUsernameError)\n        ); }\n        return Promise.resolve();\n      });\n    }\n  }\n  return Promise.resolve();\n};\n\nRestWrite.prototype._validatePasswordHistory = function () {\n  // check whether password is repeating from specified history\n  if (this.query && this.config.passwordPolicy.maxPasswordHistory) {\n    return this.config.database\n      .find(\n        '_User',\n        { objectId: this.objectId() },\n        { keys: ['_password_history', '_hashed_password'] },\n        Auth.maintenance(this.config)\n      )\n      .then(results => {\n        if (results.length != 1) {\n          throw undefined;\n        }\n        const user = results[0];\n        let oldPasswords = [];\n        if (user._password_history)\n        { oldPasswords = _.take(\n          user._password_history,\n          this.config.passwordPolicy.maxPasswordHistory - 1\n        ); }\n        oldPasswords.push(user.password);\n        const newPassword = this.data.password;\n        // compare the new password hash with all old password hashes\n        const promises = oldPasswords.map(function (hash) {\n          return passwordCrypto.compare(newPassword, hash).then(result => {\n            if (result)\n            // reject if there is a match\n            { return Promise.reject('REPEAT_PASSWORD'); }\n            return Promise.resolve();\n          });\n        });\n        // wait for all comparisons to complete\n        return Promise.all(promises)\n          .then(() => {\n            return Promise.resolve();\n          })\n          .catch(err => {\n            if (err === 'REPEAT_PASSWORD')\n            // a match was found\n            { return Promise.reject(\n              new Parse.Error(\n                Parse.Error.VALIDATION_ERROR,\n                `New password should not be the same as last ${this.config.passwordPolicy.maxPasswordHistory} passwords.`\n              )\n            ); }\n            throw err;\n          });\n      });\n  }\n  return Promise.resolve();\n};\n\nRestWrite.prototype.createSessionTokenIfNeeded = async function () {\n  if (this.className !== '_User') {\n    return;\n  }\n  // Don't generate session for updating user (this.query is set) unless authData exists\n  if (this.query && !this.data.authData) {\n    return;\n  }\n  // Don't generate new sessionToken if linking via sessionToken\n  if (this.auth.user && this.data.authData) {\n    return;\n  }\n  // If sign-up call\n  if (!this.storage.authProvider) {\n    // Create request object for verification functions\n    const { originalObject, updatedObject } = this.buildParseObjects();\n    const request = {\n      original: originalObject,\n      object: updatedObject,\n      master: this.auth.isMaster,\n      ip: this.config.ip,\n      installationId: this.auth.installationId,\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 () => this.config.verifyUserEmails === true || (typeof this.config.verifyUserEmails === 'function' && await Promise.resolve(this.config.verifyUserEmails(request)) === true);\n    const preventLoginWithUnverifiedEmail = async () => this.config.preventLoginWithUnverifiedEmail === true || (typeof this.config.preventLoginWithUnverifiedEmail === 'function' && await Promise.resolve(this.config.preventLoginWithUnverifiedEmail(request)) === true);\n    // If verification is required\n    if (await verifyUserEmails() && await preventLoginWithUnverifiedEmail()) {\n      this.storage.rejectSignup = true;\n      return;\n    }\n  }\n  return this.createSessionToken();\n};\n\nRestWrite.prototype.createSessionToken = async function () {\n  // cloud installationId from Cloud Code,\n  // never create session tokens from there.\n  if (this.auth.installationId && this.auth.installationId === 'cloud') {\n    return;\n  }\n\n  if (this.storage.authProvider == null && this.data.authData) {\n    this.storage.authProvider = Object.keys(this.data.authData).join(',');\n  }\n\n  const { sessionData, createSession } = RestWrite.createSession(this.config, {\n    userId: this.objectId(),\n    createdWith: {\n      action: this.storage.authProvider ? 'login' : 'signup',\n      authProvider: this.storage.authProvider || 'password',\n    },\n    installationId: this.auth.installationId,\n  });\n\n  if (this.response && this.response.response) {\n    this.response.response.sessionToken = sessionData.sessionToken;\n  }\n\n  return createSession();\n};\n\nRestWrite.createSession = function (\n  config,\n  { userId, createdWith, installationId, 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    expiresAt: Parse._encode(expiresAt),\n  };\n\n  if (installationId) {\n    sessionData.installationId = installationId;\n  }\n\n  Object.assign(sessionData, additionalSessionData);\n\n  return {\n    sessionData,\n    createSession: () =>\n      new RestWrite(config, Auth.master(config), '_Session', null, sessionData).execute(),\n  };\n};\n\n// Delete email reset tokens if user is changing password or email.\nRestWrite.prototype.deleteEmailResetTokenIfNeeded = function () {\n  if (this.className !== '_User' || this.query === null) {\n    // null query means create\n    return;\n  }\n\n  if ('password' in this.data || 'email' in this.data) {\n    const addOps = {\n      _perishable_token: { __op: 'Delete' },\n      _perishable_token_expires_at: { __op: 'Delete' },\n    };\n    this.data = Object.assign(this.data, addOps);\n  }\n};\n\nRestWrite.prototype.destroyDuplicatedSessions = function () {\n  // Only for _Session, and at creation time\n  if (this.className != '_Session' || this.query) {\n    return;\n  }\n  // Destroy the sessions in 'Background'\n  const { user, installationId, sessionToken } = this.data;\n  if (!user || !installationId) {\n    return;\n  }\n  if (!user.objectId) {\n    return;\n  }\n  this.config.database.destroy(\n    '_Session',\n    {\n      user,\n      installationId,\n      sessionToken: { $ne: sessionToken },\n    },\n    {},\n    this.validSchemaController\n  );\n};\n\n// Handles any followup logic\nRestWrite.prototype.handleFollowup = function () {\n  if (this.storage && this.storage['clearSessions'] && this.config.revokeSessionOnPasswordReset) {\n    var sessionQuery = {\n      user: {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: this.objectId(),\n      },\n    };\n    delete this.storage['clearSessions'];\n    return this.config.database\n      .destroy('_Session', sessionQuery)\n      .then(this.handleFollowup.bind(this));\n  }\n\n  if (this.storage && this.storage['generateNewSession']) {\n    delete this.storage['generateNewSession'];\n    return this.createSessionToken().then(this.handleFollowup.bind(this));\n  }\n\n  if (this.storage && this.storage['sendVerificationEmail']) {\n    delete this.storage['sendVerificationEmail'];\n    // Fire and forget!\n    this.config.userController.sendVerificationEmail(this.data, { auth: this.auth });\n    return this.handleFollowup.bind(this);\n  }\n};\n\n// Handles the _Session class specialness.\n// Does nothing if this isn't an _Session object.\nRestWrite.prototype.handleSession = function () {\n  if (this.response || this.className !== '_Session') {\n    return;\n  }\n\n  if (!this.auth.user && !this.auth.isMaster && !this.auth.isMaintenance) {\n    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token required.');\n  }\n\n  // TODO: Verify proper error to throw\n  if (this.data.ACL) {\n    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'Cannot set ' + 'ACL on a Session.');\n  }\n\n  if (this.query) {\n    if (this.data.user && !this.auth.isMaster && this.data.user.objectId != this.auth.user.id) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    } else if (this.data.installationId) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    } else if (this.data.sessionToken) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    }\n    if (!this.auth.isMaster) {\n      this.query = {\n        $and: [\n          this.query,\n          {\n            user: {\n              __type: 'Pointer',\n              className: '_User',\n              objectId: this.auth.user.id,\n            },\n          },\n        ],\n      };\n    }\n  }\n\n  if (!this.query && !this.auth.isMaster && !this.auth.isMaintenance) {\n    const additionalSessionData = {};\n    for (var key in this.data) {\n      if (key === 'objectId' || key === 'user') {\n        continue;\n      }\n      additionalSessionData[key] = this.data[key];\n    }\n\n    const { sessionData, createSession } = RestWrite.createSession(this.config, {\n      userId: this.auth.user.id,\n      createdWith: {\n        action: 'create',\n      },\n      additionalSessionData,\n    });\n\n    return createSession().then(results => {\n      if (!results.response) {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Error creating session.');\n      }\n      sessionData['objectId'] = results.response['objectId'];\n      this.response = {\n        status: 201,\n        location: results.location,\n        response: sessionData,\n      };\n    });\n  }\n};\n\n// Handles the _Installation class specialness.\n// Does nothing if this isn't an installation object.\n// If an installation is found, this can mutate this.query and turn a create\n// into an update.\n// Returns a promise for when we're done if it can't finish this tick.\nRestWrite.prototype.handleInstallation = function () {\n  if (this.response || this.className !== '_Installation') {\n    return;\n  }\n\n  if (\n    !this.query &&\n    !this.data.deviceToken &&\n    !this.data.installationId &&\n    !this.auth.installationId\n  ) {\n    throw new Parse.Error(\n      135,\n      'at least one ID field (deviceToken, installationId) ' + 'must be specified in this operation'\n    );\n  }\n\n  // If the device token is 64 characters long, we assume it is for iOS\n  // and lowercase it.\n  if (this.data.deviceToken && this.data.deviceToken.length == 64) {\n    this.data.deviceToken = this.data.deviceToken.toLowerCase();\n  }\n\n  // We lowercase the installationId if present\n  if (this.data.installationId) {\n    this.data.installationId = this.data.installationId.toLowerCase();\n  }\n\n  let installationId = this.data.installationId;\n\n  // If data.installationId is not set and we're not master, we can lookup in auth\n  if (!installationId && !this.auth.isMaster && !this.auth.isMaintenance) {\n    installationId = this.auth.installationId;\n  }\n\n  if (installationId) {\n    installationId = installationId.toLowerCase();\n  }\n\n  // Updating _Installation but not updating anything critical\n  if (this.query && !this.data.deviceToken && !installationId && !this.data.deviceType) {\n    return;\n  }\n\n  var promise = Promise.resolve();\n\n  var idMatch; // Will be a match on either objectId or installationId\n  var objectIdMatch;\n  var installationIdMatch;\n  var deviceTokenMatches = [];\n\n  // Instead of issuing 3 reads, let's do it with one OR.\n  const orQueries = [];\n  if (this.query && this.query.objectId) {\n    orQueries.push({\n      objectId: this.query.objectId,\n    });\n  }\n  if (installationId) {\n    orQueries.push({\n      installationId: installationId,\n    });\n  }\n  if (this.data.deviceToken) {\n    orQueries.push({ deviceToken: this.data.deviceToken });\n  }\n\n  if (orQueries.length == 0) {\n    return;\n  }\n\n  promise = promise\n    .then(() => {\n      return this.config.database.find(\n        '_Installation',\n        {\n          $or: orQueries,\n        },\n        {}\n      );\n    })\n    .then(results => {\n      results.forEach(result => {\n        if (this.query && this.query.objectId && result.objectId == this.query.objectId) {\n          objectIdMatch = result;\n        }\n        if (result.installationId == installationId) {\n          installationIdMatch = result;\n        }\n        if (result.deviceToken == this.data.deviceToken) {\n          deviceTokenMatches.push(result);\n        }\n      });\n\n      // Sanity checks when running a query\n      if (this.query && this.query.objectId) {\n        if (!objectIdMatch) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found for update.');\n        }\n        if (\n          this.data.installationId &&\n          objectIdMatch.installationId &&\n          this.data.installationId !== objectIdMatch.installationId\n        ) {\n          throw new Parse.Error(136, 'installationId may not be changed in this ' + 'operation');\n        }\n        if (\n          this.data.deviceToken &&\n          objectIdMatch.deviceToken &&\n          this.data.deviceToken !== objectIdMatch.deviceToken &&\n          !this.data.installationId &&\n          !objectIdMatch.installationId\n        ) {\n          throw new Parse.Error(136, 'deviceToken may not be changed in this ' + 'operation');\n        }\n        if (\n          this.data.deviceType &&\n          this.data.deviceType &&\n          this.data.deviceType !== objectIdMatch.deviceType\n        ) {\n          throw new Parse.Error(136, 'deviceType may not be changed in this ' + 'operation');\n        }\n      }\n\n      if (this.query && this.query.objectId && objectIdMatch) {\n        idMatch = objectIdMatch;\n      }\n\n      if (installationId && installationIdMatch) {\n        idMatch = installationIdMatch;\n      }\n      // need to specify deviceType only if it's new\n      if (!this.query && !this.data.deviceType && !idMatch) {\n        throw new Parse.Error(135, 'deviceType must be specified in this operation');\n      }\n    })\n    .then(() => {\n      if (!idMatch) {\n        if (!deviceTokenMatches.length) {\n          return;\n        } else if (\n          deviceTokenMatches.length == 1 &&\n          (!deviceTokenMatches[0]['installationId'] || !installationId)\n        ) {\n          // Single match on device token but none on installationId, and either\n          // the passed object or the match is missing an installationId, so we\n          // can just return the match.\n          return deviceTokenMatches[0]['objectId'];\n        } else if (!this.data.installationId) {\n          throw new Parse.Error(\n            132,\n            'Must specify installationId when deviceToken ' +\n              'matches multiple Installation objects'\n          );\n        } else {\n          // Multiple device token matches and we specified an installation ID,\n          // or a single match where both the passed and matching objects have\n          // an installation ID. Try cleaning out old installations that match\n          // the deviceToken, and return nil to signal that a new object should\n          // be created.\n          var delQuery = {\n            deviceToken: this.data.deviceToken,\n            installationId: {\n              $ne: installationId,\n            },\n          };\n          if (this.data.appIdentifier) {\n            delQuery['appIdentifier'] = this.data.appIdentifier;\n          }\n          this.config.database.destroy('_Installation', delQuery).catch(err => {\n            if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n              // no deletions were made. Can be ignored.\n              return;\n            }\n            // rethrow the error\n            throw err;\n          });\n          return;\n        }\n      } else {\n        if (deviceTokenMatches.length == 1 && !deviceTokenMatches[0]['installationId']) {\n          // Exactly one device token match and it doesn't have an installation\n          // ID. This is the one case where we want to merge with the existing\n          // object.\n          const delQuery = { objectId: idMatch.objectId };\n          return this.config.database\n            .destroy('_Installation', delQuery)\n            .then(() => {\n              return deviceTokenMatches[0]['objectId'];\n            })\n            .catch(err => {\n              if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n                // no deletions were made. Can be ignored\n                return;\n              }\n              // rethrow the error\n              throw err;\n            });\n        } else {\n          if (this.data.deviceToken && idMatch.deviceToken != this.data.deviceToken) {\n            // We're setting the device token on an existing installation, so\n            // we should try cleaning out old installations that match this\n            // device token.\n            const delQuery = {\n              deviceToken: this.data.deviceToken,\n            };\n            // We have a unique install Id, use that to preserve\n            // the interesting installation\n            if (this.data.installationId) {\n              delQuery['installationId'] = {\n                $ne: this.data.installationId,\n              };\n            } else if (\n              idMatch.objectId &&\n              this.data.objectId &&\n              idMatch.objectId == this.data.objectId\n            ) {\n              // we passed an objectId, preserve that instalation\n              delQuery['objectId'] = {\n                $ne: idMatch.objectId,\n              };\n            } else {\n              // What to do here? can't really clean up everything...\n              return idMatch.objectId;\n            }\n            if (this.data.appIdentifier) {\n              delQuery['appIdentifier'] = this.data.appIdentifier;\n            }\n            this.config.database.destroy('_Installation', delQuery).catch(err => {\n              if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n                // no deletions were made. Can be ignored.\n                return;\n              }\n              // rethrow the error\n              throw err;\n            });\n          }\n          // In non-merge scenarios, just return the installation match id\n          return idMatch.objectId;\n        }\n      }\n    })\n    .then(objId => {\n      if (objId) {\n        this.query = { objectId: objId };\n        delete this.data.objectId;\n        delete this.data.createdAt;\n      }\n      // TODO: Validate ops (add/remove on channels, $inc on badge, etc.)\n    });\n  return promise;\n};\n\n// If we short-circuited the object response - then we need to make sure we expand all the files,\n// since this might not have a query, meaning it won't return the full result back.\n// TODO: (nlutsenko) This should die when we move to per-class based controllers on _Session/_User\nRestWrite.prototype.expandFilesForExistingObjects = async function () {\n  // Check whether we have a short-circuited response - only then run expansion.\n  if (this.response && this.response.response) {\n    await this.config.filesController.expandFilesInObject(this.config, this.response.response);\n  }\n};\n\nRestWrite.prototype.runDatabaseOperation = function () {\n  if (this.response) {\n    return;\n  }\n\n  if (this.className === '_Role') {\n    this.config.cacheController.role.clear();\n    if (this.config.liveQueryController) {\n      this.config.liveQueryController.clearCachedRoles(this.auth.user);\n    }\n  }\n\n  if (this.className === '_User' && this.query && this.auth.isUnauthenticated()) {\n    throw createSanitizedError(\n      Parse.Error.SESSION_MISSING,\n      `Cannot modify user ${this.query.objectId}.`,\n      this.config\n    );\n  }\n\n  if (this.className === '_Product' && this.data.download) {\n    this.data.downloadName = this.data.download.name;\n  }\n\n  // TODO: Add better detection for ACL, ensuring a user can't be locked from\n  //       their own user record.\n  if (this.data.ACL && this.data.ACL['*unresolved']) {\n    throw new Parse.Error(Parse.Error.INVALID_ACL, 'Invalid ACL.');\n  }\n\n  if (this.query) {\n    // Force the user to not lockout\n    // Matched with parse.com\n    if (\n      this.className === '_User' &&\n      this.data.ACL &&\n      this.auth.isMaster !== true &&\n      this.auth.isMaintenance !== true\n    ) {\n      this.data.ACL[this.query.objectId] = { read: true, write: true };\n    }\n    // update password timestamp if user password is being changed\n    if (\n      this.className === '_User' &&\n      this.data._hashed_password &&\n      this.config.passwordPolicy &&\n      this.config.passwordPolicy.maxPasswordAge\n    ) {\n      this.data._password_changed_at = Parse._encode(new Date());\n    }\n    // Ignore createdAt when update\n    delete this.data.createdAt;\n\n    let defer = Promise.resolve();\n    // if password history is enabled then save the current password to history\n    if (\n      this.className === '_User' &&\n      this.data._hashed_password &&\n      this.config.passwordPolicy &&\n      this.config.passwordPolicy.maxPasswordHistory\n    ) {\n      defer = this.config.database\n        .find(\n          '_User',\n          { objectId: this.objectId() },\n          { keys: ['_password_history', '_hashed_password'] },\n          Auth.maintenance(this.config)\n        )\n        .then(results => {\n          if (results.length != 1) {\n            throw undefined;\n          }\n          const user = results[0];\n          let oldPasswords = [];\n          if (user._password_history) {\n            oldPasswords = _.take(\n              user._password_history,\n              this.config.passwordPolicy.maxPasswordHistory\n            );\n          }\n          //n-1 passwords go into history including last password\n          while (\n            oldPasswords.length > Math.max(0, this.config.passwordPolicy.maxPasswordHistory - 2)\n          ) {\n            oldPasswords.shift();\n          }\n          oldPasswords.push(user.password);\n          this.data._password_history = oldPasswords;\n        });\n    }\n\n    return defer.then(() => {\n      // Run an update\n      return this.config.database\n        .update(\n          this.className,\n          this.query,\n          this.data,\n          this.runOptions,\n          false,\n          false,\n          this.validSchemaController\n        )\n        .then(response => {\n          response.updatedAt = this.updatedAt;\n          this._updateResponseWithData(response, this.data);\n          this.response = { response };\n        });\n    });\n  } else {\n    // Set the default ACL and password timestamp for the new _User\n    if (this.className === '_User') {\n      var ACL = this.data.ACL;\n      // default public r/w ACL\n      if (!ACL) {\n        ACL = {};\n        if (!this.config.enforcePrivateUsers) {\n          ACL['*'] = { read: true, write: false };\n        }\n      }\n      // make sure the user is not locked down\n      ACL[this.data.objectId] = { read: true, write: true };\n      this.data.ACL = ACL;\n      // password timestamp to be used when password expiry policy is enforced\n      if (this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {\n        this.data._password_changed_at = Parse._encode(new Date());\n      }\n    }\n\n    // Run a create\n    return this.config.database\n      .create(this.className, this.data, this.runOptions, false, this.validSchemaController)\n      .catch(error => {\n        if (this.className !== '_User' || error.code !== Parse.Error.DUPLICATE_VALUE) {\n          throw error;\n        }\n\n        // Quick check, if we were able to infer the duplicated field name\n        if (error && error.userInfo && error.userInfo.duplicated_field === 'username') {\n          throw new Parse.Error(\n            Parse.Error.USERNAME_TAKEN,\n            'Account already exists for this username.'\n          );\n        }\n\n        if (error && error.userInfo && error.userInfo.duplicated_field === 'email') {\n          throw new Parse.Error(\n            Parse.Error.EMAIL_TAKEN,\n            'Account already exists for this email address.'\n          );\n        }\n\n        // If this was a failed user creation due to username or email already taken, we need to\n        // check whether it was username or email and return the appropriate error.\n        // Fallback to the original method\n        // TODO: See if we can later do this without additional queries by using named indexes.\n        return this.config.database\n          .find(\n            this.className,\n            {\n              username: this.data.username,\n              objectId: { $ne: this.objectId() },\n            },\n            { limit: 1 }\n          )\n          .then(results => {\n            if (results.length > 0) {\n              throw new Parse.Error(\n                Parse.Error.USERNAME_TAKEN,\n                'Account already exists for this username.'\n              );\n            }\n            return this.config.database.find(\n              this.className,\n              { email: this.data.email, objectId: { $ne: this.objectId() } },\n              { limit: 1 }\n            );\n          })\n          .then(results => {\n            if (results.length > 0) {\n              throw new Parse.Error(\n                Parse.Error.EMAIL_TAKEN,\n                'Account already exists for this email address.'\n              );\n            }\n            throw new Parse.Error(\n              Parse.Error.DUPLICATE_VALUE,\n              'A duplicate value for a field with unique values was provided'\n            );\n          });\n      })\n      .then(response => {\n        response.objectId = this.data.objectId;\n        response.createdAt = this.data.createdAt;\n\n        if (this.responseShouldHaveUsername) {\n          response.username = this.data.username;\n        }\n        this._updateResponseWithData(response, this.data);\n        this.response = {\n          status: 201,\n          response,\n          location: this.location(),\n        };\n      });\n  }\n};\n\n// Returns nothing - doesn't wait for the trigger.\nRestWrite.prototype.runAfterSaveTrigger = function () {\n  if (!this.response || !this.response.response || this.runOptions.many) {\n    return;\n  }\n\n  // Avoid doing any setup for triggers if there is no 'afterSave' trigger for this class.\n  const hasAfterSaveHook = triggers.triggerExists(\n    this.className,\n    triggers.Types.afterSave,\n    this.config.applicationId\n  );\n  const hasLiveQuery = this.config.liveQueryController.hasLiveQuery(this.className);\n  if (!hasAfterSaveHook && !hasLiveQuery) {\n    return Promise.resolve();\n  }\n\n  const { originalObject, updatedObject } = this.buildParseObjects();\n  updatedObject._handleSaveResponse(this.response.response, this.response.status || 200);\n\n  if (hasLiveQuery) {\n    this.config.database.loadSchema().then(schemaController => {\n      // Notify LiveQueryServer if possible\n      const perms = schemaController.getClassLevelPermissions(updatedObject.className);\n      this.config.liveQueryController.onAfterSave(\n        updatedObject.className,\n        updatedObject,\n        originalObject,\n        perms\n      );\n    });\n  }\n  if (!hasAfterSaveHook) {\n    return Promise.resolve();\n  }\n  // Run afterSave trigger\n  return triggers\n    .maybeRunTrigger(\n      triggers.Types.afterSave,\n      this.auth,\n      updatedObject,\n      originalObject,\n      this.config,\n      this.context\n    )\n    .then(result => {\n      const jsonReturned = result && !result._toFullJSON;\n      if (jsonReturned) {\n        this.pendingOps.operations = {};\n        this.response.response = result;\n      } else {\n        this.response.response = this._updateResponseWithData(\n          (result || updatedObject).toJSON(),\n          this.data\n        );\n      }\n    })\n    .catch(function (err) {\n      logger.warn('afterSave caught an error', err);\n    });\n};\n\n// A helper to figure out what location this operation happens at.\nRestWrite.prototype.location = function () {\n  var middle = this.className === '_User' ? '/users/' : '/classes/' + this.className + '/';\n  const mount = this.config.mount || this.config.serverURL;\n  return mount + middle + this.data.objectId;\n};\n\n// A helper to get the object id for this operation.\n// Because it could be either on the query or on the data\nRestWrite.prototype.objectId = function () {\n  return this.data.objectId || this.query.objectId;\n};\n\n// Returns a copy of the data and delete bad keys (_auth_data, _hashed_password...)\nRestWrite.prototype.sanitizedData = function () {\n  const data = Object.keys(this.data).reduce((data, key) => {\n    // Regexp comes from Parse.Object.prototype.validate\n    if (!/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) {\n      delete data[key];\n    }\n    return data;\n  }, deepcopy(this.data));\n  return Parse._decode(undefined, data);\n};\n\n// Returns an updated copy of the object\nRestWrite.prototype.buildParseObjects = function () {\n  const extraData = { className: this.className, objectId: this.query?.objectId };\n  let originalObject;\n  if (this.query && this.query.objectId) {\n    originalObject = triggers.inflate(extraData, this.originalData);\n  }\n\n  const className = Parse.Object.fromJSON(extraData);\n  const readOnlyAttributes = className.constructor.readOnlyAttributes\n    ? className.constructor.readOnlyAttributes()\n    : [];\n\n  // For _Role class, 'name' cannot be set after the role has an objectId.\n  // In afterSave context, _handleSaveResponse has already set the objectId,\n  // so we treat 'name' as read-only to avoid Parse SDK validation errors.\n  const isRoleAfterSave = this.className === '_Role' && this.response && !this.query;\n  if (isRoleAfterSave && this.data.name && !readOnlyAttributes.includes('name')) {\n    readOnlyAttributes.push('name');\n  }\n  if (!this.originalData) {\n    for (const attribute of readOnlyAttributes) {\n      extraData[attribute] = this.data[attribute];\n    }\n  }\n  const updatedObject = triggers.inflate(extraData, this.originalData);\n  Object.keys(this.data).reduce(function (data, key) {\n    if (key.indexOf('.') > 0) {\n      if (typeof data[key].__op === 'string') {\n        if (!readOnlyAttributes.includes(key)) {\n          updatedObject.set(key, data[key]);\n        }\n      } else {\n        // subdocument key with dot notation { 'x.y': v } => { 'x': { 'y' : v } })\n        const splittedKey = key.split('.');\n        const parentProp = splittedKey[0];\n        let parentVal = updatedObject.get(parentProp);\n        if (typeof parentVal !== 'object') {\n          parentVal = {};\n        }\n        parentVal[splittedKey[1]] = data[key];\n        updatedObject.set(parentProp, parentVal);\n      }\n      delete data[key];\n    }\n    return data;\n  }, deepcopy(this.data));\n\n  const sanitized = this.sanitizedData();\n  for (const attribute of readOnlyAttributes) {\n    delete sanitized[attribute];\n  }\n  updatedObject.set(sanitized);\n  return { updatedObject, originalObject };\n};\n\nRestWrite.prototype.cleanUserAuthData = function () {\n  if (this.response && this.response.response && this.className === '_User') {\n    const user = this.response.response;\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\nRestWrite.prototype._updateResponseWithData = function (response, data) {\n  const stateController = Parse.CoreManager.getObjectStateController();\n  const [pending] = stateController.getPendingOps(this.pendingOps.identifier);\n  for (const key in this.pendingOps.operations) {\n    if (!pending[key]) {\n      data[key] = this.originalData ? this.originalData[key] : { __op: 'Delete' };\n      this.storage.fieldsChangedByTrigger.push(key);\n    }\n  }\n  const skipKeys = [...(requiredColumns.read[this.className] || [])];\n  if (!this.query) {\n    skipKeys.push('objectId', 'createdAt');\n  } else {\n    skipKeys.push('updatedAt');\n    delete response.objectId;\n  }\n  for (const key in response) {\n    if (skipKeys.includes(key)) {\n      continue;\n    }\n    const value = response[key];\n    if (\n      value == null ||\n      (value.__type && value.__type === 'Pointer') ||\n      util.isDeepStrictEqual(data[key], value) ||\n      util.isDeepStrictEqual((this.originalData || {})[key], value)\n    ) {\n      delete response[key];\n    }\n  }\n  if (_.isEmpty(this.storage.fieldsChangedByTrigger)) {\n    return response;\n  }\n  const clientSupportsDelete = ClientSDK.supportsForwardDelete(this.clientSDK);\n  this.storage.fieldsChangedByTrigger.forEach(fieldName => {\n    const dataValue = data[fieldName];\n\n    if (!Object.prototype.hasOwnProperty.call(response, fieldName)) {\n      response[fieldName] = dataValue;\n    }\n\n    // Strips operations from responses\n    if (response[fieldName] && response[fieldName].__op) {\n      delete response[fieldName];\n      if (clientSupportsDelete && dataValue.__op == 'Delete') {\n        response[fieldName] = dataValue;\n      }\n    }\n  });\n  return response;\n};\n\nexport default RestWrite;\nmodule.exports = RestWrite;\n"],"mappings":"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","ignoreList":[]}