@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Controllers/DatabaseController.js

@@ -0,0 +1,1685 @@
+"use strict";
+
+var _node = require("parse/node");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _intersect = _interopRequireDefault(require("intersect"));
+var _logger = _interopRequireDefault(require("../logger"));
+var _Utils = _interopRequireDefault(require("../Utils"));
+var SchemaController = _interopRequireWildcard(require("./SchemaController"));
+var _StorageAdapter = require("../Adapters/Storage/StorageAdapter");
+var _MongoStorageAdapter = _interopRequireDefault(require("../Adapters/Storage/Mongo/MongoStorageAdapter"));
+var _PostgresStorageAdapter = _interopRequireDefault(require("../Adapters/Storage/Postgres/PostgresStorageAdapter"));
+var _SchemaCache = _interopRequireDefault(require("../Adapters/Cache/SchemaCache"));
+var _Error = require("../Error");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// A database adapter that works with data exported from the hosted
+// Parse database.
+// -disable-next
+// -disable-next
+// -disable-next
+// Query operators that always pass validation regardless of auth level.
+const queryOperators = ['$and', '$or', '$nor'];
+
+// Registry of internal fields with access permissions.
+// Internal fields are never directly writable by clients, so clientWrite is omitted.
+// - clientRead: any client can use this field in queries
+// - masterRead: master key can use this field in queries
+// - masterWrite: master key can use this field in updates
+const internalFields = {
+  _rperm: {
+    clientRead: true,
+    masterRead: true,
+    masterWrite: true
+  },
+  _wperm: {
+    clientRead: true,
+    masterRead: true,
+    masterWrite: true
+  },
+  _hashed_password: {
+    clientRead: false,
+    masterRead: false,
+    masterWrite: true
+  },
+  _email_verify_token: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _perishable_token: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _perishable_token_expires_at: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _email_verify_token_expires_at: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _failed_login_count: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _account_lockout_expires_at: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _password_changed_at: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _password_history: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: true
+  },
+  _tombstone: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: false
+  },
+  _session_token: {
+    clientRead: false,
+    masterRead: true,
+    masterWrite: false
+  }
+  /////////////////////////////////////////////////////////////////////////////////////////////
+  // The following fields are not accessed by their _-prefixed name through the API;
+  // they are mapped to REST-level names in the adapter layer or handled through
+  // separate code paths.
+  /////////////////////////////////////////////////////////////////////////////////////////////
+  // System fields (mapped to REST-level names):
+  // _id (objectId)
+  // _created_at (createdAt)
+  // _updated_at (updatedAt)
+  // _last_used (lastUsed)
+  // _expiresAt (expiresAt)
+  /////////////////////////////////////////////////////////////////////////////////////////////
+  // Legacy ACL format: mapped to/from _rperm/_wperm
+  // _acl
+  /////////////////////////////////////////////////////////////////////////////////////////////
+  // Schema metadata: not data fields, used only for schema configuration
+  // _metadata
+  // _client_permissions
+  /////////////////////////////////////////////////////////////////////////////////////////////
+  // Dynamic auth data fields: used only in projections and updates, not in queries
+  // _auth_data_<provider>
+};
+
+// Derived access lists
+const specialQueryKeys = [...queryOperators, ...Object.keys(internalFields).filter(k => internalFields[k].clientRead)];
+const specialMasterQueryKeys = [...queryOperators, ...Object.keys(internalFields).filter(k => internalFields[k].masterRead)];
+function addWriteACL(query, acl) {
+  const newQuery = _lodash.default.cloneDeep(query);
+  //Can't be any existing '_wperm' query, we don't allow client queries on that, no need to $and
+  newQuery._wperm = {
+    $in: [null, ...acl]
+  };
+  return newQuery;
+}
+function addReadACL(query, acl) {
+  const newQuery = _lodash.default.cloneDeep(query);
+  //Can't be any existing '_rperm' query, we don't allow client queries on that, no need to $and
+  newQuery._rperm = {
+    $in: [null, '*', ...acl]
+  };
+  return newQuery;
+}
+
+// Transforms a REST API formatted ACL object to our two-field mongo format.
+const transformObjectACL = ({
+  ACL,
+  ...result
+}) => {
+  if (!ACL) {
+    return result;
+  }
+  result._wperm = [];
+  result._rperm = [];
+  for (const entry in ACL) {
+    if (ACL[entry].read) {
+      result._rperm.push(entry);
+    }
+    if (ACL[entry].write) {
+      result._wperm.push(entry);
+    }
+  }
+  return result;
+};
+const validateQuery = (query, isMaster, isMaintenance, update, options, _depth = 0) => {
+  if (isMaintenance) {
+    isMaster = true;
+  }
+  const rc = options?.requestComplexity;
+  if (!isMaster && rc && rc.queryDepth !== -1 && _depth > rc.queryDepth) {
+    throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, `Query condition nesting depth exceeds maximum allowed depth of ${rc.queryDepth}`);
+  }
+  if (query.ACL) {
+    throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Cannot query on ACL.');
+  }
+  if (query.$or) {
+    if (Array.isArray(query.$or)) {
+      query.$or.forEach(value => validateQuery(value, isMaster, isMaintenance, update, options, _depth + 1));
+    } else {
+      throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Bad $or format - use an array value.');
+    }
+  }
+  if (query.$and) {
+    if (Array.isArray(query.$and)) {
+      query.$and.forEach(value => validateQuery(value, isMaster, isMaintenance, update, options, _depth + 1));
+    } else {
+      throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Bad $and format - use an array value.');
+    }
+  }
+  if (query.$nor) {
+    if (Array.isArray(query.$nor) && query.$nor.length > 0) {
+      query.$nor.forEach(value => validateQuery(value, isMaster, isMaintenance, update, options, _depth + 1));
+    } else {
+      throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Bad $nor format - use an array of at least 1 value.');
+    }
+  }
+  Object.keys(query).forEach(key => {
+    if (query && query[key] && query[key].$regex !== undefined) {
+      if (!isMaster && rc && rc.allowRegex === false) {
+        throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, '$regex operator is not allowed');
+      }
+      if (typeof query[key].$regex !== 'string') {
+        throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, '$regex value must be a string');
+      }
+      if (query[key].$options !== undefined && typeof query[key].$options !== 'string') {
+        throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, '$options value must be a string');
+      }
+      if (typeof query[key].$options === 'string') {
+        if (!query[key].$options.match(/^[imxsu]+$/)) {
+          throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, `Bad $options value for query: ${query[key].$options}`);
+        }
+      }
+    }
+    if (!key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/) && !specialQueryKeys.includes(key) && !(isMaster && specialMasterQueryKeys.includes(key))) {
+      throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid key name: ${key}`);
+    }
+  });
+};
+
+// Filters out any data that shouldn't be on this REST-formatted object.
+const filterSensitiveData = (isMaster, isMaintenance, aclGroup, auth, operation, schema, className, protectedFields, object, protectedFieldsOwnerExempt) => {
+  let userId = null;
+  if (auth && auth.user) {
+    userId = auth.user.id;
+  }
+
+  // replace protectedFields when using pointer-permissions
+  const perms = schema && schema.getClassLevelPermissions ? schema.getClassLevelPermissions(className) : {};
+  if (perms) {
+    const isReadOperation = ['get', 'find'].indexOf(operation) > -1;
+    if (isReadOperation && perms.protectedFields) {
+      // extract protectedFields added with the pointer-permission prefix
+      const protectedFieldsPointerPerm = Object.keys(perms.protectedFields).filter(key => key.startsWith('userField:')).map(key => {
+        return {
+          key: key.substring(10),
+          value: perms.protectedFields[key]
+        };
+      });
+      const newProtectedFields = [];
+      let overrideProtectedFields = false;
+
+      // check if the object grants the current user access based on the extracted fields
+      protectedFieldsPointerPerm.forEach(pointerPerm => {
+        let pointerPermIncludesUser = false;
+        const readUserFieldValue = object[pointerPerm.key];
+        if (readUserFieldValue) {
+          if (Array.isArray(readUserFieldValue)) {
+            pointerPermIncludesUser = readUserFieldValue.some(user => user.objectId && user.objectId === userId);
+          } else {
+            pointerPermIncludesUser = readUserFieldValue.objectId && readUserFieldValue.objectId === userId;
+          }
+        }
+        if (pointerPermIncludesUser) {
+          overrideProtectedFields = true;
+          newProtectedFields.push(pointerPerm.value);
+        }
+      });
+
+      // if at least one pointer-permission affected the current user
+      // intersect vs protectedFields from previous stage (@see addProtectedFields)
+      // Sets theory (intersections): A x (B x C) == (A x B) x C
+      if (overrideProtectedFields && protectedFields) {
+        newProtectedFields.push(protectedFields);
+      }
+      // intersect all sets of protectedFields
+      newProtectedFields.forEach(fields => {
+        if (fields) {
+          // if there're no protctedFields by other criteria ( id / role / auth)
+          // then we must intersect each set (per userField)
+          if (!protectedFields) {
+            protectedFields = fields;
+          } else {
+            protectedFields = protectedFields.filter(v => fields.includes(v));
+          }
+        }
+      });
+    }
+  }
+  const isUserClass = className === '_User';
+  if (isUserClass) {
+    object.password = object._hashed_password;
+    delete object._hashed_password;
+    delete object.sessionToken;
+  }
+  if (isMaintenance) {
+    return object;
+  }
+
+  /* special treat for the user class: don't filter protectedFields if currently loggedin user is
+  the retrieved user, unless protectedFieldsOwnerExempt is false */
+  const isOwnerExempt = protectedFieldsOwnerExempt !== false && isUserClass && userId && object.objectId === userId;
+  if (!isOwnerExempt) {
+    protectedFields && protectedFields.forEach(k => delete object[k]);
+
+    // fields not requested by client (excluded),
+    // but were needed to apply protectedFields
+    perms?.protectedFields?.temporaryKeys?.forEach(k => delete object[k]);
+  }
+  for (const key in object) {
+    if (key.charAt(0) === '_') {
+      delete object[key];
+    }
+  }
+  if (!isUserClass || isMaster) {
+    return object;
+  }
+  if (aclGroup.indexOf(object.objectId) > -1) {
+    return object;
+  }
+  delete object.authData;
+  return object;
+};
+
+// Runs an update on the database.
+// Returns a promise for an object with the new values for field
+// modifications that don't know their results ahead of time, like
+// 'increment'.
+// Options:
+//   acl:  a list of strings. If the object to be updated has an ACL,
+//         one of the provided strings must provide the caller with
+//         write permissions.
+const specialKeysForUpdate = Object.keys(internalFields).filter(k => internalFields[k].masterWrite);
+const isSpecialUpdateKey = key => {
+  return specialKeysForUpdate.indexOf(key) >= 0;
+};
+function joinTableName(className, key) {
+  return `_Join:${key}:${className}`;
+}
+const flattenUpdateOperatorsForCreate = object => {
+  for (const key in object) {
+    if (object[key] && object[key].__op) {
+      switch (object[key].__op) {
+        case 'Increment':
+          if (typeof object[key].amount !== 'number') {
+            throw new _node.Parse.Error(_node.Parse.Error.INVALID_JSON, 'objects to add must be an array');
+          }
+          object[key] = object[key].amount;
+          break;
+        case 'SetOnInsert':
+          object[key] = object[key].amount;
+          break;
+        case 'Add':
+          if (!Array.isArray(object[key].objects)) {
+            throw new _node.Parse.Error(_node.Parse.Error.INVALID_JSON, 'objects to add must be an array');
+          }
+          object[key] = object[key].objects;
+          break;
+        case 'AddUnique':
+          if (!Array.isArray(object[key].objects)) {
+            throw new _node.Parse.Error(_node.Parse.Error.INVALID_JSON, 'objects to add must be an array');
+          }
+          object[key] = object[key].objects;
+          break;
+        case 'Remove':
+          if (!Array.isArray(object[key].objects)) {
+            throw new _node.Parse.Error(_node.Parse.Error.INVALID_JSON, 'objects to add must be an array');
+          }
+          object[key] = [];
+          break;
+        case 'Delete':
+          delete object[key];
+          break;
+        default:
+          throw new _node.Parse.Error(_node.Parse.Error.COMMAND_UNAVAILABLE, `The ${object[key].__op} operator is not supported yet.`);
+      }
+    }
+  }
+};
+const transformAuthData = (className, object, schema) => {
+  if (object.authData && className === '_User') {
+    Object.keys(object.authData).forEach(provider => {
+      const providerData = object.authData[provider];
+      const fieldName = `_auth_data_${provider}`;
+      if (providerData == null) {
+        object[fieldName] = {
+          __op: 'Delete'
+        };
+      } else {
+        object[fieldName] = providerData;
+        schema.fields[fieldName] = {
+          type: 'Object'
+        };
+      }
+    });
+    delete object.authData;
+  }
+};
+// Transforms a Database format ACL to a REST API format ACL
+const untransformObjectACL = ({
+  _rperm,
+  _wperm,
+  ...output
+}) => {
+  if (_rperm || _wperm) {
+    output.ACL = {};
+    (_rperm || []).forEach(entry => {
+      if (!output.ACL[entry]) {
+        output.ACL[entry] = {
+          read: true
+        };
+      } else {
+        output.ACL[entry]['read'] = true;
+      }
+    });
+    (_wperm || []).forEach(entry => {
+      if (!output.ACL[entry]) {
+        output.ACL[entry] = {
+          write: true
+        };
+      } else {
+        output.ACL[entry]['write'] = true;
+      }
+    });
+  }
+  return output;
+};
+
+/**
+ * When querying, the fieldName may be compound, extract the root fieldName
+ *     `temperature.celsius` becomes `temperature`
+ * @param {string} fieldName that may be a compound field name
+ * @returns {string} the root name of the field
+ */
+const getRootFieldName = fieldName => {
+  return fieldName.split('.')[0];
+};
+const relationSchema = {
+  fields: {
+    relatedId: {
+      type: 'String'
+    },
+    owningId: {
+      type: 'String'
+    }
+  }
+};
+const convertEmailToLowercase = (object, className, options) => {
+  if (className === '_User' && options.convertEmailToLowercase) {
+    if (typeof object['email'] === 'string') {
+      object['email'] = object['email'].toLowerCase();
+    }
+  }
+};
+const convertUsernameToLowercase = (object, className, options) => {
+  if (className === '_User' && options.convertUsernameToLowercase) {
+    if (typeof object['username'] === 'string') {
+      object['username'] = object['username'].toLowerCase();
+    }
+  }
+};
+class DatabaseController {
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.options = options || {};
+    this.idempotencyOptions = this.options.idempotencyOptions || {};
+    // Prevent mutable this.schema, otherwise one request could use
+    // multiple schemas, so instead use loadSchema to get a schema.
+    this.schemaPromise = null;
+    this._transactionalSession = null;
+    this.options = options;
+  }
+  collectionExists(className) {
+    return this.adapter.classExists(className);
+  }
+  purgeCollection(className) {
+    return this.loadSchema().then(schemaController => schemaController.getOneSchema(className)).then(schema => this.adapter.deleteObjectsByQuery(className, schema, {}));
+  }
+  validateClassName(className) {
+    if (!SchemaController.classNameIsValid(className)) {
+      return Promise.reject(new _node.Parse.Error(_node.Parse.Error.INVALID_CLASS_NAME, 'invalid className: ' + className));
+    }
+    return Promise.resolve();
+  }
+
+  // Returns a promise for a schemaController.
+  loadSchema(options = {
+    clearCache: false
+  }) {
+    if (this.schemaPromise != null) {
+      return this.schemaPromise;
+    }
+    this.schemaPromise = SchemaController.load(this.adapter, options);
+    this.schemaPromise.then(() => delete this.schemaPromise, () => delete this.schemaPromise);
+    return this.loadSchema(options);
+  }
+  loadSchemaIfNeeded(schemaController, options = {
+    clearCache: false
+  }) {
+    return schemaController ? Promise.resolve(schemaController) : this.loadSchema(options);
+  }
+
+  // Returns a promise for the classname that is related to the given
+  // classname through the key.
+  // TODO: make this not in the DatabaseController interface
+  redirectClassNameForKey(className, key) {
+    return this.loadSchema().then(schema => {
+      var t = schema.getExpectedType(className, key);
+      if (t != null && typeof t !== 'string' && t.type === 'Relation') {
+        return t.targetClass;
+      }
+      return className;
+    });
+  }
+
+  // Uses the schema to validate the object (REST API format).
+  // Returns a promise that resolves to the new schema.
+  // This does not update this.schema, because in a situation like a
+  // batch request, that could confuse other users of the schema.
+  validateObject(className, object, query, runOptions, maintenance) {
+    let schema;
+    const acl = runOptions.acl;
+    const isMaster = acl === undefined;
+    var aclGroup = acl || [];
+    return this.loadSchema().then(s => {
+      schema = s;
+      if (isMaster) {
+        return Promise.resolve();
+      }
+      return this.canAddField(schema, className, object, aclGroup, runOptions);
+    }).then(() => {
+      return schema.validateObject(className, object, query, maintenance);
+    });
+  }
+
+  /**
+   * Updates objects in the database that match the given query.
+   * @param {Object} options
+   * @param {boolean} [options.many=false] When true, updates all matching documents
+   *   and returns `{ matchedCount, modifiedCount }` where values are numbers if the
+   *   storage adapter supports `UpdateManyResult`, or `undefined` otherwise.
+   */
+  update(className, query, update, {
+    acl,
+    many,
+    upsert,
+    addsField
+  } = {}, skipSanitization = false, validateOnly = false, validSchemaController) {
+    try {
+      _Utils.default.checkProhibitedKeywords(this.options, update);
+    } catch (error) {
+      return Promise.reject(new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `${error}`));
+    }
+    try {
+      const {
+        validateFileUrlsInObject
+      } = require('../FileUrlValidator');
+      validateFileUrlsInObject(update, this.options);
+    } catch (error) {
+      return Promise.reject(error instanceof _node.Parse.Error ? error : new _node.Parse.Error(_node.Parse.Error.FILE_SAVE_ERROR, error.message || error));
+    }
+    const originalQuery = query;
+    const originalUpdate = update;
+    // Make a copy of the object, so we don't mutate the incoming data.
+    update = structuredClone(update);
+    var relationUpdates = [];
+    var isMaster = acl === undefined;
+    var aclGroup = acl || [];
+    return this.loadSchemaIfNeeded(validSchemaController).then(schemaController => {
+      return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'update')).then(() => {
+        relationUpdates = this.collectRelationUpdates(className, originalQuery.objectId, update);
+        if (!isMaster) {
+          query = this.addPointerPermissions(schemaController, className, 'update', query, aclGroup);
+          if (addsField) {
+            query = {
+              $and: [query, this.addPointerPermissions(schemaController, className, 'addField', query, aclGroup)]
+            };
+          }
+        }
+        if (!query) {
+          return Promise.resolve();
+        }
+        if (acl) {
+          query = addWriteACL(query, acl);
+        }
+        validateQuery(query, isMaster, false, true, this.options);
+        return schemaController.getOneSchema(className, true).catch(error => {
+          // If the schema doesn't exist, pretend it exists with no fields. This behavior
+          // will likely need revisiting.
+          if (error === undefined) {
+            return {
+              fields: {}
+            };
+          }
+          throw error;
+        }).then(schema => {
+          Object.keys(update).forEach(fieldName => {
+            if (fieldName.match(/^authData\./)) {
+              throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);
+            }
+            const rootFieldName = getRootFieldName(fieldName);
+            if (!SchemaController.fieldNameIsValid(rootFieldName, className) && !isSpecialUpdateKey(rootFieldName)) {
+              throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);
+            }
+          });
+          for (const updateOperation in update) {
+            if (update[updateOperation] && typeof update[updateOperation] === 'object' && Object.keys(update[updateOperation]).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) {
+              throw new _node.Parse.Error(_node.Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters");
+            }
+          }
+          update = transformObjectACL(update);
+          convertEmailToLowercase(update, className, this.options);
+          convertUsernameToLowercase(update, className, this.options);
+          transformAuthData(className, update, schema);
+          if (validateOnly) {
+            return this.adapter.find(className, schema, query, {
+              readPreference: 'primary'
+            }).then(result => {
+              if (!result || !result.length) {
+                throw new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');
+              }
+              return {};
+            });
+          }
+          if (many) {
+            return this.adapter.updateObjectsByQuery(className, schema, query, update, this._transactionalSession);
+          } else if (upsert) {
+            return this.adapter.upsertOneObject(className, schema, query, update, this._transactionalSession);
+          } else {
+            return this.adapter.findOneAndUpdate(className, schema, query, update, this._transactionalSession);
+          }
+        });
+      }).then(result => {
+        if (!result) {
+          throw new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');
+        }
+        if (validateOnly) {
+          return result;
+        }
+        return this.handleRelationUpdates(className, originalQuery.objectId, update, relationUpdates).then(() => {
+          return result;
+        });
+      }).then(result => {
+        if (skipSanitization) {
+          return Promise.resolve(result);
+        }
+        if (many) {
+          return {
+            matchedCount: typeof result?.matchedCount === 'number' ? result.matchedCount : undefined,
+            modifiedCount: typeof result?.modifiedCount === 'number' ? result.modifiedCount : undefined
+          };
+        }
+        return this._sanitizeDatabaseResult(originalUpdate, result);
+      });
+    });
+  }
+
+  // Collect all relation-updating operations from a REST-format update.
+  // Returns a list of all relation updates to perform
+  // This mutates update.
+  collectRelationUpdates(className, objectId, update) {
+    var ops = [];
+    var deleteMe = [];
+    objectId = update.objectId || objectId;
+    var process = (op, key) => {
+      if (!op) {
+        return;
+      }
+      if (op.__op == 'AddRelation') {
+        ops.push({
+          key,
+          op
+        });
+        deleteMe.push(key);
+      }
+      if (op.__op == 'RemoveRelation') {
+        ops.push({
+          key,
+          op
+        });
+        deleteMe.push(key);
+      }
+      if (op.__op == 'Batch') {
+        for (var x of op.ops) {
+          process(x, key);
+        }
+      }
+    };
+    for (const key in update) {
+      process(update[key], key);
+    }
+    for (const key of deleteMe) {
+      delete update[key];
+    }
+    return ops;
+  }
+
+  // Processes relation-updating operations from a REST-format update.
+  // Returns a promise that resolves when all updates have been performed
+  handleRelationUpdates(className, objectId, update, ops) {
+    var pending = [];
+    objectId = update.objectId || objectId;
+    ops.forEach(({
+      key,
+      op
+    }) => {
+      if (!op) {
+        return;
+      }
+      if (op.__op == 'AddRelation') {
+        for (const object of op.objects) {
+          pending.push(this.addRelation(key, className, objectId, object.objectId));
+        }
+      }
+      if (op.__op == 'RemoveRelation') {
+        for (const object of op.objects) {
+          pending.push(this.removeRelation(key, className, objectId, object.objectId));
+        }
+      }
+    });
+    return Promise.all(pending);
+  }
+
+  // Adds a relation.
+  // Returns a promise that resolves successfully iff the add was successful.
+  addRelation(key, fromClassName, fromId, toId) {
+    const doc = {
+      relatedId: toId,
+      owningId: fromId
+    };
+    return this.adapter.upsertOneObject(`_Join:${key}:${fromClassName}`, relationSchema, doc, doc, this._transactionalSession);
+  }
+
+  // Removes a relation.
+  // Returns a promise that resolves successfully iff the remove was
+  // successful.
+  removeRelation(key, fromClassName, fromId, toId) {
+    var doc = {
+      relatedId: toId,
+      owningId: fromId
+    };
+    return this.adapter.deleteObjectsByQuery(`_Join:${key}:${fromClassName}`, relationSchema, doc, this._transactionalSession).catch(error => {
+      // We don't care if they try to delete a non-existent relation.
+      if (error.code == _node.Parse.Error.OBJECT_NOT_FOUND) {
+        return;
+      }
+      throw error;
+    });
+  }
+
+  // Removes objects matches this query from the database.
+  // Returns a promise that resolves successfully iff the object was
+  // deleted.
+  // Options:
+  //   acl:  a list of strings. If the object to be updated has an ACL,
+  //         one of the provided strings must provide the caller with
+  //         write permissions.
+  destroy(className, query, {
+    acl
+  } = {}, validSchemaController) {
+    const isMaster = acl === undefined;
+    const aclGroup = acl || [];
+    return this.loadSchemaIfNeeded(validSchemaController).then(schemaController => {
+      return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'delete')).then(() => {
+        if (!isMaster) {
+          query = this.addPointerPermissions(schemaController, className, 'delete', query, aclGroup);
+          if (!query) {
+            throw new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');
+          }
+        }
+        // delete by query
+        if (acl) {
+          query = addWriteACL(query, acl);
+        }
+        validateQuery(query, isMaster, false, false, this.options);
+        return schemaController.getOneSchema(className).catch(error => {
+          // If the schema doesn't exist, pretend it exists with no fields. This behavior
+          // will likely need revisiting.
+          if (error === undefined) {
+            return {
+              fields: {}
+            };
+          }
+          throw error;
+        }).then(parseFormatSchema => this.adapter.deleteObjectsByQuery(className, parseFormatSchema, query, this._transactionalSession)).catch(error => {
+          // When deleting sessions while changing passwords, don't throw an error if they don't have any sessions.
+          if (className === '_Session' && error.code === _node.Parse.Error.OBJECT_NOT_FOUND) {
+            return Promise.resolve({});
+          }
+          throw error;
+        });
+      });
+    });
+  }
+
+  // Inserts an object into the database.
+  // Returns a promise that resolves successfully iff the object saved.
+  create(className, object, {
+    acl
+  } = {}, validateOnly = false, validSchemaController) {
+    try {
+      _Utils.default.checkProhibitedKeywords(this.options, object);
+    } catch (error) {
+      return Promise.reject(new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `${error}`));
+    }
+    try {
+      const {
+        validateFileUrlsInObject
+      } = require('../FileUrlValidator');
+      validateFileUrlsInObject(object, this.options);
+    } catch (error) {
+      return Promise.reject(error instanceof _node.Parse.Error ? error : new _node.Parse.Error(_node.Parse.Error.FILE_SAVE_ERROR, error.message || error));
+    }
+    // Make a copy of the object, so we don't mutate the incoming data.
+    const originalObject = object;
+    object = transformObjectACL(object);
+    convertEmailToLowercase(object, className, this.options);
+    convertUsernameToLowercase(object, className, this.options);
+    object.createdAt = {
+      iso: object.createdAt,
+      __type: 'Date'
+    };
+    object.updatedAt = {
+      iso: object.updatedAt,
+      __type: 'Date'
+    };
+    var isMaster = acl === undefined;
+    var aclGroup = acl || [];
+    const relationUpdates = this.collectRelationUpdates(className, null, object);
+    return this.validateClassName(className).then(() => this.loadSchemaIfNeeded(validSchemaController)).then(schemaController => {
+      return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'create')).then(() => schemaController.enforceClassExists(className)).then(() => schemaController.getOneSchema(className, true)).then(schema => {
+        transformAuthData(className, object, schema);
+        flattenUpdateOperatorsForCreate(object);
+        if (validateOnly) {
+          return {};
+        }
+        return this.adapter.createObject(className, SchemaController.convertSchemaToAdapterSchema(schema), object, this._transactionalSession);
+      }).then(result => {
+        if (validateOnly) {
+          return originalObject;
+        }
+        return this.handleRelationUpdates(className, object.objectId, object, relationUpdates).then(() => {
+          return this._sanitizeDatabaseResult(originalObject, result.ops[0]);
+        });
+      });
+    });
+  }
+  canAddField(schema, className, object, aclGroup, runOptions) {
+    const classSchema = schema.schemaData[className];
+    if (!classSchema) {
+      return Promise.resolve();
+    }
+    const fields = Object.keys(object);
+    const schemaFields = Object.keys(classSchema.fields);
+    const newKeys = fields.filter(field => {
+      // Skip fields that are unset
+      if (object[field] && object[field].__op && object[field].__op === 'Delete') {
+        return false;
+      }
+      return schemaFields.indexOf(getRootFieldName(field)) < 0;
+    });
+    if (newKeys.length > 0) {
+      // adds a marker that new field is being adding during update
+      runOptions.addsField = true;
+      const action = runOptions.action;
+      return schema.validatePermission(className, aclGroup, 'addField', action);
+    }
+    return Promise.resolve();
+  }
+
+  // Won't delete collections in the system namespace
+  /**
+   * Delete all classes and clears the schema cache
+   *
+   * @param {boolean} fast set to true if it's ok to just delete rows and not indexes
+   * @returns {Promise<void>} when the deletions completes
+   */
+  deleteEverything(fast = false) {
+    this.schemaPromise = null;
+    _SchemaCache.default.clear();
+    return this.adapter.deleteAllClasses(fast);
+  }
+
+  // Returns a promise for a list of related ids given an owning id.
+  // className here is the owning className.
+  relatedIds(className, key, owningId, queryOptions) {
+    const {
+      skip,
+      limit,
+      sort
+    } = queryOptions;
+    const findOptions = {};
+    if (sort && sort.createdAt && this.adapter.canSortOnJoinTables) {
+      findOptions.sort = {
+        _id: sort.createdAt
+      };
+      findOptions.limit = limit;
+      findOptions.skip = skip;
+      queryOptions.skip = 0;
+    }
+    return this.adapter.find(joinTableName(className, key), relationSchema, {
+      owningId
+    }, findOptions).then(results => results.map(result => result.relatedId));
+  }
+
+  // Returns a promise for a list of owning ids given some related ids.
+  // className here is the owning className.
+  owningIds(className, key, relatedIds) {
+    return this.adapter.find(joinTableName(className, key), relationSchema, {
+      relatedId: {
+        $in: relatedIds
+      }
+    }, {
+      keys: ['owningId']
+    }).then(results => results.map(result => result.owningId));
+  }
+
+  // Modifies query so that it no longer has $in on relation fields, or
+  // equal-to-pointer constraints on relation fields.
+  // Returns a promise that resolves when query is mutated
+  reduceInRelation(className, query, schema) {
+    // Search for an in-relation or equal-to-relation
+    // Make it sequential for now, not sure of paralleization side effects
+    const promises = [];
+    if (query['$or']) {
+      const ors = query['$or'];
+      promises.push(...ors.map((aQuery, index) => {
+        return this.reduceInRelation(className, aQuery, schema).then(aQuery => {
+          query['$or'][index] = aQuery;
+        });
+      }));
+    }
+    if (query['$and']) {
+      const ands = query['$and'];
+      promises.push(...ands.map((aQuery, index) => {
+        return this.reduceInRelation(className, aQuery, schema).then(aQuery => {
+          query['$and'][index] = aQuery;
+        });
+      }));
+    }
+    const otherKeys = Object.keys(query).map(key => {
+      if (key === '$and' || key === '$or') {
+        return;
+      }
+      const t = schema.getExpectedType(className, key);
+      if (!t || t.type !== 'Relation') {
+        return Promise.resolve(query);
+      }
+      let queries = null;
+      if (query[key] && (query[key]['$in'] || query[key]['$ne'] || query[key]['$nin'] || query[key].__type == 'Pointer')) {
+        // Build the list of queries
+        queries = Object.keys(query[key]).map(constraintKey => {
+          let relatedIds;
+          let isNegation = false;
+          if (constraintKey === 'objectId') {
+            relatedIds = [query[key].objectId];
+          } else if (constraintKey == '$in') {
+            relatedIds = query[key]['$in'].map(r => r.objectId);
+          } else if (constraintKey == '$nin') {
+            isNegation = true;
+            relatedIds = query[key]['$nin'].map(r => r.objectId);
+          } else if (constraintKey == '$ne') {
+            isNegation = true;
+            relatedIds = [query[key]['$ne'].objectId];
+          } else {
+            return;
+          }
+          return {
+            isNegation,
+            relatedIds
+          };
+        });
+      } else {
+        queries = [{
+          isNegation: false,
+          relatedIds: []
+        }];
+      }
+
+      // remove the current queryKey as we don,t need it anymore
+      delete query[key];
+      // execute each query independently to build the list of
+      // $in / $nin
+      const promises = queries.map(q => {
+        if (!q) {
+          return Promise.resolve();
+        }
+        return this.owningIds(className, key, q.relatedIds).then(ids => {
+          if (q.isNegation) {
+            this.addNotInObjectIdsIds(ids, query);
+          } else {
+            this.addInObjectIdsIds(ids, query);
+          }
+          return Promise.resolve();
+        });
+      });
+      return Promise.all(promises).then(() => {
+        return Promise.resolve();
+      });
+    });
+    return Promise.all([...promises, ...otherKeys]).then(() => {
+      return Promise.resolve(query);
+    });
+  }
+
+  // Modifies query so that it no longer has $relatedTo
+  // Returns a promise that resolves when query is mutated
+  reduceRelationKeys(className, query, queryOptions) {
+    if (query['$or']) {
+      return Promise.all(query['$or'].map(aQuery => {
+        return this.reduceRelationKeys(className, aQuery, queryOptions);
+      }));
+    }
+    if (query['$and']) {
+      return Promise.all(query['$and'].map(aQuery => {
+        return this.reduceRelationKeys(className, aQuery, queryOptions);
+      }));
+    }
+    var relatedTo = query['$relatedTo'];
+    if (relatedTo) {
+      return this.relatedIds(relatedTo.object.className, relatedTo.key, relatedTo.object.objectId, queryOptions).then(ids => {
+        delete query['$relatedTo'];
+        this.addInObjectIdsIds(ids, query);
+        return this.reduceRelationKeys(className, query, queryOptions);
+      }).then(() => {});
+    }
+  }
+  addInObjectIdsIds(ids = null, query) {
+    const idsFromString = typeof query.objectId === 'string' ? [query.objectId] : null;
+    const idsFromEq = query.objectId && query.objectId['$eq'] ? [query.objectId['$eq']] : null;
+    const idsFromIn = query.objectId && query.objectId['$in'] ? query.objectId['$in'] : null;
+
+    // -disable-next
+    const allIds = [idsFromString, idsFromEq, idsFromIn, ids].filter(list => list !== null);
+    const totalLength = allIds.reduce((memo, list) => memo + list.length, 0);
+    let idsIntersection = [];
+    if (totalLength > 125) {
+      idsIntersection = _intersect.default.big(allIds);
+    } else {
+      idsIntersection = (0, _intersect.default)(allIds);
+    }
+
+    // Need to make sure we don't clobber existing shorthand $eq constraints on objectId.
+    if (!('objectId' in query)) {
+      query.objectId = {
+        $in: undefined
+      };
+    } else if (typeof query.objectId === 'string') {
+      query.objectId = {
+        $in: undefined,
+        $eq: query.objectId
+      };
+    }
+    query.objectId['$in'] = idsIntersection;
+    return query;
+  }
+  addNotInObjectIdsIds(ids = [], query) {
+    const idsFromNin = query.objectId && query.objectId['$nin'] ? query.objectId['$nin'] : [];
+    let allIds = [...idsFromNin, ...ids].filter(list => list !== null);
+
+    // make a set and spread to remove duplicates
+    allIds = [...new Set(allIds)];
+
+    // Need to make sure we don't clobber existing shorthand $eq constraints on objectId.
+    if (!('objectId' in query)) {
+      query.objectId = {
+        $nin: undefined
+      };
+    } else if (typeof query.objectId === 'string') {
+      query.objectId = {
+        $nin: undefined,
+        $eq: query.objectId
+      };
+    }
+    query.objectId['$nin'] = allIds;
+    return query;
+  }
+
+  // Runs a query on the database.
+  // Returns a promise that resolves to a list of items.
+  // Options:
+  //   skip    number of results to skip.
+  //   limit   limit to this number of results.
+  //   sort    an object where keys are the fields to sort by.
+  //           the value is +1 for ascending, -1 for descending.
+  //   count   run a count instead of returning results.
+  //   acl     restrict this operation with an ACL for the provided array
+  //           of user objectIds and roles. acl: null means no user.
+  //           when this field is not present, don't do anything regarding ACLs.
+  //  caseInsensitive make string comparisons case insensitive
+  // TODO: make userIds not needed here. The db adapter shouldn't know
+  // anything about users, ideally. Then, improve the format of the ACL
+  // arg to work like the others.
+  find(className, query, {
+    skip,
+    limit,
+    acl,
+    sort = {},
+    count,
+    keys,
+    op,
+    distinct,
+    pipeline,
+    readPreference,
+    hint,
+    caseInsensitive = false,
+    explain,
+    comment,
+    rawValues,
+    rawFieldNames
+  } = {}, auth = {}, validSchemaController) {
+    const isMaintenance = auth.isMaintenance;
+    const isMaster = acl === undefined || isMaintenance;
+    const aclGroup = acl || [];
+    op = op || (typeof query.objectId == 'string' && Object.keys(query).length === 1 ? 'get' : 'find');
+    // Count operation if counting
+    op = count === true ? 'count' : op;
+    let classExists = true;
+    return this.loadSchemaIfNeeded(validSchemaController).then(schemaController => {
+      //Allow volatile classes if querying with Master (for _PushStatus)
+      //TODO: Move volatile classes concept into mongo adapter, postgres adapter shouldn't care
+      //that api.parse.com breaks when _PushStatus exists in mongo.
+      return schemaController.getOneSchema(className, isMaster).catch(error => {
+        // Behavior for non-existent classes is kinda weird on Parse.com. Probably doesn't matter too much.
+        // For now, pretend the class exists but has no objects,
+        if (error === undefined) {
+          classExists = false;
+          return {
+            fields: {}
+          };
+        }
+        throw error;
+      }).then(schema => {
+        // Parse.com treats queries on _created_at and _updated_at as if they were queries on createdAt and updatedAt,
+        // so duplicate that behavior here. If both are specified, the correct behavior to match Parse.com is to
+        // use the one that appears first in the sort list.
+        if (sort._created_at) {
+          sort.createdAt = sort._created_at;
+          delete sort._created_at;
+        }
+        if (sort._updated_at) {
+          sort.updatedAt = sort._updated_at;
+          delete sort._updated_at;
+        }
+        const queryOptions = {
+          skip,
+          limit,
+          sort,
+          keys,
+          readPreference,
+          hint,
+          caseInsensitive: this.options.enableCollationCaseComparison ? false : caseInsensitive,
+          explain,
+          comment
+        };
+        Object.keys(sort).forEach(fieldName => {
+          if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) {
+            throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Cannot sort by ${fieldName}`);
+          }
+          const rootFieldName = getRootFieldName(fieldName);
+          if (!SchemaController.fieldNameIsValid(rootFieldName, className)) {
+            throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`);
+          }
+          if (!schema.fields[fieldName.split('.')[0]] && fieldName !== 'score') {
+            delete sort[fieldName];
+          }
+        });
+        return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, op)).then(() => this.reduceRelationKeys(className, query, queryOptions)).then(() => this.reduceInRelation(className, query, schemaController)).then(() => {
+          let protectedFields;
+          if (!isMaster) {
+            query = this.addPointerPermissions(schemaController, className, op, query, aclGroup);
+            /* Don't use projections to optimize the protectedFields since the protectedFields
+              based on pointer-permissions are determined after querying. The filtering can
+              overwrite the protected fields. */
+            protectedFields = this.addProtectedFields(schemaController, className, query, aclGroup, auth, queryOptions);
+          }
+          if (!query) {
+            if (op === 'get') {
+              throw new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');
+            } else {
+              return [];
+            }
+          }
+          if (!isMaster) {
+            if (op === 'update' || op === 'delete') {
+              query = addWriteACL(query, aclGroup);
+            } else {
+              query = addReadACL(query, aclGroup);
+            }
+          }
+          validateQuery(query, isMaster, isMaintenance, false, this.options);
+          if (count) {
+            if (!classExists) {
+              return 0;
+            } else {
+              return this.adapter.count(className, schema, query, readPreference, undefined, hint, comment);
+            }
+          } else if (distinct) {
+            if (!classExists) {
+              return [];
+            } else {
+              return this.adapter.distinct(className, schema, query, distinct);
+            }
+          } else if (pipeline) {
+            if (!classExists) {
+              return [];
+            } else {
+              return this.adapter.aggregate(className, schema, pipeline, readPreference, hint, explain, comment, rawValues, rawFieldNames);
+            }
+          } else if (explain) {
+            return this.adapter.find(className, schema, query, queryOptions);
+          } else {
+            return this.adapter.find(className, schema, query, queryOptions).then(objects => objects.map(object => {
+              object = untransformObjectACL(object);
+              return filterSensitiveData(isMaster, isMaintenance, aclGroup, auth, op, schemaController, className, protectedFields, object, this.options.protectedFieldsOwnerExempt);
+            })).catch(error => {
+              if (error instanceof _node.Parse.Error) {
+                throw error;
+              }
+              const detailedMessage = typeof error === 'string' ? error : error?.message || 'An internal server error occurred';
+              throw (0, _Error.createSanitizedError)(_node.Parse.Error.INTERNAL_SERVER_ERROR, detailedMessage, this.options, 'An internal server error occurred');
+            });
+          }
+        });
+      });
+    });
+  }
+  deleteSchema(className) {
+    let schemaController;
+    return this.loadSchema({
+      clearCache: true
+    }).then(s => {
+      schemaController = s;
+      return schemaController.getOneSchema(className, true);
+    }).catch(error => {
+      if (error === undefined) {
+        return {
+          fields: {}
+        };
+      } else {
+        throw error;
+      }
+    }).then(schema => {
+      return this.collectionExists(className).then(() => this.adapter.count(className, {
+        fields: {}
+      }, null, '', false)).then(count => {
+        if (count > 0) {
+          throw new _node.Parse.Error(255, `Class ${className} is not empty, contains ${count} objects, cannot drop schema.`);
+        }
+        return this.adapter.deleteClass(className);
+      }).then(wasParseCollection => {
+        if (wasParseCollection) {
+          const relationFieldNames = Object.keys(schema.fields).filter(fieldName => schema.fields[fieldName].type === 'Relation');
+          return Promise.all(relationFieldNames.map(name => this.adapter.deleteClass(joinTableName(className, name)))).then(() => {
+            _SchemaCache.default.del(className);
+            return schemaController.reloadData();
+          });
+        } else {
+          return Promise.resolve();
+        }
+      });
+    });
+  }
+
+  // This helps to create intermediate objects for simpler comparison of
+  // key value pairs used in query objects. Each key value pair will represented
+  // in a similar way to json
+  objectToEntriesStrings(query) {
+    return Object.entries(query).map(a => a.map(s => JSON.stringify(s)).join(':'));
+  }
+
+  // Naive logic reducer for OR operations meant to be used only for pointer permissions.
+  reduceOrOperation(query) {
+    if (!query.$or) {
+      return query;
+    }
+    const queries = query.$or.map(q => this.objectToEntriesStrings(q));
+    let repeat = false;
+    do {
+      repeat = false;
+      for (let i = 0; i < queries.length - 1; i++) {
+        for (let j = i + 1; j < queries.length; j++) {
+          const [shorter, longer] = queries[i].length > queries[j].length ? [j, i] : [i, j];
+          const foundEntries = queries[shorter].reduce((acc, entry) => acc + (queries[longer].includes(entry) ? 1 : 0), 0);
+          const shorterEntries = queries[shorter].length;
+          if (foundEntries === shorterEntries) {
+            // If the shorter query is completely contained in the longer one, we can strike
+            // out the longer query.
+            query.$or.splice(longer, 1);
+            queries.splice(longer, 1);
+            repeat = true;
+            break;
+          }
+        }
+      }
+    } while (repeat);
+    if (query.$or.length === 1) {
+      query = {
+        ...query,
+        ...query.$or[0]
+      };
+      delete query.$or;
+    }
+    return query;
+  }
+
+  // Naive logic reducer for AND operations meant to be used only for pointer permissions.
+  reduceAndOperation(query) {
+    if (!query.$and) {
+      return query;
+    }
+    const queries = query.$and.map(q => this.objectToEntriesStrings(q));
+    let repeat = false;
+    do {
+      repeat = false;
+      for (let i = 0; i < queries.length - 1; i++) {
+        for (let j = i + 1; j < queries.length; j++) {
+          const [shorter, longer] = queries[i].length > queries[j].length ? [j, i] : [i, j];
+          const foundEntries = queries[shorter].reduce((acc, entry) => acc + (queries[longer].includes(entry) ? 1 : 0), 0);
+          const shorterEntries = queries[shorter].length;
+          if (foundEntries === shorterEntries) {
+            // If the shorter query is completely contained in the longer one, we can strike
+            // out the shorter query.
+            query.$and.splice(shorter, 1);
+            queries.splice(shorter, 1);
+            repeat = true;
+            break;
+          }
+        }
+      }
+    } while (repeat);
+    if (query.$and.length === 1) {
+      query = {
+        ...query,
+        ...query.$and[0]
+      };
+      delete query.$and;
+    }
+    return query;
+  }
+
+  // Constraints query using CLP's pointer permissions (PP) if any.
+  // 1. Etract the user id from caller's ACLgroup;
+  // 2. Exctract a list of field names that are PP for target collection and operation;
+  // 3. Constraint the original query so that each PP field must
+  // point to caller's id (or contain it in case of PP field being an array)
+  addPointerPermissions(schema, className, operation, query, aclGroup = []) {
+    // Check if class has public permission for operation
+    // If the BaseCLP pass, let go through
+    if (schema.testPermissionsForClassName(className, aclGroup, operation)) {
+      return query;
+    }
+    const perms = schema.getClassLevelPermissions(className);
+    const userACL = aclGroup.filter(acl => {
+      return acl.indexOf('role:') != 0 && acl != '*';
+    });
+    const groupKey = ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';
+    const permFields = [];
+    if (perms[operation] && perms[operation].pointerFields) {
+      permFields.push(...perms[operation].pointerFields);
+    }
+    if (perms[groupKey]) {
+      for (const field of perms[groupKey]) {
+        if (!permFields.includes(field)) {
+          permFields.push(field);
+        }
+      }
+    }
+    // the ACL should have exactly 1 user
+    if (permFields.length > 0) {
+      // the ACL should have exactly 1 user
+      // No user set return undefined
+      // If the length is > 1, that means we didn't de-dupe users correctly
+      if (userACL.length != 1) {
+        return;
+      }
+      const userId = userACL[0];
+      const userPointer = {
+        __type: 'Pointer',
+        className: '_User',
+        objectId: userId
+      };
+      const queries = permFields.map(key => {
+        const fieldDescriptor = schema.getExpectedType(className, key);
+        const fieldType = fieldDescriptor && typeof fieldDescriptor === 'object' && Object.prototype.hasOwnProperty.call(fieldDescriptor, 'type') ? fieldDescriptor.type : null;
+        let queryClause;
+        if (fieldType === 'Pointer') {
+          // constraint for single pointer setup
+          queryClause = {
+            [key]: userPointer
+          };
+        } else if (fieldType === 'Array') {
+          // constraint for users-array setup
+          queryClause = {
+            [key]: {
+              $all: [userPointer]
+            }
+          };
+        } else if (fieldType === 'Object') {
+          // constraint for object setup
+          queryClause = {
+            [key]: userPointer
+          };
+        } else {
+          // This means that there is a CLP field of an unexpected type. This condition should not happen, which is
+          // why is being treated as an error.
+          throw Error(`An unexpected condition occurred when resolving pointer permissions: ${className} ${key}`);
+        }
+        // if we already have a constraint on the key, use the $and
+        if (Object.prototype.hasOwnProperty.call(query, key)) {
+          return this.reduceAndOperation({
+            $and: [queryClause, query]
+          });
+        }
+        // otherwise just add the constaint
+        return Object.assign({}, query, queryClause);
+      });
+      return queries.length === 1 ? queries[0] : this.reduceOrOperation({
+        $or: queries
+      });
+    } else {
+      return query;
+    }
+  }
+  addProtectedFields(schema, className, query = {}, aclGroup = [], auth = {}, queryOptions = {}) {
+    const perms = schema && schema.getClassLevelPermissions ? schema.getClassLevelPermissions(className) : schema;
+    if (!perms) {
+      return null;
+    }
+    const protectedFields = perms.protectedFields;
+    if (!protectedFields) {
+      return null;
+    }
+    if (className === '_User' && this.options.protectedFieldsOwnerExempt !== false && aclGroup.indexOf(query.objectId) > -1) {
+      return null;
+    }
+
+    // for queries where "keys" are set and do not include all 'userField':{field},
+    // we have to transparently include it, and then remove before returning to client
+    // Because if such key not projected the permission won't be enforced properly
+    // PS this is called when 'excludeKeys' already reduced to 'keys'
+    const preserveKeys = queryOptions.keys;
+
+    // these are keys that need to be included only
+    // to be able to apply protectedFields by pointer
+    // and then unset before returning to client (later in  filterSensitiveFields)
+    const serverOnlyKeys = [];
+    const authenticated = auth.user;
+
+    // map to allow check without array search
+    const roles = (auth.userRoles || []).reduce((acc, r) => {
+      acc[r] = protectedFields[r];
+      return acc;
+    }, {});
+
+    // array of sets of protected fields. separate item for each applicable criteria
+    const protectedKeysSets = [];
+    for (const key in protectedFields) {
+      // skip userFields
+      if (key.startsWith('userField:')) {
+        if (preserveKeys) {
+          const fieldName = key.substring(10);
+          if (!preserveKeys.includes(fieldName)) {
+            // 1. put it there temporarily
+            queryOptions.keys && queryOptions.keys.push(fieldName);
+            // 2. preserve it delete later
+            serverOnlyKeys.push(fieldName);
+          }
+        }
+        continue;
+      }
+
+      // add public tier
+      if (key === '*') {
+        protectedKeysSets.push(protectedFields[key]);
+        continue;
+      }
+      if (authenticated) {
+        if (key === 'authenticated') {
+          // for logged in users
+          protectedKeysSets.push(protectedFields[key]);
+          continue;
+        }
+        if (roles[key] && key.startsWith('role:')) {
+          // add applicable roles
+          protectedKeysSets.push(roles[key]);
+        }
+      }
+    }
+
+    // check if there's a rule for current user's id
+    if (authenticated) {
+      const userId = auth.user.id;
+      if (perms.protectedFields[userId]) {
+        protectedKeysSets.push(perms.protectedFields[userId]);
+      }
+    }
+
+    // preserve fields to be removed before sending response to client
+    if (serverOnlyKeys.length > 0) {
+      perms.protectedFields.temporaryKeys = serverOnlyKeys;
+    }
+    let protectedKeys = protectedKeysSets.reduce((acc, next) => {
+      if (next) {
+        acc.push(...next);
+      }
+      return acc;
+    }, []);
+
+    // intersect all sets of protectedFields
+    protectedKeysSets.forEach(fields => {
+      if (fields) {
+        protectedKeys = protectedKeys.filter(v => fields.includes(v));
+      }
+    });
+    return protectedKeys;
+  }
+  createTransactionalSession() {
+    return this.adapter.createTransactionalSession().then(transactionalSession => {
+      this._transactionalSession = transactionalSession;
+    });
+  }
+  commitTransactionalSession() {
+    if (!this._transactionalSession) {
+      throw new Error('There is no transactional session to commit');
+    }
+    return this.adapter.commitTransactionalSession(this._transactionalSession).then(() => {
+      this._transactionalSession = null;
+    });
+  }
+  abortTransactionalSession() {
+    if (!this._transactionalSession) {
+      throw new Error('There is no transactional session to abort');
+    }
+    return this.adapter.abortTransactionalSession(this._transactionalSession).then(() => {
+      this._transactionalSession = null;
+    });
+  }
+
+  // TODO: create indexes on first creation of a _User object. Otherwise it's impossible to
+  // have a Parse app without it having a _User collection.
+  async performInitialization() {
+    await this.adapter.performInitialization({
+      VolatileClassesSchemas: SchemaController.VolatileClassesSchemas
+    });
+    const requiredUserFields = {
+      fields: {
+        ...SchemaController.defaultColumns._Default,
+        ...SchemaController.defaultColumns._User
+      }
+    };
+    const requiredRoleFields = {
+      fields: {
+        ...SchemaController.defaultColumns._Default,
+        ...SchemaController.defaultColumns._Role
+      }
+    };
+    const requiredIdempotencyFields = {
+      fields: {
+        ...SchemaController.defaultColumns._Default,
+        ...SchemaController.defaultColumns._Idempotency
+      }
+    };
+    await this.loadSchema().then(schema => schema.enforceClassExists('_User'));
+    await this.loadSchema().then(schema => schema.enforceClassExists('_Role'));
+    await this.loadSchema().then(schema => schema.enforceClassExists('_Idempotency'));
+    const databaseOptions = this.options.databaseOptions || {};
+    if (databaseOptions.createIndexUserUsername !== false) {
+      await this.adapter.ensureUniqueness('_User', requiredUserFields, ['username']).catch(error => {
+        _logger.default.warn('Unable to ensure uniqueness for usernames: ', error);
+        throw error;
+      });
+    }
+    if (!this.options.enableCollationCaseComparison) {
+      if (databaseOptions.createIndexUserUsernameCaseInsensitive !== false) {
+        await this.adapter.ensureIndex('_User', requiredUserFields, ['username'], 'case_insensitive_username', true).catch(error => {
+          _logger.default.warn('Unable to create case insensitive username index: ', error);
+          throw error;
+        });
+      }
+      if (databaseOptions.createIndexUserEmailCaseInsensitive !== false) {
+        await this.adapter.ensureIndex('_User', requiredUserFields, ['email'], 'case_insensitive_email', true).catch(error => {
+          _logger.default.warn('Unable to create case insensitive email index: ', error);
+          throw error;
+        });
+      }
+    }
+    if (databaseOptions.createIndexUserEmail !== false) {
+      await this.adapter.ensureUniqueness('_User', requiredUserFields, ['email']).catch(error => {
+        _logger.default.warn('Unable to ensure uniqueness for user email addresses: ', error);
+        throw error;
+      });
+    }
+    if (databaseOptions.createIndexUserEmailVerifyToken !== false) {
+      await this.adapter.ensureIndex('_User', requiredUserFields, ['_email_verify_token'], '_email_verify_token', false).catch(error => {
+        _logger.default.warn('Unable to create index for email verification token: ', error);
+        throw error;
+      });
+    }
+    if (databaseOptions.createIndexUserPasswordResetToken !== false) {
+      await this.adapter.ensureIndex('_User', requiredUserFields, ['_perishable_token'], '_perishable_token', false).catch(error => {
+        _logger.default.warn('Unable to create index for password reset token: ', error);
+        throw error;
+      });
+    }
+    if (databaseOptions.createIndexRoleName !== false) {
+      await this.adapter.ensureUniqueness('_Role', requiredRoleFields, ['name']).catch(error => {
+        _logger.default.warn('Unable to ensure uniqueness for role name: ', error);
+        throw error;
+      });
+    }
+    await this.adapter.ensureUniqueness('_Idempotency', requiredIdempotencyFields, ['reqId']).catch(error => {
+      _logger.default.warn('Unable to ensure uniqueness for idempotency request ID: ', error);
+      throw error;
+    });
+    const isMongoAdapter = this.adapter instanceof _MongoStorageAdapter.default;
+    const isPostgresAdapter = this.adapter instanceof _PostgresStorageAdapter.default;
+    if (isMongoAdapter || isPostgresAdapter) {
+      let options = {};
+      if (isMongoAdapter) {
+        options = {
+          ttl: 0
+        };
+      } else if (isPostgresAdapter) {
+        options = this.idempotencyOptions;
+        options.setIdempotencyFunction = true;
+      }
+      await this.adapter.ensureIndex('_Idempotency', requiredIdempotencyFields, ['expire'], 'ttl', false, options).catch(error => {
+        _logger.default.warn('Unable to create TTL index for idempotency expire date: ', error);
+        throw error;
+      });
+    }
+    // Create unique indexes for authData providers to prevent race conditions
+    // during concurrent signups with the same authData
+    if (databaseOptions.createIndexAuthDataUniqueness !== false && typeof this.adapter.ensureAuthDataUniqueness === 'function') {
+      const authProviders = Object.keys(this.options.auth || {});
+      if (this.options.enableAnonymousUsers !== false) {
+        if (!authProviders.includes('anonymous')) {
+          authProviders.push('anonymous');
+        }
+      }
+      await Promise.all(authProviders.map(provider => this.adapter.ensureAuthDataUniqueness(provider).catch(error => {
+        _logger.default.warn(`Unable to ensure uniqueness for auth data provider "${provider}": `, error);
+      })));
+    }
+    await this.adapter.updateSchemaWithIndexes();
+  }
+  _expandResultOnKeyPath(object, key, value) {
+    if (key.indexOf('.') < 0) {
+      object[key] = value[key];
+      return object;
+    }
+    const path = key.split('.');
+    const firstKey = path[0];
+    const nextPath = path.slice(1).join('.');
+
+    // Scan request data for denied keywords
+    if (this.options && this.options.requestKeywordDenylist) {
+      // Scan request data for denied keywords
+      for (const keyword of this.options.requestKeywordDenylist) {
+        const match = _Utils.default.objectContainsKeyValue({
+          [firstKey]: true,
+          [nextPath]: true
+        }, keyword.key, true);
+        if (match) {
+          throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Prohibited keyword in request data: ${JSON.stringify(keyword)}.`);
+        }
+      }
+    }
+    object[firstKey] = this._expandResultOnKeyPath(object[firstKey] || {}, nextPath, value[firstKey]);
+    delete object[key];
+    return object;
+  }
+  _sanitizeDatabaseResult(originalObject, result) {
+    const response = {};
+    if (!result) {
+      return Promise.resolve(response);
+    }
+    Object.keys(originalObject).forEach(key => {
+      const keyUpdate = originalObject[key];
+      // determine if that was an op
+      if (keyUpdate && typeof keyUpdate === 'object' && keyUpdate.__op && ['Add', 'AddUnique', 'Remove', 'Increment', 'SetOnInsert'].indexOf(keyUpdate.__op) > -1) {
+        // only valid ops that produce an actionable result
+        // the op may have happened on a keypath
+        this._expandResultOnKeyPath(response, key, result);
+        // Revert array to object conversion on dot notation for arrays (e.g. "field.0.key")
+        if (key.includes('.')) {
+          const [field, index] = key.split('.');
+          const isArrayIndex = Array.from(index).every(c => c >= '0' && c <= '9');
+          if (isArrayIndex && Array.isArray(result[field]) && !Array.isArray(response[field])) {
+            response[field] = result[field];
+          }
+        }
+      }
+    });
+    return Promise.resolve(response);
+  }
+}
+module.exports = DatabaseController;
+// Expose validateQuery for tests
+module.exports._validateQuery = validateQuery;
+module.exports.filterSensitiveData = filterSensitiveData;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","require","_lodash","_interopRequireDefault","_intersect","_logger","_Utils","SchemaController","_interopRequireWildcard","_StorageAdapter","_MongoStorageAdapter","_PostgresStorageAdapter","_SchemaCache","_Error","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","queryOperators","internalFields","_rperm","clientRead","masterRead","masterWrite","_wperm","_hashed_password","_email_verify_token","_perishable_token","_perishable_token_expires_at","_email_verify_token_expires_at","_failed_login_count","_account_lockout_expires_at","_password_changed_at","_password_history","_tombstone","_session_token","specialQueryKeys","keys","filter","k","specialMasterQueryKeys","addWriteACL","query","acl","newQuery","_","cloneDeep","$in","addReadACL","transformObjectACL","ACL","result","entry","read","push","write","validateQuery","isMaster","isMaintenance","update","options","_depth","rc","requestComplexity","queryDepth","Parse","Error","INVALID_QUERY","$or","Array","isArray","forEach","value","$and","$nor","length","key","$regex","undefined","allowRegex","$options","match","includes","INVALID_KEY_NAME","filterSensitiveData","aclGroup","auth","operation","schema","className","protectedFields","object","protectedFieldsOwnerExempt","userId","user","id","perms","getClassLevelPermissions","isReadOperation","indexOf","protectedFieldsPointerPerm","startsWith","map","substring","newProtectedFields","overrideProtectedFields","pointerPerm","pointerPermIncludesUser","readUserFieldValue","some","objectId","fields","v","isUserClass","password","sessionToken","isOwnerExempt","temporaryKeys","charAt","authData","specialKeysForUpdate","isSpecialUpdateKey","joinTableName","flattenUpdateOperatorsForCreate","__op","amount","INVALID_JSON","objects","COMMAND_UNAVAILABLE","transformAuthData","provider","providerData","fieldName","type","untransformObjectACL","output","getRootFieldName","split","relationSchema","relatedId","owningId","convertEmailToLowercase","toLowerCase","convertUsernameToLowercase","DatabaseController","constructor","adapter","idempotencyOptions","schemaPromise","_transactionalSession","collectionExists","classExists","purgeCollection","loadSchema","then","schemaController","getOneSchema","deleteObjectsByQuery","validateClassName","classNameIsValid","Promise","reject","INVALID_CLASS_NAME","resolve","clearCache","load","loadSchemaIfNeeded","redirectClassNameForKey","getExpectedType","targetClass","validateObject","runOptions","maintenance","s","canAddField","many","upsert","addsField","skipSanitization","validateOnly","validSchemaController","Utils","checkProhibitedKeywords","error","validateFileUrlsInObject","FILE_SAVE_ERROR","message","originalQuery","originalUpdate","structuredClone","relationUpdates","validatePermission","collectRelationUpdates","addPointerPermissions","catch","rootFieldName","fieldNameIsValid","updateOperation","innerKey","INVALID_NESTED_KEY","find","readPreference","OBJECT_NOT_FOUND","updateObjectsByQuery","upsertOneObject","findOneAndUpdate","handleRelationUpdates","matchedCount","modifiedCount","_sanitizeDatabaseResult","ops","deleteMe","process","op","x","pending","addRelation","removeRelation","all","fromClassName","fromId","toId","doc","code","destroy","parseFormatSchema","create","originalObject","createdAt","iso","__type","updatedAt","enforceClassExists","createObject","convertSchemaToAdapterSchema","classSchema","schemaData","schemaFields","newKeys","field","action","deleteEverything","fast","SchemaCache","clear","deleteAllClasses","relatedIds","queryOptions","skip","limit","sort","findOptions","canSortOnJoinTables","_id","results","owningIds","reduceInRelation","promises","ors","aQuery","index","ands","otherKeys","queries","constraintKey","isNegation","q","ids","addNotInObjectIdsIds","addInObjectIdsIds","reduceRelationKeys","relatedTo","idsFromString","idsFromEq","idsFromIn","allIds","list","totalLength","reduce","memo","idsIntersection","intersect","big","$eq","idsFromNin","Set","$nin","count","distinct","pipeline","hint","caseInsensitive","explain","comment","rawValues","rawFieldNames","_created_at","_updated_at","enableCollationCaseComparison","addProtectedFields","aggregate","detailedMessage","createSanitizedError","INTERNAL_SERVER_ERROR","deleteSchema","deleteClass","wasParseCollection","relationFieldNames","name","del","reloadData","objectToEntriesStrings","entries","a","JSON","stringify","join","reduceOrOperation","repeat","j","shorter","longer","foundEntries","acc","shorterEntries","splice","reduceAndOperation","testPermissionsForClassName","userACL","groupKey","permFields","pointerFields","userPointer","fieldDescriptor","fieldType","prototype","queryClause","$all","assign","preserveKeys","serverOnlyKeys","authenticated","roles","userRoles","protectedKeysSets","protectedKeys","next","createTransactionalSession","transactionalSession","commitTransactionalSession","abortTransactionalSession","performInitialization","VolatileClassesSchemas","requiredUserFields","defaultColumns","_Default","_User","requiredRoleFields","_Role","requiredIdempotencyFields","_Idempotency","databaseOptions","createIndexUserUsername","ensureUniqueness","logger","warn","createIndexUserUsernameCaseInsensitive","ensureIndex","createIndexUserEmailCaseInsensitive","createIndexUserEmail","createIndexUserEmailVerifyToken","createIndexUserPasswordResetToken","createIndexRoleName","isMongoAdapter","MongoStorageAdapter","isPostgresAdapter","PostgresStorageAdapter","ttl","setIdempotencyFunction","createIndexAuthDataUniqueness","ensureAuthDataUniqueness","authProviders","enableAnonymousUsers","updateSchemaWithIndexes","_expandResultOnKeyPath","path","firstKey","nextPath","slice","requestKeywordDenylist","keyword","objectContainsKeyValue","response","keyUpdate","isArrayIndex","from","every","c","module","exports","_validateQuery"],"sources":["../../src/Controllers/DatabaseController.js"],"sourcesContent":["﻿// @flow\n// A database adapter that works with data exported from the hosted\n// Parse database.\n\n// @flow-disable-next\nimport { Parse } from 'parse/node';\n// @flow-disable-next\nimport _ from 'lodash';\n// @flow-disable-next\nimport intersect from 'intersect';\nimport logger from '../logger';\nimport Utils from '../Utils';\nimport * as SchemaController from './SchemaController';\nimport { StorageAdapter } from '../Adapters/Storage/StorageAdapter';\nimport MongoStorageAdapter from '../Adapters/Storage/Mongo/MongoStorageAdapter';\nimport PostgresStorageAdapter from '../Adapters/Storage/Postgres/PostgresStorageAdapter';\nimport SchemaCache from '../Adapters/Cache/SchemaCache';\nimport type { LoadSchemaOptions } from './types';\nimport type { ParseServerOptions } from '../Options';\nimport type { QueryOptions, FullQueryOptions } from '../Adapters/Storage/StorageAdapter';\nimport { createSanitizedError } from '../Error';\n\n// Query operators that always pass validation regardless of auth level.\nconst queryOperators = ['$and', '$or', '$nor'];\n\n// Registry of internal fields with access permissions.\n// Internal fields are never directly writable by clients, so clientWrite is omitted.\n// - clientRead: any client can use this field in queries\n// - masterRead: master key can use this field in queries\n// - masterWrite: master key can use this field in updates\nconst internalFields = {\n  _rperm:                         { clientRead: true,  masterRead: true,  masterWrite: true  },\n  _wperm:                         { clientRead: true,  masterRead: true,  masterWrite: true  },\n  _hashed_password:               { clientRead: false, masterRead: false, masterWrite: true  },\n  _email_verify_token:            { clientRead: false, masterRead: true,  masterWrite: true  },\n  _perishable_token:              { clientRead: false, masterRead: true,  masterWrite: true  },\n  _perishable_token_expires_at:   { clientRead: false, masterRead: true,  masterWrite: true  },\n  _email_verify_token_expires_at: { clientRead: false, masterRead: true,  masterWrite: true  },\n  _failed_login_count:            { clientRead: false, masterRead: true,  masterWrite: true  },\n  _account_lockout_expires_at:    { clientRead: false, masterRead: true,  masterWrite: true  },\n  _password_changed_at:           { clientRead: false, masterRead: true,  masterWrite: true  },\n  _password_history:              { clientRead: false, masterRead: true,  masterWrite: true  },\n  _tombstone:                     { clientRead: false, masterRead: true,  masterWrite: false },\n  _session_token:                 { clientRead: false, masterRead: true,  masterWrite: false },\n  /////////////////////////////////////////////////////////////////////////////////////////////\n  // The following fields are not accessed by their _-prefixed name through the API;\n  // they are mapped to REST-level names in the adapter layer or handled through\n  // separate code paths.\n  /////////////////////////////////////////////////////////////////////////////////////////////\n  // System fields (mapped to REST-level names):\n  // _id (objectId)\n  // _created_at (createdAt)\n  // _updated_at (updatedAt)\n  // _last_used (lastUsed)\n  // _expiresAt (expiresAt)\n  /////////////////////////////////////////////////////////////////////////////////////////////\n  // Legacy ACL format: mapped to/from _rperm/_wperm\n  // _acl\n  /////////////////////////////////////////////////////////////////////////////////////////////\n  // Schema metadata: not data fields, used only for schema configuration\n  // _metadata\n  // _client_permissions\n  /////////////////////////////////////////////////////////////////////////////////////////////\n  // Dynamic auth data fields: used only in projections and updates, not in queries\n  // _auth_data_<provider>\n};\n\n// Derived access lists\nconst specialQueryKeys = [\n  ...queryOperators,\n  ...Object.keys(internalFields).filter(k => internalFields[k].clientRead),\n];\nconst specialMasterQueryKeys = [\n  ...queryOperators,\n  ...Object.keys(internalFields).filter(k => internalFields[k].masterRead),\n];\n\nfunction addWriteACL(query, acl) {\n  const newQuery = _.cloneDeep(query);\n  //Can't be any existing '_wperm' query, we don't allow client queries on that, no need to $and\n  newQuery._wperm = { $in: [null, ...acl] };\n  return newQuery;\n}\n\nfunction addReadACL(query, acl) {\n  const newQuery = _.cloneDeep(query);\n  //Can't be any existing '_rperm' query, we don't allow client queries on that, no need to $and\n  newQuery._rperm = { $in: [null, '*', ...acl] };\n  return newQuery;\n}\n\n// Transforms a REST API formatted ACL object to our two-field mongo format.\nconst transformObjectACL = ({ ACL, ...result }) => {\n  if (!ACL) {\n    return result;\n  }\n\n  result._wperm = [];\n  result._rperm = [];\n\n  for (const entry in ACL) {\n    if (ACL[entry].read) {\n      result._rperm.push(entry);\n    }\n    if (ACL[entry].write) {\n      result._wperm.push(entry);\n    }\n  }\n  return result;\n};\n\nconst validateQuery = (\n  query: any,\n  isMaster: boolean,\n  isMaintenance: boolean,\n  update: boolean,\n  options: ?ParseServerOptions,\n  _depth: number = 0\n): void => {\n  if (isMaintenance) {\n    isMaster = true;\n  }\n  const rc = options?.requestComplexity;\n  if (!isMaster && rc && rc.queryDepth !== -1 && _depth > rc.queryDepth) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_QUERY,\n      `Query condition nesting depth exceeds maximum allowed depth of ${rc.queryDepth}`\n    );\n  }\n  if (query.ACL) {\n    throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Cannot query on ACL.');\n  }\n\n  if (query.$or) {\n    if (Array.isArray(query.$or)) {\n      query.$or.forEach(value => validateQuery(value, isMaster, isMaintenance, update, options, _depth + 1));\n    } else {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Bad $or format - use an array value.');\n    }\n  }\n\n  if (query.$and) {\n    if (Array.isArray(query.$and)) {\n      query.$and.forEach(value => validateQuery(value, isMaster, isMaintenance, update, options, _depth + 1));\n    } else {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Bad $and format - use an array value.');\n    }\n  }\n\n  if (query.$nor) {\n    if (Array.isArray(query.$nor) && query.$nor.length > 0) {\n      query.$nor.forEach(value => validateQuery(value, isMaster, isMaintenance, update, options, _depth + 1));\n    } else {\n      throw new Parse.Error(\n        Parse.Error.INVALID_QUERY,\n        'Bad $nor format - use an array of at least 1 value.'\n      );\n    }\n  }\n\n  Object.keys(query).forEach(key => {\n    if (query && query[key] && query[key].$regex !== undefined) {\n      if (!isMaster && rc && rc.allowRegex === false) {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, '$regex operator is not allowed');\n      }\n      if (typeof query[key].$regex !== 'string') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, '$regex value must be a string');\n      }\n      if (query[key].$options !== undefined && typeof query[key].$options !== 'string') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, '$options value must be a string');\n      }\n      if (typeof query[key].$options === 'string') {\n        if (!query[key].$options.match(/^[imxsu]+$/)) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_QUERY,\n            `Bad $options value for query: ${query[key].$options}`\n          );\n        }\n      }\n    }\n    if (\n      !key.match(/^[a-zA-Z][a-zA-Z0-9_\\.]*$/) &&\n      !specialQueryKeys.includes(key) &&\n      !(isMaster && specialMasterQueryKeys.includes(key))\n    ) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid key name: ${key}`);\n    }\n  });\n};\n\n// Filters out any data that shouldn't be on this REST-formatted object.\nconst filterSensitiveData = (\n  isMaster: boolean,\n  isMaintenance: boolean,\n  aclGroup: any[],\n  auth: any,\n  operation: any,\n  schema: SchemaController.SchemaController | any,\n  className: string,\n  protectedFields: null | Array<any>,\n  object: any,\n  protectedFieldsOwnerExempt: ?boolean\n) => {\n  let userId = null;\n  if (auth && auth.user) { userId = auth.user.id; }\n\n  // replace protectedFields when using pointer-permissions\n  const perms =\n    schema && schema.getClassLevelPermissions ? schema.getClassLevelPermissions(className) : {};\n  if (perms) {\n    const isReadOperation = ['get', 'find'].indexOf(operation) > -1;\n\n    if (isReadOperation && perms.protectedFields) {\n      // extract protectedFields added with the pointer-permission prefix\n      const protectedFieldsPointerPerm = Object.keys(perms.protectedFields)\n        .filter(key => key.startsWith('userField:'))\n        .map(key => {\n          return { key: key.substring(10), value: perms.protectedFields[key] };\n        });\n\n      const newProtectedFields: Array<string>[] = [];\n      let overrideProtectedFields = false;\n\n      // check if the object grants the current user access based on the extracted fields\n      protectedFieldsPointerPerm.forEach(pointerPerm => {\n        let pointerPermIncludesUser = false;\n        const readUserFieldValue = object[pointerPerm.key];\n        if (readUserFieldValue) {\n          if (Array.isArray(readUserFieldValue)) {\n            pointerPermIncludesUser = readUserFieldValue.some(\n              user => user.objectId && user.objectId === userId\n            );\n          } else {\n            pointerPermIncludesUser =\n              readUserFieldValue.objectId && readUserFieldValue.objectId === userId;\n          }\n        }\n\n        if (pointerPermIncludesUser) {\n          overrideProtectedFields = true;\n          newProtectedFields.push(pointerPerm.value);\n        }\n      });\n\n      // if at least one pointer-permission affected the current user\n      // intersect vs protectedFields from previous stage (@see addProtectedFields)\n      // Sets theory (intersections): A x (B x C) == (A x B) x C\n      if (overrideProtectedFields && protectedFields) {\n        newProtectedFields.push(protectedFields);\n      }\n      // intersect all sets of protectedFields\n      newProtectedFields.forEach(fields => {\n        if (fields) {\n          // if there're no protctedFields by other criteria ( id / role / auth)\n          // then we must intersect each set (per userField)\n          if (!protectedFields) {\n            protectedFields = fields;\n          } else {\n            protectedFields = protectedFields.filter(v => fields.includes(v));\n          }\n        }\n      });\n    }\n  }\n\n  const isUserClass = className === '_User';\n  if (isUserClass) {\n    object.password = object._hashed_password;\n    delete object._hashed_password;\n    delete object.sessionToken;\n  }\n\n  if (isMaintenance) {\n    return object;\n  }\n\n  /* special treat for the user class: don't filter protectedFields if currently loggedin user is\n  the retrieved user, unless protectedFieldsOwnerExempt is false */\n  const isOwnerExempt = protectedFieldsOwnerExempt !== false && isUserClass && userId && object.objectId === userId;\n  if (!isOwnerExempt) {\n    protectedFields && protectedFields.forEach(k => delete object[k]);\n\n    // fields not requested by client (excluded),\n    // but were needed to apply protectedFields\n    perms?.protectedFields?.temporaryKeys?.forEach(k => delete object[k]);\n  }\n\n  for (const key in object) {\n    if (key.charAt(0) === '_') {\n      delete object[key];\n    }\n  }\n\n  if (!isUserClass || isMaster) {\n    return object;\n  }\n\n  if (aclGroup.indexOf(object.objectId) > -1) {\n    return object;\n  }\n  delete object.authData;\n  return object;\n};\n\n// Runs an update on the database.\n// Returns a promise for an object with the new values for field\n// modifications that don't know their results ahead of time, like\n// 'increment'.\n// Options:\n//   acl:  a list of strings. If the object to be updated has an ACL,\n//         one of the provided strings must provide the caller with\n//         write permissions.\nconst specialKeysForUpdate = Object.keys(internalFields).filter(k => internalFields[k].masterWrite);\n\nconst isSpecialUpdateKey = key => {\n  return specialKeysForUpdate.indexOf(key) >= 0;\n};\n\nfunction joinTableName(className, key) {\n  return `_Join:${key}:${className}`;\n}\n\nconst flattenUpdateOperatorsForCreate = object => {\n  for (const key in object) {\n    if (object[key] && object[key].__op) {\n      switch (object[key].__op) {\n        case 'Increment':\n          if (typeof object[key].amount !== 'number') {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n          }\n          object[key] = object[key].amount;\n          break;\n        case 'SetOnInsert':\n          object[key] = object[key].amount;\n          break;\n        case 'Add':\n          if (!Array.isArray(object[key].objects)) {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n          }\n          object[key] = object[key].objects;\n          break;\n        case 'AddUnique':\n          if (!Array.isArray(object[key].objects)) {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n          }\n          object[key] = object[key].objects;\n          break;\n        case 'Remove':\n          if (!Array.isArray(object[key].objects)) {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n          }\n          object[key] = [];\n          break;\n        case 'Delete':\n          delete object[key];\n          break;\n        default:\n          throw new Parse.Error(\n            Parse.Error.COMMAND_UNAVAILABLE,\n            `The ${object[key].__op} operator is not supported yet.`\n          );\n      }\n    }\n  }\n};\n\nconst transformAuthData = (className, object, schema) => {\n  if (object.authData && className === '_User') {\n    Object.keys(object.authData).forEach(provider => {\n      const providerData = object.authData[provider];\n      const fieldName = `_auth_data_${provider}`;\n      if (providerData == null) {\n        object[fieldName] = {\n          __op: 'Delete',\n        };\n      } else {\n        object[fieldName] = providerData;\n        schema.fields[fieldName] = { type: 'Object' };\n      }\n    });\n    delete object.authData;\n  }\n};\n// Transforms a Database format ACL to a REST API format ACL\nconst untransformObjectACL = ({ _rperm, _wperm, ...output }) => {\n  if (_rperm || _wperm) {\n    output.ACL = {};\n\n    (_rperm || []).forEach(entry => {\n      if (!output.ACL[entry]) {\n        output.ACL[entry] = { read: true };\n      } else {\n        output.ACL[entry]['read'] = true;\n      }\n    });\n\n    (_wperm || []).forEach(entry => {\n      if (!output.ACL[entry]) {\n        output.ACL[entry] = { write: true };\n      } else {\n        output.ACL[entry]['write'] = true;\n      }\n    });\n  }\n  return output;\n};\n\n/**\n * When querying, the fieldName may be compound, extract the root fieldName\n *     `temperature.celsius` becomes `temperature`\n * @param {string} fieldName that may be a compound field name\n * @returns {string} the root name of the field\n */\nconst getRootFieldName = (fieldName: string): string => {\n  return fieldName.split('.')[0];\n};\n\nconst relationSchema = {\n  fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } },\n};\n\nconst convertEmailToLowercase = (object, className, options) => {\n  if (className === '_User' && options.convertEmailToLowercase) {\n    if (typeof object['email'] === 'string') {\n      object['email'] = object['email'].toLowerCase();\n    }\n  }\n};\n\nconst convertUsernameToLowercase = (object, className, options) => {\n  if (className === '_User' && options.convertUsernameToLowercase) {\n    if (typeof object['username'] === 'string') {\n      object['username'] = object['username'].toLowerCase();\n    }\n  }\n};\n\nclass DatabaseController {\n  adapter: StorageAdapter;\n  schemaCache: any;\n  schemaPromise: ?Promise<SchemaController.SchemaController>;\n  _transactionalSession: ?any;\n  options: ParseServerOptions;\n  idempotencyOptions: any;\n\n  constructor(adapter: StorageAdapter, options: ParseServerOptions) {\n    this.adapter = adapter;\n    this.options = options || {};\n    this.idempotencyOptions = this.options.idempotencyOptions || {};\n    // Prevent mutable this.schema, otherwise one request could use\n    // multiple schemas, so instead use loadSchema to get a schema.\n    this.schemaPromise = null;\n    this._transactionalSession = null;\n    this.options = options;\n  }\n\n  collectionExists(className: string): Promise<boolean> {\n    return this.adapter.classExists(className);\n  }\n\n  purgeCollection(className: string): Promise<void> {\n    return this.loadSchema()\n      .then(schemaController => schemaController.getOneSchema(className))\n      .then(schema => this.adapter.deleteObjectsByQuery(className, schema, {}));\n  }\n\n  validateClassName(className: string): Promise<void> {\n    if (!SchemaController.classNameIsValid(className)) {\n      return Promise.reject(\n        new Parse.Error(Parse.Error.INVALID_CLASS_NAME, 'invalid className: ' + className)\n      );\n    }\n    return Promise.resolve();\n  }\n\n  // Returns a promise for a schemaController.\n  loadSchema(\n    options: LoadSchemaOptions = { clearCache: false }\n  ): Promise<SchemaController.SchemaController> {\n    if (this.schemaPromise != null) {\n      return this.schemaPromise;\n    }\n    this.schemaPromise = SchemaController.load(this.adapter, options);\n    this.schemaPromise.then(\n      () => delete this.schemaPromise,\n      () => delete this.schemaPromise\n    );\n    return this.loadSchema(options);\n  }\n\n  loadSchemaIfNeeded(\n    schemaController: SchemaController.SchemaController,\n    options: LoadSchemaOptions = { clearCache: false }\n  ): Promise<SchemaController.SchemaController> {\n    return schemaController ? Promise.resolve(schemaController) : this.loadSchema(options);\n  }\n\n  // Returns a promise for the classname that is related to the given\n  // classname through the key.\n  // TODO: make this not in the DatabaseController interface\n  redirectClassNameForKey(className: string, key: string): Promise<?string> {\n    return this.loadSchema().then(schema => {\n      var t = schema.getExpectedType(className, key);\n      if (t != null && typeof t !== 'string' && t.type === 'Relation') {\n        return t.targetClass;\n      }\n      return className;\n    });\n  }\n\n  // Uses the schema to validate the object (REST API format).\n  // Returns a promise that resolves to the new schema.\n  // This does not update this.schema, because in a situation like a\n  // batch request, that could confuse other users of the schema.\n  validateObject(\n    className: string,\n    object: any,\n    query: any,\n    runOptions: QueryOptions,\n    maintenance: boolean\n  ): Promise<boolean> {\n    let schema;\n    const acl = runOptions.acl;\n    const isMaster = acl === undefined;\n    var aclGroup: string[] = acl || [];\n    return this.loadSchema()\n      .then(s => {\n        schema = s;\n        if (isMaster) {\n          return Promise.resolve();\n        }\n        return this.canAddField(schema, className, object, aclGroup, runOptions);\n      })\n      .then(() => {\n        return schema.validateObject(className, object, query, maintenance);\n      });\n  }\n\n  /**\n   * Updates objects in the database that match the given query.\n   * @param {Object} options\n   * @param {boolean} [options.many=false] When true, updates all matching documents\n   *   and returns `{ matchedCount, modifiedCount }` where values are numbers if the\n   *   storage adapter supports `UpdateManyResult`, or `undefined` otherwise.\n   */\n  update(\n    className: string,\n    query: any,\n    update: any,\n    { acl, many, upsert, addsField }: FullQueryOptions = {},\n    skipSanitization: boolean = false,\n    validateOnly: boolean = false,\n    validSchemaController: SchemaController.SchemaController\n  ): Promise<any> {\n    try {\n      Utils.checkProhibitedKeywords(this.options, update);\n    } catch (error) {\n      return Promise.reject(new Parse.Error(Parse.Error.INVALID_KEY_NAME, `${error}`));\n    }\n    try {\n      const { validateFileUrlsInObject } = require('../FileUrlValidator');\n      validateFileUrlsInObject(update, this.options);\n    } catch (error) {\n      return Promise.reject(error instanceof Parse.Error ? error : new Parse.Error(Parse.Error.FILE_SAVE_ERROR, error.message || error));\n    }\n    const originalQuery = query;\n    const originalUpdate = update;\n    // Make a copy of the object, so we don't mutate the incoming data.\n    update = structuredClone(update);\n    var relationUpdates = [];\n    var isMaster = acl === undefined;\n    var aclGroup = acl || [];\n\n    return this.loadSchemaIfNeeded(validSchemaController).then(schemaController => {\n      return (isMaster\n        ? Promise.resolve()\n        : schemaController.validatePermission(className, aclGroup, 'update')\n      )\n        .then(() => {\n          relationUpdates = this.collectRelationUpdates(className, originalQuery.objectId, update);\n          if (!isMaster) {\n            query = this.addPointerPermissions(\n              schemaController,\n              className,\n              'update',\n              query,\n              aclGroup\n            );\n\n            if (addsField) {\n              query = {\n                $and: [\n                  query,\n                  this.addPointerPermissions(\n                    schemaController,\n                    className,\n                    'addField',\n                    query,\n                    aclGroup\n                  ),\n                ],\n              };\n            }\n          }\n          if (!query) {\n            return Promise.resolve();\n          }\n          if (acl) {\n            query = addWriteACL(query, acl);\n          }\n          validateQuery(query, isMaster, false, true, this.options);\n          return schemaController\n            .getOneSchema(className, true)\n            .catch(error => {\n              // If the schema doesn't exist, pretend it exists with no fields. This behavior\n              // will likely need revisiting.\n              if (error === undefined) {\n                return { fields: {} };\n              }\n              throw error;\n            })\n            .then(schema => {\n              Object.keys(update).forEach(fieldName => {\n                if (fieldName.match(/^authData\\./)) {\n                  throw new Parse.Error(\n                    Parse.Error.INVALID_KEY_NAME,\n                    `Invalid field name for update: ${fieldName}`\n                  );\n                }\n                const rootFieldName = getRootFieldName(fieldName);\n                if (\n                  !SchemaController.fieldNameIsValid(rootFieldName, className) &&\n                  !isSpecialUpdateKey(rootFieldName)\n                ) {\n                  throw new Parse.Error(\n                    Parse.Error.INVALID_KEY_NAME,\n                    `Invalid field name for update: ${fieldName}`\n                  );\n                }\n              });\n              for (const updateOperation in update) {\n                if (\n                  update[updateOperation] &&\n                  typeof update[updateOperation] === 'object' &&\n                  Object.keys(update[updateOperation]).some(\n                    innerKey => innerKey.includes('$') || innerKey.includes('.')\n                  )\n                ) {\n                  throw new Parse.Error(\n                    Parse.Error.INVALID_NESTED_KEY,\n                    \"Nested keys should not contain the '$' or '.' characters\"\n                  );\n                }\n              }\n              update = transformObjectACL(update);\n              convertEmailToLowercase(update, className, this.options);\n              convertUsernameToLowercase(update, className, this.options);\n              transformAuthData(className, update, schema);\n              if (validateOnly) {\n                return this.adapter.find(className, schema, query, { readPreference: 'primary' }).then(result => {\n                  if (!result || !result.length) {\n                    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n                  }\n                  return {};\n                });\n              }\n              if (many) {\n                return this.adapter.updateObjectsByQuery(\n                  className,\n                  schema,\n                  query,\n                  update,\n                  this._transactionalSession\n                );\n              } else if (upsert) {\n                return this.adapter.upsertOneObject(\n                  className,\n                  schema,\n                  query,\n                  update,\n                  this._transactionalSession\n                );\n              } else {\n                return this.adapter.findOneAndUpdate(\n                  className,\n                  schema,\n                  query,\n                  update,\n                  this._transactionalSession\n                );\n              }\n            });\n        })\n        .then((result: any) => {\n          if (!result) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n          }\n          if (validateOnly) {\n            return result;\n          }\n          return this.handleRelationUpdates(\n            className,\n            originalQuery.objectId,\n            update,\n            relationUpdates\n          ).then(() => {\n            return result;\n          });\n        })\n        .then(result => {\n          if (skipSanitization) {\n            return Promise.resolve(result);\n          }\n          if (many) {\n            return {\n              matchedCount: typeof result?.matchedCount === 'number'\n                ? result.matchedCount\n                : undefined,\n              modifiedCount: typeof result?.modifiedCount === 'number'\n                ? result.modifiedCount\n                : undefined,\n            };\n          }\n          return this._sanitizeDatabaseResult(originalUpdate, result);\n        });\n    });\n  }\n\n  // Collect all relation-updating operations from a REST-format update.\n  // Returns a list of all relation updates to perform\n  // This mutates update.\n  collectRelationUpdates(className: string, objectId: ?string, update: any) {\n    var ops = [];\n    var deleteMe = [];\n    objectId = update.objectId || objectId;\n\n    var process = (op, key) => {\n      if (!op) {\n        return;\n      }\n      if (op.__op == 'AddRelation') {\n        ops.push({ key, op });\n        deleteMe.push(key);\n      }\n\n      if (op.__op == 'RemoveRelation') {\n        ops.push({ key, op });\n        deleteMe.push(key);\n      }\n\n      if (op.__op == 'Batch') {\n        for (var x of op.ops) {\n          process(x, key);\n        }\n      }\n    };\n\n    for (const key in update) {\n      process(update[key], key);\n    }\n    for (const key of deleteMe) {\n      delete update[key];\n    }\n    return ops;\n  }\n\n  // Processes relation-updating operations from a REST-format update.\n  // Returns a promise that resolves when all updates have been performed\n  handleRelationUpdates(className: string, objectId: string, update: any, ops: any) {\n    var pending = [];\n    objectId = update.objectId || objectId;\n    ops.forEach(({ key, op }) => {\n      if (!op) {\n        return;\n      }\n      if (op.__op == 'AddRelation') {\n        for (const object of op.objects) {\n          pending.push(this.addRelation(key, className, objectId, object.objectId));\n        }\n      }\n\n      if (op.__op == 'RemoveRelation') {\n        for (const object of op.objects) {\n          pending.push(this.removeRelation(key, className, objectId, object.objectId));\n        }\n      }\n    });\n\n    return Promise.all(pending);\n  }\n\n  // Adds a relation.\n  // Returns a promise that resolves successfully iff the add was successful.\n  addRelation(key: string, fromClassName: string, fromId: string, toId: string) {\n    const doc = {\n      relatedId: toId,\n      owningId: fromId,\n    };\n    return this.adapter.upsertOneObject(\n      `_Join:${key}:${fromClassName}`,\n      relationSchema,\n      doc,\n      doc,\n      this._transactionalSession\n    );\n  }\n\n  // Removes a relation.\n  // Returns a promise that resolves successfully iff the remove was\n  // successful.\n  removeRelation(key: string, fromClassName: string, fromId: string, toId: string) {\n    var doc = {\n      relatedId: toId,\n      owningId: fromId,\n    };\n    return this.adapter\n      .deleteObjectsByQuery(\n        `_Join:${key}:${fromClassName}`,\n        relationSchema,\n        doc,\n        this._transactionalSession\n      )\n      .catch(error => {\n        // We don't care if they try to delete a non-existent relation.\n        if (error.code == Parse.Error.OBJECT_NOT_FOUND) {\n          return;\n        }\n        throw error;\n      });\n  }\n\n  // Removes objects matches this query from the database.\n  // Returns a promise that resolves successfully iff the object was\n  // deleted.\n  // Options:\n  //   acl:  a list of strings. If the object to be updated has an ACL,\n  //         one of the provided strings must provide the caller with\n  //         write permissions.\n  destroy(\n    className: string,\n    query: any,\n    { acl }: QueryOptions = {},\n    validSchemaController: SchemaController.SchemaController\n  ): Promise<any> {\n    const isMaster = acl === undefined;\n    const aclGroup = acl || [];\n\n    return this.loadSchemaIfNeeded(validSchemaController).then(schemaController => {\n      return (isMaster\n        ? Promise.resolve()\n        : schemaController.validatePermission(className, aclGroup, 'delete')\n      ).then(() => {\n        if (!isMaster) {\n          query = this.addPointerPermissions(\n            schemaController,\n            className,\n            'delete',\n            query,\n            aclGroup\n          );\n          if (!query) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n          }\n        }\n        // delete by query\n        if (acl) {\n          query = addWriteACL(query, acl);\n        }\n        validateQuery(query, isMaster, false, false, this.options);\n        return schemaController\n          .getOneSchema(className)\n          .catch(error => {\n            // If the schema doesn't exist, pretend it exists with no fields. This behavior\n            // will likely need revisiting.\n            if (error === undefined) {\n              return { fields: {} };\n            }\n            throw error;\n          })\n          .then(parseFormatSchema =>\n            this.adapter.deleteObjectsByQuery(\n              className,\n              parseFormatSchema,\n              query,\n              this._transactionalSession\n            )\n          )\n          .catch(error => {\n            // When deleting sessions while changing passwords, don't throw an error if they don't have any sessions.\n            if (className === '_Session' && error.code === Parse.Error.OBJECT_NOT_FOUND) {\n              return Promise.resolve({});\n            }\n            throw error;\n          });\n      });\n    });\n  }\n\n  // Inserts an object into the database.\n  // Returns a promise that resolves successfully iff the object saved.\n  create(\n    className: string,\n    object: any,\n    { acl }: QueryOptions = {},\n    validateOnly: boolean = false,\n    validSchemaController: SchemaController.SchemaController\n  ): Promise<any> {\n    try {\n      Utils.checkProhibitedKeywords(this.options, object);\n    } catch (error) {\n      return Promise.reject(new Parse.Error(Parse.Error.INVALID_KEY_NAME, `${error}`));\n    }\n    try {\n      const { validateFileUrlsInObject } = require('../FileUrlValidator');\n      validateFileUrlsInObject(object, this.options);\n    } catch (error) {\n      return Promise.reject(error instanceof Parse.Error ? error : new Parse.Error(Parse.Error.FILE_SAVE_ERROR, error.message || error));\n    }\n    // Make a copy of the object, so we don't mutate the incoming data.\n    const originalObject = object;\n    object = transformObjectACL(object);\n\n    convertEmailToLowercase(object, className, this.options);\n    convertUsernameToLowercase(object, className, this.options);\n    object.createdAt = { iso: object.createdAt, __type: 'Date' };\n    object.updatedAt = { iso: object.updatedAt, __type: 'Date' };\n\n    var isMaster = acl === undefined;\n    var aclGroup = acl || [];\n    const relationUpdates = this.collectRelationUpdates(className, null, object);\n\n    return this.validateClassName(className)\n      .then(() => this.loadSchemaIfNeeded(validSchemaController))\n      .then(schemaController => {\n        return (isMaster\n          ? Promise.resolve()\n          : schemaController.validatePermission(className, aclGroup, 'create')\n        )\n          .then(() => schemaController.enforceClassExists(className))\n          .then(() => schemaController.getOneSchema(className, true))\n          .then(schema => {\n            transformAuthData(className, object, schema);\n            flattenUpdateOperatorsForCreate(object);\n            if (validateOnly) {\n              return {};\n            }\n            return this.adapter.createObject(\n              className,\n              SchemaController.convertSchemaToAdapterSchema(schema),\n              object,\n              this._transactionalSession\n            );\n          })\n          .then(result => {\n            if (validateOnly) {\n              return originalObject;\n            }\n            return this.handleRelationUpdates(\n              className,\n              object.objectId,\n              object,\n              relationUpdates\n            ).then(() => {\n              return this._sanitizeDatabaseResult(originalObject, result.ops[0]);\n            });\n          });\n      });\n  }\n\n  canAddField(\n    schema: SchemaController.SchemaController,\n    className: string,\n    object: any,\n    aclGroup: string[],\n    runOptions: QueryOptions\n  ): Promise<void> {\n    const classSchema = schema.schemaData[className];\n    if (!classSchema) {\n      return Promise.resolve();\n    }\n    const fields = Object.keys(object);\n    const schemaFields = Object.keys(classSchema.fields);\n    const newKeys = fields.filter(field => {\n      // Skip fields that are unset\n      if (object[field] && object[field].__op && object[field].__op === 'Delete') {\n        return false;\n      }\n      return schemaFields.indexOf(getRootFieldName(field)) < 0;\n    });\n    if (newKeys.length > 0) {\n      // adds a marker that new field is being adding during update\n      runOptions.addsField = true;\n\n      const action = runOptions.action;\n      return schema.validatePermission(className, aclGroup, 'addField', action);\n    }\n    return Promise.resolve();\n  }\n\n  // Won't delete collections in the system namespace\n  /**\n   * Delete all classes and clears the schema cache\n   *\n   * @param {boolean} fast set to true if it's ok to just delete rows and not indexes\n   * @returns {Promise<void>} when the deletions completes\n   */\n  deleteEverything(fast: boolean = false): Promise<any> {\n    this.schemaPromise = null;\n    SchemaCache.clear();\n    return this.adapter.deleteAllClasses(fast);\n  }\n\n  // Returns a promise for a list of related ids given an owning id.\n  // className here is the owning className.\n  relatedIds(\n    className: string,\n    key: string,\n    owningId: string,\n    queryOptions: QueryOptions\n  ): Promise<Array<string>> {\n    const { skip, limit, sort } = queryOptions;\n    const findOptions = {};\n    if (sort && sort.createdAt && this.adapter.canSortOnJoinTables) {\n      findOptions.sort = { _id: sort.createdAt };\n      findOptions.limit = limit;\n      findOptions.skip = skip;\n      queryOptions.skip = 0;\n    }\n    return this.adapter\n      .find(joinTableName(className, key), relationSchema, { owningId }, findOptions)\n      .then(results => results.map(result => result.relatedId));\n  }\n\n  // Returns a promise for a list of owning ids given some related ids.\n  // className here is the owning className.\n  owningIds(className: string, key: string, relatedIds: string[]): Promise<string[]> {\n    return this.adapter\n      .find(\n        joinTableName(className, key),\n        relationSchema,\n        { relatedId: { $in: relatedIds } },\n        { keys: ['owningId'] }\n      )\n      .then(results => results.map(result => result.owningId));\n  }\n\n  // Modifies query so that it no longer has $in on relation fields, or\n  // equal-to-pointer constraints on relation fields.\n  // Returns a promise that resolves when query is mutated\n  reduceInRelation(className: string, query: any, schema: any): Promise<any> {\n    // Search for an in-relation or equal-to-relation\n    // Make it sequential for now, not sure of paralleization side effects\n    const promises = [];\n    if (query['$or']) {\n      const ors = query['$or'];\n      promises.push(\n        ...ors.map((aQuery, index) => {\n          return this.reduceInRelation(className, aQuery, schema).then(aQuery => {\n            query['$or'][index] = aQuery;\n          });\n        })\n      );\n    }\n    if (query['$and']) {\n      const ands = query['$and'];\n      promises.push(\n        ...ands.map((aQuery, index) => {\n          return this.reduceInRelation(className, aQuery, schema).then(aQuery => {\n            query['$and'][index] = aQuery;\n          });\n        })\n      );\n    }\n\n    const otherKeys = Object.keys(query).map(key => {\n      if (key === '$and' || key === '$or') {\n        return;\n      }\n      const t = schema.getExpectedType(className, key);\n      if (!t || t.type !== 'Relation') {\n        return Promise.resolve(query);\n      }\n      let queries: ?(any[]) = null;\n      if (\n        query[key] &&\n        (query[key]['$in'] ||\n          query[key]['$ne'] ||\n          query[key]['$nin'] ||\n          query[key].__type == 'Pointer')\n      ) {\n        // Build the list of queries\n        queries = Object.keys(query[key]).map(constraintKey => {\n          let relatedIds;\n          let isNegation = false;\n          if (constraintKey === 'objectId') {\n            relatedIds = [query[key].objectId];\n          } else if (constraintKey == '$in') {\n            relatedIds = query[key]['$in'].map(r => r.objectId);\n          } else if (constraintKey == '$nin') {\n            isNegation = true;\n            relatedIds = query[key]['$nin'].map(r => r.objectId);\n          } else if (constraintKey == '$ne') {\n            isNegation = true;\n            relatedIds = [query[key]['$ne'].objectId];\n          } else {\n            return;\n          }\n          return {\n            isNegation,\n            relatedIds,\n          };\n        });\n      } else {\n        queries = [{ isNegation: false, relatedIds: [] }];\n      }\n\n      // remove the current queryKey as we don,t need it anymore\n      delete query[key];\n      // execute each query independently to build the list of\n      // $in / $nin\n      const promises = queries.map(q => {\n        if (!q) {\n          return Promise.resolve();\n        }\n        return this.owningIds(className, key, q.relatedIds).then(ids => {\n          if (q.isNegation) {\n            this.addNotInObjectIdsIds(ids, query);\n          } else {\n            this.addInObjectIdsIds(ids, query);\n          }\n          return Promise.resolve();\n        });\n      });\n\n      return Promise.all(promises).then(() => {\n        return Promise.resolve();\n      });\n    });\n\n    return Promise.all([...promises, ...otherKeys]).then(() => {\n      return Promise.resolve(query);\n    });\n  }\n\n  // Modifies query so that it no longer has $relatedTo\n  // Returns a promise that resolves when query is mutated\n  reduceRelationKeys(className: string, query: any, queryOptions: any): ?Promise<void> {\n    if (query['$or']) {\n      return Promise.all(\n        query['$or'].map(aQuery => {\n          return this.reduceRelationKeys(className, aQuery, queryOptions);\n        })\n      );\n    }\n    if (query['$and']) {\n      return Promise.all(\n        query['$and'].map(aQuery => {\n          return this.reduceRelationKeys(className, aQuery, queryOptions);\n        })\n      );\n    }\n    var relatedTo = query['$relatedTo'];\n    if (relatedTo) {\n      return this.relatedIds(\n        relatedTo.object.className,\n        relatedTo.key,\n        relatedTo.object.objectId,\n        queryOptions\n      )\n        .then(ids => {\n          delete query['$relatedTo'];\n          this.addInObjectIdsIds(ids, query);\n          return this.reduceRelationKeys(className, query, queryOptions);\n        })\n        .then(() => {});\n    }\n  }\n\n  addInObjectIdsIds(ids: ?Array<string> = null, query: any) {\n    const idsFromString: ?Array<string> =\n      typeof query.objectId === 'string' ? [query.objectId] : null;\n    const idsFromEq: ?Array<string> =\n      query.objectId && query.objectId['$eq'] ? [query.objectId['$eq']] : null;\n    const idsFromIn: ?Array<string> =\n      query.objectId && query.objectId['$in'] ? query.objectId['$in'] : null;\n\n    // @flow-disable-next\n    const allIds: Array<Array<string>> = [idsFromString, idsFromEq, idsFromIn, ids].filter(\n      list => list !== null\n    );\n    const totalLength = allIds.reduce((memo, list) => memo + list.length, 0);\n\n    let idsIntersection = [];\n    if (totalLength > 125) {\n      idsIntersection = intersect.big(allIds);\n    } else {\n      idsIntersection = intersect(allIds);\n    }\n\n    // Need to make sure we don't clobber existing shorthand $eq constraints on objectId.\n    if (!('objectId' in query)) {\n      query.objectId = {\n        $in: undefined,\n      };\n    } else if (typeof query.objectId === 'string') {\n      query.objectId = {\n        $in: undefined,\n        $eq: query.objectId,\n      };\n    }\n    query.objectId['$in'] = idsIntersection;\n\n    return query;\n  }\n\n  addNotInObjectIdsIds(ids: string[] = [], query: any) {\n    const idsFromNin = query.objectId && query.objectId['$nin'] ? query.objectId['$nin'] : [];\n    let allIds = [...idsFromNin, ...ids].filter(list => list !== null);\n\n    // make a set and spread to remove duplicates\n    allIds = [...new Set(allIds)];\n\n    // Need to make sure we don't clobber existing shorthand $eq constraints on objectId.\n    if (!('objectId' in query)) {\n      query.objectId = {\n        $nin: undefined,\n      };\n    } else if (typeof query.objectId === 'string') {\n      query.objectId = {\n        $nin: undefined,\n        $eq: query.objectId,\n      };\n    }\n\n    query.objectId['$nin'] = allIds;\n    return query;\n  }\n\n  // Runs a query on the database.\n  // Returns a promise that resolves to a list of items.\n  // Options:\n  //   skip    number of results to skip.\n  //   limit   limit to this number of results.\n  //   sort    an object where keys are the fields to sort by.\n  //           the value is +1 for ascending, -1 for descending.\n  //   count   run a count instead of returning results.\n  //   acl     restrict this operation with an ACL for the provided array\n  //           of user objectIds and roles. acl: null means no user.\n  //           when this field is not present, don't do anything regarding ACLs.\n  //  caseInsensitive make string comparisons case insensitive\n  // TODO: make userIds not needed here. The db adapter shouldn't know\n  // anything about users, ideally. Then, improve the format of the ACL\n  // arg to work like the others.\n  find(\n    className: string,\n    query: any,\n    {\n      skip,\n      limit,\n      acl,\n      sort = {},\n      count,\n      keys,\n      op,\n      distinct,\n      pipeline,\n      readPreference,\n      hint,\n      caseInsensitive = false,\n      explain,\n      comment,\n      rawValues,\n      rawFieldNames,\n    }: any = {},\n    auth: any = {},\n    validSchemaController: SchemaController.SchemaController\n  ): Promise<any> {\n    const isMaintenance = auth.isMaintenance;\n    const isMaster = acl === undefined || isMaintenance;\n    const aclGroup = acl || [];\n    op =\n      op || (typeof query.objectId == 'string' && Object.keys(query).length === 1 ? 'get' : 'find');\n    // Count operation if counting\n    op = count === true ? 'count' : op;\n\n    let classExists = true;\n    return this.loadSchemaIfNeeded(validSchemaController).then(schemaController => {\n      //Allow volatile classes if querying with Master (for _PushStatus)\n      //TODO: Move volatile classes concept into mongo adapter, postgres adapter shouldn't care\n      //that api.parse.com breaks when _PushStatus exists in mongo.\n      return schemaController\n        .getOneSchema(className, isMaster)\n        .catch(error => {\n          // Behavior for non-existent classes is kinda weird on Parse.com. Probably doesn't matter too much.\n          // For now, pretend the class exists but has no objects,\n          if (error === undefined) {\n            classExists = false;\n            return { fields: {} };\n          }\n          throw error;\n        })\n        .then(schema => {\n          // Parse.com treats queries on _created_at and _updated_at as if they were queries on createdAt and updatedAt,\n          // so duplicate that behavior here. If both are specified, the correct behavior to match Parse.com is to\n          // use the one that appears first in the sort list.\n          if (sort._created_at) {\n            sort.createdAt = sort._created_at;\n            delete sort._created_at;\n          }\n          if (sort._updated_at) {\n            sort.updatedAt = sort._updated_at;\n            delete sort._updated_at;\n          }\n          const queryOptions = {\n            skip,\n            limit,\n            sort,\n            keys,\n            readPreference,\n            hint,\n            caseInsensitive: this.options.enableCollationCaseComparison ? false : caseInsensitive,\n            explain,\n            comment,\n          };\n          Object.keys(sort).forEach(fieldName => {\n            if (fieldName.match(/^authData\\.([a-zA-Z0-9_]+)\\.id$/)) {\n              throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Cannot sort by ${fieldName}`);\n            }\n            const rootFieldName = getRootFieldName(fieldName);\n            if (!SchemaController.fieldNameIsValid(rootFieldName, className)) {\n              throw new Parse.Error(\n                Parse.Error.INVALID_KEY_NAME,\n                `Invalid field name: ${fieldName}.`\n              );\n            }\n            if (!schema.fields[fieldName.split('.')[0]] && fieldName !== 'score') {\n              delete sort[fieldName];\n            }\n          });\n          return (isMaster\n            ? Promise.resolve()\n            : schemaController.validatePermission(className, aclGroup, op)\n          )\n            .then(() => this.reduceRelationKeys(className, query, queryOptions))\n            .then(() => this.reduceInRelation(className, query, schemaController))\n            .then(() => {\n              let protectedFields;\n              if (!isMaster) {\n                query = this.addPointerPermissions(\n                  schemaController,\n                  className,\n                  op,\n                  query,\n                  aclGroup\n                );\n                /* Don't use projections to optimize the protectedFields since the protectedFields\n                  based on pointer-permissions are determined after querying. The filtering can\n                  overwrite the protected fields. */\n                protectedFields = this.addProtectedFields(\n                  schemaController,\n                  className,\n                  query,\n                  aclGroup,\n                  auth,\n                  queryOptions\n                );\n              }\n              if (!query) {\n                if (op === 'get') {\n                  throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n                } else {\n                  return [];\n                }\n              }\n              if (!isMaster) {\n                if (op === 'update' || op === 'delete') {\n                  query = addWriteACL(query, aclGroup);\n                } else {\n                  query = addReadACL(query, aclGroup);\n                }\n              }\n              validateQuery(query, isMaster, isMaintenance, false, this.options);\n              if (count) {\n                if (!classExists) {\n                  return 0;\n                } else {\n                  return this.adapter.count(\n                    className,\n                    schema,\n                    query,\n                    readPreference,\n                    undefined,\n                    hint,\n                    comment\n                  );\n                }\n              } else if (distinct) {\n                if (!classExists) {\n                  return [];\n                } else {\n                  return this.adapter.distinct(className, schema, query, distinct);\n                }\n              } else if (pipeline) {\n                if (!classExists) {\n                  return [];\n                } else {\n                  return this.adapter.aggregate(\n                    className,\n                    schema,\n                    pipeline,\n                    readPreference,\n                    hint,\n                    explain,\n                    comment,\n                    rawValues,\n                    rawFieldNames\n                  );\n                }\n              } else if (explain) {\n                return this.adapter.find(className, schema, query, queryOptions);\n              } else {\n                return this.adapter\n                  .find(className, schema, query, queryOptions)\n                  .then(objects =>\n                    objects.map(object => {\n                      object = untransformObjectACL(object);\n                      return filterSensitiveData(\n                        isMaster,\n                        isMaintenance,\n                        aclGroup,\n                        auth,\n                        op,\n                        schemaController,\n                        className,\n                        protectedFields,\n                        object,\n                        this.options.protectedFieldsOwnerExempt\n                      );\n                    })\n                  )\n                  .catch(error => {\n                    if (error instanceof Parse.Error) {\n                      throw error;\n                    }\n                    const detailedMessage =\n                      typeof error === 'string'\n                        ? error\n                        : error?.message || 'An internal server error occurred';\n                    throw createSanitizedError(\n                      Parse.Error.INTERNAL_SERVER_ERROR,\n                      detailedMessage,\n                      this.options,\n                      'An internal server error occurred'\n                    );\n                  });\n              }\n            });\n        });\n    });\n  }\n\n  deleteSchema(className: string): Promise<void> {\n    let schemaController;\n    return this.loadSchema({ clearCache: true })\n      .then(s => {\n        schemaController = s;\n        return schemaController.getOneSchema(className, true);\n      })\n      .catch(error => {\n        if (error === undefined) {\n          return { fields: {} };\n        } else {\n          throw error;\n        }\n      })\n      .then((schema: any) => {\n        return this.collectionExists(className)\n          .then(() => this.adapter.count(className, { fields: {} }, null, '', false))\n          .then(count => {\n            if (count > 0) {\n              throw new Parse.Error(\n                255,\n                `Class ${className} is not empty, contains ${count} objects, cannot drop schema.`\n              );\n            }\n            return this.adapter.deleteClass(className);\n          })\n          .then(wasParseCollection => {\n            if (wasParseCollection) {\n              const relationFieldNames = Object.keys(schema.fields).filter(\n                fieldName => schema.fields[fieldName].type === 'Relation'\n              );\n              return Promise.all(\n                relationFieldNames.map(name =>\n                  this.adapter.deleteClass(joinTableName(className, name))\n                )\n              ).then(() => {\n                SchemaCache.del(className);\n                return schemaController.reloadData();\n              });\n            } else {\n              return Promise.resolve();\n            }\n          });\n      });\n  }\n\n  // This helps to create intermediate objects for simpler comparison of\n  // key value pairs used in query objects. Each key value pair will represented\n  // in a similar way to json\n  objectToEntriesStrings(query: any): Array<string> {\n    return Object.entries(query).map(a => a.map(s => JSON.stringify(s)).join(':'));\n  }\n\n  // Naive logic reducer for OR operations meant to be used only for pointer permissions.\n  reduceOrOperation(query: { $or: Array<any> }): any {\n    if (!query.$or) {\n      return query;\n    }\n    const queries = query.$or.map(q => this.objectToEntriesStrings(q));\n    let repeat = false;\n    do {\n      repeat = false;\n      for (let i = 0; i < queries.length - 1; i++) {\n        for (let j = i + 1; j < queries.length; j++) {\n          const [shorter, longer] = queries[i].length > queries[j].length ? [j, i] : [i, j];\n          const foundEntries = queries[shorter].reduce(\n            (acc, entry) => acc + (queries[longer].includes(entry) ? 1 : 0),\n            0\n          );\n          const shorterEntries = queries[shorter].length;\n          if (foundEntries === shorterEntries) {\n            // If the shorter query is completely contained in the longer one, we can strike\n            // out the longer query.\n            query.$or.splice(longer, 1);\n            queries.splice(longer, 1);\n            repeat = true;\n            break;\n          }\n        }\n      }\n    } while (repeat);\n    if (query.$or.length === 1) {\n      query = { ...query, ...query.$or[0] };\n      delete query.$or;\n    }\n    return query;\n  }\n\n  // Naive logic reducer for AND operations meant to be used only for pointer permissions.\n  reduceAndOperation(query: { $and: Array<any> }): any {\n    if (!query.$and) {\n      return query;\n    }\n    const queries = query.$and.map(q => this.objectToEntriesStrings(q));\n    let repeat = false;\n    do {\n      repeat = false;\n      for (let i = 0; i < queries.length - 1; i++) {\n        for (let j = i + 1; j < queries.length; j++) {\n          const [shorter, longer] = queries[i].length > queries[j].length ? [j, i] : [i, j];\n          const foundEntries = queries[shorter].reduce(\n            (acc, entry) => acc + (queries[longer].includes(entry) ? 1 : 0),\n            0\n          );\n          const shorterEntries = queries[shorter].length;\n          if (foundEntries === shorterEntries) {\n            // If the shorter query is completely contained in the longer one, we can strike\n            // out the shorter query.\n            query.$and.splice(shorter, 1);\n            queries.splice(shorter, 1);\n            repeat = true;\n            break;\n          }\n        }\n      }\n    } while (repeat);\n    if (query.$and.length === 1) {\n      query = { ...query, ...query.$and[0] };\n      delete query.$and;\n    }\n    return query;\n  }\n\n  // Constraints query using CLP's pointer permissions (PP) if any.\n  // 1. Etract the user id from caller's ACLgroup;\n  // 2. Exctract a list of field names that are PP for target collection and operation;\n  // 3. Constraint the original query so that each PP field must\n  // point to caller's id (or contain it in case of PP field being an array)\n  addPointerPermissions(\n    schema: SchemaController.SchemaController,\n    className: string,\n    operation: string,\n    query: any,\n    aclGroup: any[] = []\n  ): any {\n    // Check if class has public permission for operation\n    // If the BaseCLP pass, let go through\n    if (schema.testPermissionsForClassName(className, aclGroup, operation)) {\n      return query;\n    }\n    const perms = schema.getClassLevelPermissions(className);\n\n    const userACL = aclGroup.filter(acl => {\n      return acl.indexOf('role:') != 0 && acl != '*';\n    });\n\n    const groupKey =\n      ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';\n\n    const permFields = [];\n\n    if (perms[operation] && perms[operation].pointerFields) {\n      permFields.push(...perms[operation].pointerFields);\n    }\n\n    if (perms[groupKey]) {\n      for (const field of perms[groupKey]) {\n        if (!permFields.includes(field)) {\n          permFields.push(field);\n        }\n      }\n    }\n    // the ACL should have exactly 1 user\n    if (permFields.length > 0) {\n      // the ACL should have exactly 1 user\n      // No user set return undefined\n      // If the length is > 1, that means we didn't de-dupe users correctly\n      if (userACL.length != 1) {\n        return;\n      }\n      const userId = userACL[0];\n      const userPointer = {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: userId,\n      };\n\n      const queries = permFields.map(key => {\n        const fieldDescriptor = schema.getExpectedType(className, key);\n        const fieldType =\n          fieldDescriptor &&\n          typeof fieldDescriptor === 'object' &&\n          Object.prototype.hasOwnProperty.call(fieldDescriptor, 'type')\n            ? fieldDescriptor.type\n            : null;\n\n        let queryClause;\n\n        if (fieldType === 'Pointer') {\n          // constraint for single pointer setup\n          queryClause = { [key]: userPointer };\n        } else if (fieldType === 'Array') {\n          // constraint for users-array setup\n          queryClause = { [key]: { $all: [userPointer] } };\n        } else if (fieldType === 'Object') {\n          // constraint for object setup\n          queryClause = { [key]: userPointer };\n        } else {\n          // This means that there is a CLP field of an unexpected type. This condition should not happen, which is\n          // why is being treated as an error.\n          throw Error(\n            `An unexpected condition occurred when resolving pointer permissions: ${className} ${key}`\n          );\n        }\n        // if we already have a constraint on the key, use the $and\n        if (Object.prototype.hasOwnProperty.call(query, key)) {\n          return this.reduceAndOperation({ $and: [queryClause, query] });\n        }\n        // otherwise just add the constaint\n        return Object.assign({}, query, queryClause);\n      });\n\n      return queries.length === 1 ? queries[0] : this.reduceOrOperation({ $or: queries });\n    } else {\n      return query;\n    }\n  }\n\n  addProtectedFields(\n    schema: SchemaController.SchemaController | any,\n    className: string,\n    query: any = {},\n    aclGroup: any[] = [],\n    auth: any = {},\n    queryOptions: FullQueryOptions = {}\n  ): null | string[] {\n    const perms =\n      schema && schema.getClassLevelPermissions\n        ? schema.getClassLevelPermissions(className)\n        : schema;\n    if (!perms) { return null; }\n\n    const protectedFields = perms.protectedFields;\n    if (!protectedFields) { return null; }\n\n    if (className === '_User' && this.options.protectedFieldsOwnerExempt !== false && aclGroup.indexOf(query.objectId) > -1) { return null; }\n\n    // for queries where \"keys\" are set and do not include all 'userField':{field},\n    // we have to transparently include it, and then remove before returning to client\n    // Because if such key not projected the permission won't be enforced properly\n    // PS this is called when 'excludeKeys' already reduced to 'keys'\n    const preserveKeys = queryOptions.keys;\n\n    // these are keys that need to be included only\n    // to be able to apply protectedFields by pointer\n    // and then unset before returning to client (later in  filterSensitiveFields)\n    const serverOnlyKeys = [];\n\n    const authenticated = auth.user;\n\n    // map to allow check without array search\n    const roles = (auth.userRoles || []).reduce((acc, r) => {\n      acc[r] = protectedFields[r];\n      return acc;\n    }, {});\n\n    // array of sets of protected fields. separate item for each applicable criteria\n    const protectedKeysSets = [];\n\n    for (const key in protectedFields) {\n      // skip userFields\n      if (key.startsWith('userField:')) {\n        if (preserveKeys) {\n          const fieldName = key.substring(10);\n          if (!preserveKeys.includes(fieldName)) {\n            // 1. put it there temporarily\n            queryOptions.keys && queryOptions.keys.push(fieldName);\n            // 2. preserve it delete later\n            serverOnlyKeys.push(fieldName);\n          }\n        }\n        continue;\n      }\n\n      // add public tier\n      if (key === '*') {\n        protectedKeysSets.push(protectedFields[key]);\n        continue;\n      }\n\n      if (authenticated) {\n        if (key === 'authenticated') {\n          // for logged in users\n          protectedKeysSets.push(protectedFields[key]);\n          continue;\n        }\n\n        if (roles[key] && key.startsWith('role:')) {\n          // add applicable roles\n          protectedKeysSets.push(roles[key]);\n        }\n      }\n    }\n\n    // check if there's a rule for current user's id\n    if (authenticated) {\n      const userId = auth.user.id;\n      if (perms.protectedFields[userId]) {\n        protectedKeysSets.push(perms.protectedFields[userId]);\n      }\n    }\n\n    // preserve fields to be removed before sending response to client\n    if (serverOnlyKeys.length > 0) {\n      perms.protectedFields.temporaryKeys = serverOnlyKeys;\n    }\n\n    let protectedKeys = protectedKeysSets.reduce((acc, next) => {\n      if (next) {\n        acc.push(...next);\n      }\n      return acc;\n    }, []);\n\n    // intersect all sets of protectedFields\n    protectedKeysSets.forEach(fields => {\n      if (fields) {\n        protectedKeys = protectedKeys.filter(v => fields.includes(v));\n      }\n    });\n\n    return protectedKeys;\n  }\n\n  createTransactionalSession() {\n    return this.adapter.createTransactionalSession().then(transactionalSession => {\n      this._transactionalSession = transactionalSession;\n    });\n  }\n\n  commitTransactionalSession() {\n    if (!this._transactionalSession) {\n      throw new Error('There is no transactional session to commit');\n    }\n    return this.adapter.commitTransactionalSession(this._transactionalSession).then(() => {\n      this._transactionalSession = null;\n    });\n  }\n\n  abortTransactionalSession() {\n    if (!this._transactionalSession) {\n      throw new Error('There is no transactional session to abort');\n    }\n    return this.adapter.abortTransactionalSession(this._transactionalSession).then(() => {\n      this._transactionalSession = null;\n    });\n  }\n\n  // TODO: create indexes on first creation of a _User object. Otherwise it's impossible to\n  // have a Parse app without it having a _User collection.\n  async performInitialization() {\n    await this.adapter.performInitialization({\n      VolatileClassesSchemas: SchemaController.VolatileClassesSchemas,\n    });\n    const requiredUserFields = {\n      fields: {\n        ...SchemaController.defaultColumns._Default,\n        ...SchemaController.defaultColumns._User,\n      },\n    };\n    const requiredRoleFields = {\n      fields: {\n        ...SchemaController.defaultColumns._Default,\n        ...SchemaController.defaultColumns._Role,\n      },\n    };\n    const requiredIdempotencyFields = {\n      fields: {\n        ...SchemaController.defaultColumns._Default,\n        ...SchemaController.defaultColumns._Idempotency,\n      },\n    };\n    await this.loadSchema().then(schema => schema.enforceClassExists('_User'));\n    await this.loadSchema().then(schema => schema.enforceClassExists('_Role'));\n    await this.loadSchema().then(schema => schema.enforceClassExists('_Idempotency'));\n\n    const databaseOptions = this.options.databaseOptions || {};\n\n    if (databaseOptions.createIndexUserUsername !== false) {\n      await this.adapter.ensureUniqueness('_User', requiredUserFields, ['username']).catch(error => {\n        logger.warn('Unable to ensure uniqueness for usernames: ', error);\n        throw error;\n      });\n    }\n\n    if (!this.options.enableCollationCaseComparison) {\n      if (databaseOptions.createIndexUserUsernameCaseInsensitive !== false) {\n        await this.adapter\n          .ensureIndex('_User', requiredUserFields, ['username'], 'case_insensitive_username', true)\n          .catch(error => {\n            logger.warn('Unable to create case insensitive username index: ', error);\n            throw error;\n          });\n      }\n\n      if (databaseOptions.createIndexUserEmailCaseInsensitive !== false) {\n        await this.adapter\n          .ensureIndex('_User', requiredUserFields, ['email'], 'case_insensitive_email', true)\n          .catch(error => {\n            logger.warn('Unable to create case insensitive email index: ', error);\n            throw error;\n          });\n      }\n    }\n\n    if (databaseOptions.createIndexUserEmail !== false) {\n      await this.adapter.ensureUniqueness('_User', requiredUserFields, ['email']).catch(error => {\n        logger.warn('Unable to ensure uniqueness for user email addresses: ', error);\n        throw error;\n      });\n    }\n\n    if (databaseOptions.createIndexUserEmailVerifyToken !== false) {\n      await this.adapter\n        .ensureIndex('_User', requiredUserFields, ['_email_verify_token'], '_email_verify_token', false)\n        .catch(error => {\n          logger.warn('Unable to create index for email verification token: ', error);\n          throw error;\n        });\n    }\n\n    if (databaseOptions.createIndexUserPasswordResetToken !== false) {\n      await this.adapter\n        .ensureIndex('_User', requiredUserFields, ['_perishable_token'], '_perishable_token', false)\n        .catch(error => {\n          logger.warn('Unable to create index for password reset token: ', error);\n          throw error;\n        });\n    }\n\n    if (databaseOptions.createIndexRoleName !== false) {\n      await this.adapter.ensureUniqueness('_Role', requiredRoleFields, ['name']).catch(error => {\n        logger.warn('Unable to ensure uniqueness for role name: ', error);\n        throw error;\n      });\n    }\n\n    await this.adapter\n      .ensureUniqueness('_Idempotency', requiredIdempotencyFields, ['reqId'])\n      .catch(error => {\n        logger.warn('Unable to ensure uniqueness for idempotency request ID: ', error);\n        throw error;\n      });\n\n    const isMongoAdapter = this.adapter instanceof MongoStorageAdapter;\n    const isPostgresAdapter = this.adapter instanceof PostgresStorageAdapter;\n    if (isMongoAdapter || isPostgresAdapter) {\n      let options = {};\n      if (isMongoAdapter) {\n        options = {\n          ttl: 0,\n        };\n      } else if (isPostgresAdapter) {\n        options = this.idempotencyOptions;\n        options.setIdempotencyFunction = true;\n      }\n      await this.adapter\n        .ensureIndex('_Idempotency', requiredIdempotencyFields, ['expire'], 'ttl', false, options)\n        .catch(error => {\n          logger.warn('Unable to create TTL index for idempotency expire date: ', error);\n          throw error;\n        });\n    }\n    // Create unique indexes for authData providers to prevent race conditions\n    // during concurrent signups with the same authData\n    if (\n      databaseOptions.createIndexAuthDataUniqueness !== false &&\n      typeof this.adapter.ensureAuthDataUniqueness === 'function'\n    ) {\n      const authProviders = Object.keys(this.options.auth || {});\n      if (this.options.enableAnonymousUsers !== false) {\n        if (!authProviders.includes('anonymous')) {\n          authProviders.push('anonymous');\n        }\n      }\n      await Promise.all(\n        authProviders.map(provider =>\n          this.adapter.ensureAuthDataUniqueness(provider).catch(error => {\n            logger.warn(\n              `Unable to ensure uniqueness for auth data provider \"${provider}\": `,\n              error\n            );\n          })\n        )\n      );\n    }\n\n    await this.adapter.updateSchemaWithIndexes();\n  }\n\n  _expandResultOnKeyPath(object: any, key: string, value: any): any {\n    if (key.indexOf('.') < 0) {\n      object[key] = value[key];\n      return object;\n    }\n    const path = key.split('.');\n    const firstKey = path[0];\n    const nextPath = path.slice(1).join('.');\n\n    // Scan request data for denied keywords\n    if (this.options && this.options.requestKeywordDenylist) {\n      // Scan request data for denied keywords\n      for (const keyword of this.options.requestKeywordDenylist) {\n        const match = Utils.objectContainsKeyValue(\n          { [firstKey]: true, [nextPath]: true },\n          keyword.key,\n          true\n        );\n        if (match) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_KEY_NAME,\n            `Prohibited keyword in request data: ${JSON.stringify(keyword)}.`\n          );\n        }\n      }\n    }\n\n    object[firstKey] = this._expandResultOnKeyPath(\n      object[firstKey] || {},\n      nextPath,\n      value[firstKey]\n    );\n    delete object[key];\n    return object;\n  }\n\n  _sanitizeDatabaseResult(originalObject: any, result: any): Promise<any> {\n    const response = {};\n    if (!result) {\n      return Promise.resolve(response);\n    }\n    Object.keys(originalObject).forEach(key => {\n      const keyUpdate = originalObject[key];\n      // determine if that was an op\n      if (\n        keyUpdate &&\n        typeof keyUpdate === 'object' &&\n        keyUpdate.__op &&\n        ['Add', 'AddUnique', 'Remove', 'Increment', 'SetOnInsert'].indexOf(keyUpdate.__op) > -1\n      ) {\n        // only valid ops that produce an actionable result\n        // the op may have happened on a keypath\n        this._expandResultOnKeyPath(response, key, result);\n        // Revert array to object conversion on dot notation for arrays (e.g. \"field.0.key\")\n        if (key.includes('.')) {\n          const [field, index] = key.split('.');\n          const isArrayIndex = Array.from(index).every(c => c >= '0' && c <= '9');\n          if (isArrayIndex && Array.isArray(result[field]) && !Array.isArray(response[field])) {\n            response[field] = result[field];\n          }\n        }\n      }\n    });\n    return Promise.resolve(response);\n  }\n\n  static _validateQuery: (any, boolean, boolean, boolean) => void;\n  static filterSensitiveData: (boolean, boolean, any[], any, any, any, string, any[], any, ?boolean) => void;\n}\n\nmodule.exports = DatabaseController;\n// Expose validateQuery for tests\nmodule.exports._validateQuery = validateQuery;\nmodule.exports.filterSensitiveData = filterSensitiveData;\n"],"mappings":"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","ignoreList":[]}