@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Controllers/SchemaController.js

@@ -0,0 +1,1563 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VolatileClassesSchemas = exports.SchemaController = void 0;
+exports.buildMergedSchemaObject = buildMergedSchemaObject;
+exports.classNameIsValid = classNameIsValid;
+exports.defaultColumns = exports.default = exports.convertSchemaToAdapterSchema = void 0;
+exports.fieldNameIsValid = fieldNameIsValid;
+exports.invalidClassNameMessage = invalidClassNameMessage;
+exports.systemClasses = exports.requiredColumns = exports.load = void 0;
+var _StorageAdapter = require("../Adapters/Storage/StorageAdapter");
+var _SchemaCache = _interopRequireDefault(require("../Adapters/Cache/SchemaCache"));
+var _DatabaseController = _interopRequireDefault(require("./DatabaseController"));
+var _Config = _interopRequireDefault(require("../Config"));
+var _Error = require("../Error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// This class handles schema validation, persistence, and modification.
+//
+// Each individual Schema object should be immutable. The helpers to
+// do things with the Schema just return a new schema when the schema
+// is changed.
+//
+// The canonical place to store this Schema is in the database itself,
+// in a _SCHEMA collection. This is not the right way to do it for an
+// open source framework, but it's backward compatible, so we're
+// keeping it this way for now.
+//
+// In API-handling code, you should only use the Schema class via the
+// DatabaseController. This will let us replace the schema logic for
+// different databases.
+// TODO: hide all schema logic inside the database adapter.
+// -disable-next
+const Parse = require('parse/node').Parse;
+const defaultColumns = exports.defaultColumns = Object.freeze({
+  // Contain the default columns for every parse object type (except _Join collection)
+  _Default: {
+    objectId: {
+      type: 'String'
+    },
+    createdAt: {
+      type: 'Date'
+    },
+    updatedAt: {
+      type: 'Date'
+    },
+    ACL: {
+      type: 'ACL'
+    }
+  },
+  // The additional default columns for the _User collection (in addition to DefaultCols)
+  _User: {
+    username: {
+      type: 'String'
+    },
+    password: {
+      type: 'String'
+    },
+    email: {
+      type: 'String'
+    },
+    emailVerified: {
+      type: 'Boolean'
+    },
+    authData: {
+      type: 'Object'
+    }
+  },
+  // The additional default columns for the _Installation collection (in addition to DefaultCols)
+  _Installation: {
+    installationId: {
+      type: 'String'
+    },
+    deviceToken: {
+      type: 'String'
+    },
+    channels: {
+      type: 'Array'
+    },
+    deviceType: {
+      type: 'String'
+    },
+    pushType: {
+      type: 'String'
+    },
+    GCMSenderId: {
+      type: 'String'
+    },
+    timeZone: {
+      type: 'String'
+    },
+    localeIdentifier: {
+      type: 'String'
+    },
+    badge: {
+      type: 'Number'
+    },
+    appVersion: {
+      type: 'String'
+    },
+    appName: {
+      type: 'String'
+    },
+    appIdentifier: {
+      type: 'String'
+    },
+    parseVersion: {
+      type: 'String'
+    }
+  },
+  // The additional default columns for the _Role collection (in addition to DefaultCols)
+  _Role: {
+    name: {
+      type: 'String'
+    },
+    users: {
+      type: 'Relation',
+      targetClass: '_User'
+    },
+    roles: {
+      type: 'Relation',
+      targetClass: '_Role'
+    }
+  },
+  // The additional default columns for the _Session collection (in addition to DefaultCols)
+  _Session: {
+    user: {
+      type: 'Pointer',
+      targetClass: '_User'
+    },
+    installationId: {
+      type: 'String'
+    },
+    sessionToken: {
+      type: 'String'
+    },
+    expiresAt: {
+      type: 'Date'
+    },
+    createdWith: {
+      type: 'Object'
+    }
+  },
+  _Product: {
+    productIdentifier: {
+      type: 'String'
+    },
+    download: {
+      type: 'File'
+    },
+    downloadName: {
+      type: 'String'
+    },
+    icon: {
+      type: 'File'
+    },
+    order: {
+      type: 'Number'
+    },
+    title: {
+      type: 'String'
+    },
+    subtitle: {
+      type: 'String'
+    }
+  },
+  _PushStatus: {
+    pushTime: {
+      type: 'String'
+    },
+    source: {
+      type: 'String'
+    },
+    // rest or webui
+    query: {
+      type: 'String'
+    },
+    // the stringified JSON query
+    payload: {
+      type: 'String'
+    },
+    // the stringified JSON payload,
+    title: {
+      type: 'String'
+    },
+    expiry: {
+      type: 'Number'
+    },
+    expiration_interval: {
+      type: 'Number'
+    },
+    status: {
+      type: 'String'
+    },
+    numSent: {
+      type: 'Number'
+    },
+    numFailed: {
+      type: 'Number'
+    },
+    pushHash: {
+      type: 'String'
+    },
+    errorMessage: {
+      type: 'Object'
+    },
+    sentPerType: {
+      type: 'Object'
+    },
+    failedPerType: {
+      type: 'Object'
+    },
+    sentPerUTCOffset: {
+      type: 'Object'
+    },
+    failedPerUTCOffset: {
+      type: 'Object'
+    },
+    count: {
+      type: 'Number'
+    } // tracks # of batches queued and pending
+  },
+  _JobStatus: {
+    jobName: {
+      type: 'String'
+    },
+    source: {
+      type: 'String'
+    },
+    status: {
+      type: 'String'
+    },
+    message: {
+      type: 'String'
+    },
+    params: {
+      type: 'Object'
+    },
+    // params received when calling the job
+    finishedAt: {
+      type: 'Date'
+    }
+  },
+  _JobSchedule: {
+    jobName: {
+      type: 'String'
+    },
+    description: {
+      type: 'String'
+    },
+    params: {
+      type: 'String'
+    },
+    startAfter: {
+      type: 'String'
+    },
+    daysOfWeek: {
+      type: 'Array'
+    },
+    timeOfDay: {
+      type: 'String'
+    },
+    lastRun: {
+      type: 'Number'
+    },
+    repeatMinutes: {
+      type: 'Number'
+    }
+  },
+  _Hooks: {
+    functionName: {
+      type: 'String'
+    },
+    className: {
+      type: 'String'
+    },
+    triggerName: {
+      type: 'String'
+    },
+    url: {
+      type: 'String'
+    }
+  },
+  _GlobalConfig: {
+    objectId: {
+      type: 'String'
+    },
+    params: {
+      type: 'Object'
+    },
+    masterKeyOnly: {
+      type: 'Object'
+    }
+  },
+  _GraphQLConfig: {
+    objectId: {
+      type: 'String'
+    },
+    config: {
+      type: 'Object'
+    }
+  },
+  _Audience: {
+    objectId: {
+      type: 'String'
+    },
+    name: {
+      type: 'String'
+    },
+    query: {
+      type: 'String'
+    },
+    //storing query as JSON string to prevent "Nested keys should not contain the '$' or '.' characters" error
+    lastUsed: {
+      type: 'Date'
+    },
+    timesUsed: {
+      type: 'Number'
+    }
+  },
+  _Idempotency: {
+    reqId: {
+      type: 'String'
+    },
+    expire: {
+      type: 'Date'
+    }
+  }
+});
+
+// fields required for read or write operations on their respective classes.
+const requiredColumns = exports.requiredColumns = Object.freeze({
+  read: {
+    _User: ['username']
+  },
+  write: {
+    _Product: ['productIdentifier', 'icon', 'order', 'title', 'subtitle'],
+    _Role: ['name', 'ACL']
+  }
+});
+const invalidColumns = ['length'];
+const systemClasses = exports.systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience', '_Idempotency']);
+const volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_GraphQLConfig', '_JobSchedule', '_Audience', '_Idempotency']);
+
+// Anything that start with role
+const roleRegex = /^role:.*/;
+// Anything that starts with userField (allowed for protected fields only)
+const protectedFieldsPointerRegex = /^userField:.*/;
+// * permission
+const publicRegex = /^\*$/;
+const authenticatedRegex = /^authenticated$/;
+const requiresAuthenticationRegex = /^requiresAuthentication$/;
+const clpPointerRegex = /^pointerFields$/;
+
+// regex for validating entities in protectedFields object
+const protectedFieldsRegex = Object.freeze([protectedFieldsPointerRegex, publicRegex, authenticatedRegex, roleRegex]);
+
+// clp regex
+const clpFieldsRegex = Object.freeze([clpPointerRegex, publicRegex, requiresAuthenticationRegex, roleRegex]);
+function validatePermissionKey(key, userIdRegExp) {
+  let matchesSome = false;
+  for (const regEx of clpFieldsRegex) {
+    if (key.match(regEx) !== null) {
+      matchesSome = true;
+      break;
+    }
+  }
+
+  // userId depends on startup options so it's dynamic
+  const valid = matchesSome || key.match(userIdRegExp) !== null;
+  if (!valid) {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid key for class level permissions`);
+  }
+}
+function validateProtectedFieldsKey(key, userIdRegExp) {
+  let matchesSome = false;
+  for (const regEx of protectedFieldsRegex) {
+    if (key.match(regEx) !== null) {
+      matchesSome = true;
+      break;
+    }
+  }
+
+  // userId regex depends on launch options so it's dynamic
+  const valid = matchesSome || key.match(userIdRegExp) !== null;
+  if (!valid) {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid key for class level permissions`);
+  }
+}
+const CLPValidKeys = Object.freeze(['ACL', 'find', 'count', 'get', 'create', 'update', 'delete', 'addField', 'readUserFields', 'writeUserFields', 'protectedFields']);
+
+// validation before setting class-level permissions on collection
+function validateCLP(perms, fields, userIdRegExp) {
+  if (!perms) {
+    return;
+  }
+  for (const operationKey in perms) {
+    if (CLPValidKeys.indexOf(operationKey) == -1) {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, `${operationKey} is not a valid operation for class level permissions`);
+    }
+    const operation = perms[operationKey];
+    // proceed with next operationKey
+
+    // throws when root fields are of wrong type
+    validateCLPjson(operation, operationKey);
+    if (operationKey === 'readUserFields' || operationKey === 'writeUserFields') {
+      // validate grouped pointer permissions
+      // must be an array with field names
+      for (const fieldName of operation) {
+        validatePointerPermission(fieldName, fields, operationKey);
+      }
+      // readUserFields and writerUserFields do not have nesdted fields
+      // proceed with next operationKey
+      continue;
+    }
+
+    // validate protected fields
+    if (operationKey === 'protectedFields') {
+      for (const entity in operation) {
+        // throws on unexpected key
+        validateProtectedFieldsKey(entity, userIdRegExp);
+        const protectedFields = operation[entity];
+        if (!Array.isArray(protectedFields)) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, `'${protectedFields}' is not a valid value for protectedFields[${entity}] - expected an array.`);
+        }
+
+        // if the field is in form of array
+        for (const field of protectedFields) {
+          // do not alloow to protect default fields
+          if (defaultColumns._Default[field]) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `Default field '${field}' can not be protected`);
+          }
+          // field should exist on collection
+          if (!Object.prototype.hasOwnProperty.call(fields, field)) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `Field '${field}' in protectedFields:${entity} does not exist`);
+          }
+        }
+      }
+      // proceed with next operationKey
+      continue;
+    }
+
+    // validate other fields
+    // Entity can be:
+    // "*" - Public,
+    // "requiresAuthentication" - authenticated users,
+    // "objectId" - _User id,
+    // "role:rolename",
+    // "pointerFields" - array of field names containing pointers to users
+    for (const entity in operation) {
+      // throws on unexpected key
+      validatePermissionKey(entity, userIdRegExp);
+
+      // entity can be either:
+      // "pointerFields": string[]
+      if (entity === 'pointerFields') {
+        const pointerFields = operation[entity];
+        if (Array.isArray(pointerFields)) {
+          for (const pointerField of pointerFields) {
+            validatePointerPermission(pointerField, fields, operation);
+          }
+        } else {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, `'${pointerFields}' is not a valid value for ${operationKey}[${entity}] - expected an array.`);
+        }
+        // proceed with next entity key
+        continue;
+      }
+      const permit = operation[entity];
+      if (operationKey === 'ACL') {
+        if (Object.prototype.toString.call(permit) !== '[object Object]') {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, `'${permit}' is not a valid value for class level permissions acl`);
+        }
+        const invalidKeys = Object.keys(permit).filter(key => !['read', 'write'].includes(key));
+        const invalidValues = Object.values(permit).filter(key => typeof key !== 'boolean');
+        if (invalidKeys.length) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, `'${invalidKeys.join(',')}' is not a valid key for class level permissions acl`);
+        }
+        if (invalidValues.length) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, `'${invalidValues.join(',')}' is not a valid value for class level permissions acl`);
+        }
+      } else if (permit !== true) {
+        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${permit}' is not a valid value for class level permissions acl ${operationKey}:${entity}`);
+      }
+    }
+  }
+}
+function validateCLPjson(operation, operationKey) {
+  if (operationKey === 'readUserFields' || operationKey === 'writeUserFields') {
+    if (!Array.isArray(operation)) {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, `'${operation}' is not a valid value for class level permissions ${operationKey} - must be an array`);
+    }
+  } else {
+    if (typeof operation === 'object' && operation !== null) {
+      // ok to proceed
+      return;
+    } else {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, `'${operation}' is not a valid value for class level permissions ${operationKey} - must be an object`);
+    }
+  }
+}
+function validatePointerPermission(fieldName, fields, operation) {
+  // Uses collection schema to ensure the field is of type:
+  // - Pointer<_User> (pointers)
+  // - Array
+  //
+  //    It's not possible to enforce type on Array's items in schema
+  //  so we accept any Array field, and later when applying permissions
+  //  only items that are pointers to _User are considered.
+  if (!(fields[fieldName] && (fields[fieldName].type == 'Pointer' && fields[fieldName].targetClass == '_User' || fields[fieldName].type == 'Array'))) {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, `'${fieldName}' is not a valid column for class level pointer permissions ${operation}`);
+  }
+}
+const joinClassRegex = /^_Join:[A-Za-z0-9_]+:[A-Za-z0-9_]+/;
+const classAndFieldRegex = /^[A-Za-z][A-Za-z0-9_]*$/;
+function classNameIsValid(className) {
+  // Valid classes must:
+  return (
+    // Be one of _User, _Installation, _Role, _Session OR
+    systemClasses.indexOf(className) > -1 ||
+    // Be a join table OR
+    joinClassRegex.test(className) ||
+    // Include only alpha-numeric and underscores, and not start with an underscore or number
+    fieldNameIsValid(className, className)
+  );
+}
+
+// Valid fields must be alpha-numeric, and not start with an underscore or number
+// must not be a reserved key
+function fieldNameIsValid(fieldName, className) {
+  if (className && className !== '_Hooks') {
+    if (fieldName === 'className') {
+      return false;
+    }
+  }
+  return classAndFieldRegex.test(fieldName) && !invalidColumns.includes(fieldName);
+}
+
+// Checks that it's not trying to clobber one of the default fields of the class.
+function fieldNameIsValidForClass(fieldName, className) {
+  if (!fieldNameIsValid(fieldName, className)) {
+    return false;
+  }
+  if (defaultColumns._Default[fieldName]) {
+    return false;
+  }
+  if (defaultColumns[className] && defaultColumns[className][fieldName]) {
+    return false;
+  }
+  return true;
+}
+function invalidClassNameMessage(className) {
+  return 'Invalid classname: ' + className + ', classnames can only have alphanumeric characters and _, and must start with an alpha character ';
+}
+const invalidJsonError = new Parse.Error(Parse.Error.INVALID_JSON, 'invalid JSON');
+const validNonRelationOrPointerTypes = ['Number', 'String', 'Boolean', 'Date', 'Object', 'Array', 'GeoPoint', 'File', 'Bytes', 'Polygon'];
+// Returns an error suitable for throwing if the type is invalid
+const fieldTypeIsInvalid = ({
+  type,
+  targetClass
+}) => {
+  if (['Pointer', 'Relation'].indexOf(type) >= 0) {
+    if (!targetClass) {
+      return new Parse.Error(135, `type ${type} needs a class name`);
+    } else if (typeof targetClass !== 'string') {
+      return invalidJsonError;
+    } else if (!classNameIsValid(targetClass)) {
+      return new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(targetClass));
+    } else {
+      return undefined;
+    }
+  }
+  if (typeof type !== 'string') {
+    return invalidJsonError;
+  }
+  if (validNonRelationOrPointerTypes.indexOf(type) < 0) {
+    return new Parse.Error(Parse.Error.INCORRECT_TYPE, `invalid field type: ${type}`);
+  }
+  return undefined;
+};
+const convertSchemaToAdapterSchema = schema => {
+  schema = injectDefaultSchema(schema);
+  delete schema.fields.ACL;
+  schema.fields._rperm = {
+    type: 'Array'
+  };
+  schema.fields._wperm = {
+    type: 'Array'
+  };
+  if (schema.className === '_User') {
+    delete schema.fields.password;
+    schema.fields._hashed_password = {
+      type: 'String'
+    };
+  }
+  return schema;
+};
+exports.convertSchemaToAdapterSchema = convertSchemaToAdapterSchema;
+const convertAdapterSchemaToParseSchema = ({
+  ...schema
+}) => {
+  delete schema.fields._rperm;
+  delete schema.fields._wperm;
+  schema.fields.ACL = {
+    type: 'ACL'
+  };
+  if (schema.className === '_User') {
+    delete schema.fields.authData; //Auth data is implicit
+    delete schema.fields._hashed_password;
+    schema.fields.password = {
+      type: 'String'
+    };
+  }
+  if (schema.indexes && Object.keys(schema.indexes).length === 0) {
+    delete schema.indexes;
+  }
+  return schema;
+};
+class SchemaData {
+  constructor(allSchemas = [], protectedFields = {}) {
+    this.__data = {};
+    this.__protectedFields = protectedFields;
+    allSchemas.forEach(schema => {
+      if (volatileClasses.includes(schema.className)) {
+        return;
+      }
+      Object.defineProperty(this, schema.className, {
+        get: () => {
+          if (!this.__data[schema.className]) {
+            const data = {};
+            data.fields = injectDefaultSchema(schema).fields;
+            data.classLevelPermissions = structuredClone(schema.classLevelPermissions);
+            data.indexes = schema.indexes;
+            const classProtectedFields = this.__protectedFields[schema.className];
+            if (classProtectedFields) {
+              for (const key in classProtectedFields) {
+                const unq = new Set([...(data.classLevelPermissions.protectedFields[key] || []), ...classProtectedFields[key]]);
+                data.classLevelPermissions.protectedFields[key] = Array.from(unq);
+              }
+            }
+            this.__data[schema.className] = data;
+          }
+          return this.__data[schema.className];
+        }
+      });
+    });
+
+    // Inject the in-memory classes
+    volatileClasses.forEach(className => {
+      Object.defineProperty(this, className, {
+        get: () => {
+          if (!this.__data[className]) {
+            const schema = injectDefaultSchema({
+              className,
+              fields: {},
+              classLevelPermissions: {}
+            });
+            const data = {};
+            data.fields = schema.fields;
+            data.classLevelPermissions = schema.classLevelPermissions;
+            data.indexes = schema.indexes;
+            this.__data[className] = data;
+          }
+          return this.__data[className];
+        }
+      });
+    });
+  }
+}
+const injectDefaultSchema = ({
+  className,
+  fields,
+  classLevelPermissions,
+  indexes
+}) => {
+  const defaultSchema = {
+    className,
+    fields: {
+      ...defaultColumns._Default,
+      ...(defaultColumns[className] || {}),
+      ...fields
+    },
+    classLevelPermissions
+  };
+  if (indexes && Object.keys(indexes).length !== 0) {
+    defaultSchema.indexes = indexes;
+  }
+  return defaultSchema;
+};
+const _HooksSchema = {
+  className: '_Hooks',
+  fields: defaultColumns._Hooks
+};
+const _GlobalConfigSchema = {
+  className: '_GlobalConfig',
+  fields: defaultColumns._GlobalConfig
+};
+const _GraphQLConfigSchema = {
+  className: '_GraphQLConfig',
+  fields: defaultColumns._GraphQLConfig
+};
+const _PushStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
+  className: '_PushStatus',
+  fields: {},
+  classLevelPermissions: {}
+}));
+const _JobStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
+  className: '_JobStatus',
+  fields: {},
+  classLevelPermissions: {}
+}));
+const _JobScheduleSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
+  className: '_JobSchedule',
+  fields: {},
+  classLevelPermissions: {}
+}));
+const _AudienceSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
+  className: '_Audience',
+  fields: defaultColumns._Audience,
+  classLevelPermissions: {}
+}));
+const _IdempotencySchema = convertSchemaToAdapterSchema(injectDefaultSchema({
+  className: '_Idempotency',
+  fields: defaultColumns._Idempotency,
+  classLevelPermissions: {}
+}));
+const VolatileClassesSchemas = exports.VolatileClassesSchemas = [_HooksSchema, _JobStatusSchema, _JobScheduleSchema, _PushStatusSchema, _GlobalConfigSchema, _GraphQLConfigSchema, _AudienceSchema, _IdempotencySchema];
+const dbTypeMatchesObjectType = (dbType, objectType) => {
+  if (dbType.type !== objectType.type) {
+    return false;
+  }
+  if (dbType.targetClass !== objectType.targetClass) {
+    return false;
+  }
+  if (dbType === objectType.type) {
+    return true;
+  }
+  if (dbType.type === objectType.type) {
+    return true;
+  }
+  return false;
+};
+const typeToString = type => {
+  if (typeof type === 'string') {
+    return type;
+  }
+  if (type.targetClass) {
+    return `${type.type}<${type.targetClass}>`;
+  }
+  return `${type.type}`;
+};
+const ttl = {
+  date: Date.now(),
+  duration: undefined
+};
+
+// Stores the entire schema of the app in a weird hybrid format somewhere between
+// the mongo format and the Parse format. Soon, this will all be Parse format.
+class SchemaController {
+  constructor(databaseAdapter) {
+    this._dbAdapter = databaseAdapter;
+    const config = _Config.default.get(Parse.applicationId);
+    this.schemaData = new SchemaData(_SchemaCache.default.all(), this.protectedFields);
+    this.protectedFields = config.protectedFields;
+    const customIds = config.allowCustomObjectId;
+    const customIdRegEx = /^.{1,}$/u; // 1+ chars
+    const autoIdRegEx = /^[a-zA-Z0-9]{1,}$/;
+    this.userIdRegEx = customIds ? customIdRegEx : autoIdRegEx;
+    this._dbAdapter.watch(() => {
+      this.reloadData({
+        clearCache: true
+      });
+    });
+  }
+  async reloadDataIfNeeded() {
+    if (this._dbAdapter.enableSchemaHooks) {
+      return;
+    }
+    const {
+      date,
+      duration
+    } = ttl || {};
+    if (!duration) {
+      return;
+    }
+    const now = Date.now();
+    if (now - date > duration) {
+      ttl.date = now;
+      await this.reloadData({
+        clearCache: true
+      });
+    }
+  }
+  reloadData(options = {
+    clearCache: false
+  }) {
+    if (this.reloadDataPromise && !options.clearCache) {
+      return this.reloadDataPromise;
+    }
+    this.reloadDataPromise = this.getAllClasses(options).then(allSchemas => {
+      this.schemaData = new SchemaData(allSchemas, this.protectedFields);
+      delete this.reloadDataPromise;
+    }, err => {
+      this.schemaData = new SchemaData();
+      delete this.reloadDataPromise;
+      throw err;
+    }).then(() => {});
+    return this.reloadDataPromise;
+  }
+  async getAllClasses(options = {
+    clearCache: false
+  }) {
+    if (options.clearCache) {
+      return this.setAllClasses();
+    }
+    await this.reloadDataIfNeeded();
+    const cached = _SchemaCache.default.all();
+    if (cached && cached.length) {
+      return Promise.resolve(cached);
+    }
+    return this.setAllClasses();
+  }
+  setAllClasses() {
+    return this._dbAdapter.getAllClasses().then(allSchemas => allSchemas.map(injectDefaultSchema)).then(allSchemas => {
+      _SchemaCache.default.put(allSchemas);
+      return allSchemas;
+    });
+  }
+  getOneSchema(className, allowVolatileClasses = false, options = {
+    clearCache: false
+  }) {
+    if (options.clearCache) {
+      _SchemaCache.default.clear();
+    }
+    if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {
+      const data = this.schemaData[className];
+      return Promise.resolve({
+        className,
+        fields: data.fields,
+        classLevelPermissions: data.classLevelPermissions,
+        indexes: data.indexes
+      });
+    }
+    const cached = _SchemaCache.default.get(className);
+    if (cached && !options.clearCache) {
+      return Promise.resolve(cached);
+    }
+    return this.setAllClasses().then(allSchemas => {
+      const oneSchema = allSchemas.find(schema => schema.className === className);
+      if (!oneSchema) {
+        return Promise.reject(undefined);
+      }
+      return oneSchema;
+    });
+  }
+
+  // Create a new class that includes the three default fields.
+  // ACL is an implicit column that does not get an entry in the
+  // _SCHEMAS database. Returns a promise that resolves with the
+  // created schema, in mongo format.
+  // on success, and rejects with an error on fail. Ensure you
+  // have authorization (master key, or client class creation
+  // enabled) before calling this function.
+  async addClassIfNotExists(className, fields = {}, classLevelPermissions, indexes = {}) {
+    var validationError = this.validateNewClass(className, fields, classLevelPermissions);
+    if (validationError) {
+      if (validationError instanceof Parse.Error) {
+        return Promise.reject(validationError);
+      } else if (validationError.code && validationError.error) {
+        return Promise.reject(new Parse.Error(validationError.code, validationError.error));
+      }
+      return Promise.reject(validationError);
+    }
+    try {
+      const adapterSchema = await this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({
+        fields,
+        classLevelPermissions,
+        indexes,
+        className
+      }));
+      // TODO: Remove by updating schema cache directly
+      await this.reloadData({
+        clearCache: true
+      });
+      const parseSchema = convertAdapterSchemaToParseSchema(adapterSchema);
+      return parseSchema;
+    } catch (error) {
+      if (error && error.code === Parse.Error.DUPLICATE_VALUE) {
+        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);
+      } else {
+        throw error;
+      }
+    }
+  }
+  updateClass(className, submittedFields, classLevelPermissions, indexes, database) {
+    return this.getOneSchema(className).then(schema => {
+      const existingFields = schema.fields;
+      Object.keys(submittedFields).forEach(name => {
+        const field = submittedFields[name];
+        if (existingFields[name] && existingFields[name].type !== field.type && field.__op !== 'Delete') {
+          throw new Parse.Error(255, `Field ${name} exists, cannot update.`);
+        }
+        if (!existingFields[name] && field.__op === 'Delete') {
+          throw new Parse.Error(255, `Field ${name} does not exist, cannot delete.`);
+        }
+      });
+      delete existingFields._rperm;
+      delete existingFields._wperm;
+      const newSchema = buildMergedSchemaObject(existingFields, submittedFields);
+      const defaultFields = defaultColumns[className] || defaultColumns._Default;
+      const fullNewSchema = Object.assign({}, newSchema, defaultFields);
+      const validationError = this.validateSchemaData(className, newSchema, classLevelPermissions, Object.keys(existingFields));
+      if (validationError) {
+        throw new Parse.Error(validationError.code, validationError.error);
+      }
+
+      // Finally we have checked to make sure the request is valid and we can start deleting fields.
+      // Do all deletions first, then a single save to _SCHEMA collection to handle all additions.
+      const deletedFields = [];
+      const insertedFields = [];
+      Object.keys(submittedFields).forEach(fieldName => {
+        if (submittedFields[fieldName].__op === 'Delete') {
+          deletedFields.push(fieldName);
+        } else {
+          insertedFields.push(fieldName);
+        }
+      });
+      let deletePromise = Promise.resolve();
+      if (deletedFields.length > 0) {
+        deletePromise = this.deleteFields(deletedFields, className, database);
+      }
+      let enforceFields = [];
+      return deletePromise // Delete Everything
+      .then(() => this.reloadData({
+        clearCache: true
+      })) // Reload our Schema, so we have all the new values
+      .then(() => {
+        const promises = insertedFields.map(fieldName => {
+          const type = submittedFields[fieldName];
+          return this.enforceFieldExists(className, fieldName, type);
+        });
+        return Promise.all(promises);
+      }).then(results => {
+        enforceFields = results.filter(result => !!result);
+        return this.setPermissions(className, classLevelPermissions, newSchema);
+      }).then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, fullNewSchema)).then(() => this.reloadData({
+        clearCache: true
+      }))
+      //TODO: Move this logic into the database adapter
+      .then(() => {
+        this.ensureFields(enforceFields);
+        const schema = this.schemaData[className];
+        const reloadedSchema = {
+          className: className,
+          fields: schema.fields,
+          classLevelPermissions: schema.classLevelPermissions
+        };
+        if (schema.indexes && Object.keys(schema.indexes).length !== 0) {
+          reloadedSchema.indexes = schema.indexes;
+        }
+        return reloadedSchema;
+      });
+    }).catch(error => {
+      if (error === undefined) {
+        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);
+      } else {
+        throw error;
+      }
+    });
+  }
+
+  // Returns a promise that resolves successfully to the new schema
+  // object or fails with a reason.
+  enforceClassExists(className) {
+    if (this.schemaData[className]) {
+      return Promise.resolve(this);
+    }
+    // We don't have this class. Update the schema
+    return (
+      // The schema update succeeded. Reload the schema
+      this.addClassIfNotExists(className).catch(() => {
+        // The schema update failed. This can be okay - it might
+        // have failed because there's a race condition and a different
+        // client is making the exact same schema update that we want.
+        // So just reload the schema.
+        return this.reloadData({
+          clearCache: true
+        });
+      }).then(() => {
+        // Ensure that the schema now validates
+        if (this.schemaData[className]) {
+          return this;
+        } else {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, `Failed to add ${className}`);
+        }
+      }).catch(() => {
+        // The schema still doesn't validate. Give up
+        throw new Parse.Error(Parse.Error.INVALID_JSON, 'schema class name does not revalidate');
+      })
+    );
+  }
+  validateNewClass(className, fields = {}, classLevelPermissions) {
+    if (this.schemaData[className]) {
+      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);
+    }
+    if (!classNameIsValid(className)) {
+      return {
+        code: Parse.Error.INVALID_CLASS_NAME,
+        error: invalidClassNameMessage(className)
+      };
+    }
+    return this.validateSchemaData(className, fields, classLevelPermissions, []);
+  }
+  validateSchemaData(className, fields, classLevelPermissions, existingFieldNames) {
+    for (const fieldName in fields) {
+      if (existingFieldNames.indexOf(fieldName) < 0) {
+        if (!fieldNameIsValid(fieldName, className)) {
+          return {
+            code: Parse.Error.INVALID_KEY_NAME,
+            error: 'invalid field name: ' + fieldName
+          };
+        }
+        if (!fieldNameIsValidForClass(fieldName, className)) {
+          return {
+            code: 136,
+            error: 'field ' + fieldName + ' cannot be added'
+          };
+        }
+        const fieldType = fields[fieldName];
+        const error = fieldTypeIsInvalid(fieldType);
+        if (error) {
+          return {
+            code: error.code,
+            error: error.message
+          };
+        }
+        if (fieldType.defaultValue !== undefined) {
+          let defaultValueType = getType(fieldType.defaultValue);
+          if (typeof defaultValueType === 'string') {
+            defaultValueType = {
+              type: defaultValueType
+            };
+          } else if (typeof defaultValueType === 'object' && fieldType.type === 'Relation') {
+            return {
+              code: Parse.Error.INCORRECT_TYPE,
+              error: `The 'default value' option is not applicable for ${typeToString(fieldType)}`
+            };
+          }
+          if (!dbTypeMatchesObjectType(fieldType, defaultValueType)) {
+            return {
+              code: Parse.Error.INCORRECT_TYPE,
+              error: `schema mismatch for ${className}.${fieldName} default value; expected ${typeToString(fieldType)} but got ${typeToString(defaultValueType)}`
+            };
+          }
+        } else if (fieldType.required) {
+          if (typeof fieldType === 'object' && fieldType.type === 'Relation') {
+            return {
+              code: Parse.Error.INCORRECT_TYPE,
+              error: `The 'required' option is not applicable for ${typeToString(fieldType)}`
+            };
+          }
+        }
+      }
+    }
+    for (const fieldName in defaultColumns[className]) {
+      fields[fieldName] = defaultColumns[className][fieldName];
+    }
+    const geoPoints = Object.keys(fields).filter(key => fields[key] && fields[key].type === 'GeoPoint');
+    if (geoPoints.length > 1) {
+      return {
+        code: Parse.Error.INCORRECT_TYPE,
+        error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.'
+      };
+    }
+    validateCLP(classLevelPermissions, fields, this.userIdRegEx);
+  }
+
+  // Sets the Class-level permissions for a given className, which must exist.
+  async setPermissions(className, perms, newSchema) {
+    if (typeof perms === 'undefined') {
+      return Promise.resolve();
+    }
+    validateCLP(perms, newSchema, this.userIdRegEx);
+    await this._dbAdapter.setClassLevelPermissions(className, perms);
+    const cached = _SchemaCache.default.get(className);
+    if (cached) {
+      cached.classLevelPermissions = perms;
+    }
+  }
+
+  // Returns a promise that resolves successfully to the new schema
+  // object if the provided className-fieldName-type tuple is valid.
+  // The className must already be validated.
+  // If 'freeze' is true, refuse to update the schema for this field.
+  enforceFieldExists(className, fieldName, type, isValidation, maintenance) {
+    if (fieldName.indexOf('.') > 0) {
+      // "<array>.<index>" for Nested Arrays
+      // "<embedded document>.<field>" for Nested Objects
+      // JSON Arrays are treated as Nested Objects
+      const [x, y] = fieldName.split('.');
+      fieldName = x;
+      const isArrayIndex = Array.from(y).every(c => c >= '0' && c <= '9');
+      if (isArrayIndex && !['sentPerUTCOffset', 'failedPerUTCOffset'].includes(fieldName)) {
+        type = 'Array';
+      } else {
+        type = 'Object';
+      }
+    }
+    let fieldNameToValidate = `${fieldName}`;
+    if (maintenance && fieldNameToValidate.charAt(0) === '_') {
+      fieldNameToValidate = fieldNameToValidate.substring(1);
+    }
+    if (!fieldNameIsValid(fieldNameToValidate, className)) {
+      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`);
+    }
+
+    // If someone tries to create a new field with null/undefined as the value, return;
+    if (!type) {
+      return undefined;
+    }
+    const expectedType = this.getExpectedType(className, fieldName);
+    if (typeof type === 'string') {
+      type = {
+        type
+      };
+    }
+    if (type.defaultValue !== undefined) {
+      let defaultValueType = getType(type.defaultValue);
+      if (typeof defaultValueType === 'string') {
+        defaultValueType = {
+          type: defaultValueType
+        };
+      }
+      if (!dbTypeMatchesObjectType(type, defaultValueType)) {
+        throw new Parse.Error(Parse.Error.INCORRECT_TYPE, `schema mismatch for ${className}.${fieldName} default value; expected ${typeToString(type)} but got ${typeToString(defaultValueType)}`);
+      }
+    }
+    if (expectedType) {
+      if (!dbTypeMatchesObjectType(expectedType, type)) {
+        throw new Parse.Error(Parse.Error.INCORRECT_TYPE, `schema mismatch for ${className}.${fieldName}; expected ${typeToString(expectedType)} but got ${typeToString(type)}`);
+      }
+      // If type options do not change
+      // we can safely return
+      if (isValidation || JSON.stringify(expectedType) === JSON.stringify(type)) {
+        return undefined;
+      }
+      // Field options are may be changed
+      // ensure to have an update to date schema field
+      return this._dbAdapter.updateFieldOptions(className, fieldName, type);
+    }
+    return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).catch(error => {
+      if (error.code == Parse.Error.INCORRECT_TYPE) {
+        // Make sure that we throw errors when it is appropriate to do so.
+        throw error;
+      }
+      // The update failed. This can be okay - it might have been a race
+      // condition where another client updated the schema in the same
+      // way that we wanted to. So, just reload the schema
+      return Promise.resolve();
+    }).then(() => {
+      return {
+        className,
+        fieldName,
+        type
+      };
+    });
+  }
+  ensureFields(fields) {
+    for (let i = 0; i < fields.length; i += 1) {
+      const {
+        className,
+        fieldName
+      } = fields[i];
+      let {
+        type
+      } = fields[i];
+      const expectedType = this.getExpectedType(className, fieldName);
+      if (typeof type === 'string') {
+        type = {
+          type: type
+        };
+      }
+      if (!expectedType || !dbTypeMatchesObjectType(expectedType, type)) {
+        throw new Parse.Error(Parse.Error.INVALID_JSON, `Could not add field ${fieldName}`);
+      }
+    }
+  }
+
+  // maintain compatibility
+  deleteField(fieldName, className, database) {
+    return this.deleteFields([fieldName], className, database);
+  }
+
+  // Delete fields, and remove that data from all objects. This is intended
+  // to remove unused fields, if other writers are writing objects that include
+  // this field, the field may reappear. Returns a Promise that resolves with
+  // no object on success, or rejects with { code, error } on failure.
+  // Passing the database and prefix is necessary in order to drop relation collections
+  // and remove fields from objects. Ideally the database would belong to
+  // a database adapter and this function would close over it or access it via member.
+  deleteFields(fieldNames, className, database) {
+    if (!classNameIsValid(className)) {
+      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(className));
+    }
+    fieldNames.forEach(fieldName => {
+      if (!fieldNameIsValid(fieldName, className)) {
+        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `invalid field name: ${fieldName}`);
+      }
+      //Don't allow deleting the default fields.
+      if (!fieldNameIsValidForClass(fieldName, className)) {
+        throw new Parse.Error(136, `field ${fieldName} cannot be changed`);
+      }
+    });
+    return this.getOneSchema(className, false, {
+      clearCache: true
+    }).catch(error => {
+      if (error === undefined) {
+        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);
+      } else {
+        throw error;
+      }
+    }).then(schema => {
+      fieldNames.forEach(fieldName => {
+        if (!schema.fields[fieldName]) {
+          throw new Parse.Error(255, `Field ${fieldName} does not exist, cannot delete.`);
+        }
+      });
+      const schemaFields = {
+        ...schema.fields
+      };
+      return database.adapter.deleteFields(className, schema, fieldNames).then(() => {
+        return Promise.all(fieldNames.map(fieldName => {
+          const field = schemaFields[fieldName];
+          if (field && field.type === 'Relation') {
+            //For relations, drop the _Join table
+            return database.adapter.deleteClass(`_Join:${fieldName}:${className}`);
+          }
+          return Promise.resolve();
+        }));
+      });
+    }).then(() => {
+      _SchemaCache.default.clear();
+    });
+  }
+
+  // Validates an object provided in REST format.
+  // Returns a promise that resolves to the new schema if this object is
+  // valid.
+  async validateObject(className, object, query, maintenance) {
+    let geocount = 0;
+    const schema = await this.enforceClassExists(className);
+    const promises = [];
+    for (const fieldName in object) {
+      if (object[fieldName] && getType(object[fieldName]) === 'GeoPoint') {
+        geocount++;
+      }
+      if (geocount > 1) {
+        return Promise.reject(new Parse.Error(Parse.Error.INCORRECT_TYPE, 'there can only be one geopoint field in a class'));
+      }
+    }
+    for (const fieldName in object) {
+      if (object[fieldName] === undefined) {
+        continue;
+      }
+      const expected = getType(object[fieldName]);
+      if (!expected) {
+        continue;
+      }
+      if (fieldName === 'ACL') {
+        // Every object has ACL implicitly.
+        continue;
+      }
+      promises.push(schema.enforceFieldExists(className, fieldName, expected, true, maintenance));
+    }
+    const results = await Promise.all(promises);
+    const enforceFields = results.filter(result => !!result);
+    if (enforceFields.length !== 0) {
+      // TODO: Remove by updating schema cache directly
+      await this.reloadData({
+        clearCache: true
+      });
+    }
+    this.ensureFields(enforceFields);
+    const promise = Promise.resolve(schema);
+    return thenValidateRequiredColumns(promise, className, object, query);
+  }
+
+  // Validates that all the properties are set for the object
+  validateRequiredColumns(className, object, query) {
+    const columns = requiredColumns.write[className];
+    if (!columns || columns.length == 0) {
+      return Promise.resolve(this);
+    }
+    const missingColumns = columns.filter(function (column) {
+      if (query && query.objectId) {
+        if (object[column] && typeof object[column] === 'object') {
+          // Trying to delete a required column
+          return object[column].__op == 'Delete';
+        }
+        // Not trying to do anything there
+        return false;
+      }
+      return !object[column];
+    });
+    if (missingColumns.length > 0) {
+      throw new Parse.Error(Parse.Error.INCORRECT_TYPE, missingColumns[0] + ' is required.');
+    }
+    return Promise.resolve(this);
+  }
+  testPermissionsForClassName(className, aclGroup, operation) {
+    return SchemaController.testPermissions(this.getClassLevelPermissions(className), aclGroup, operation);
+  }
+
+  // Tests that the class level permission let pass the operation for a given aclGroup
+  static testPermissions(classPermissions, aclGroup, operation) {
+    if (!classPermissions || !classPermissions[operation]) {
+      return true;
+    }
+    const perms = classPermissions[operation];
+    if (perms['*']) {
+      return true;
+    }
+    // Check permissions against the aclGroup provided (array of userId/roles)
+    if (aclGroup.some(acl => {
+      return perms[acl] === true;
+    })) {
+      return true;
+    }
+    return false;
+  }
+
+  // Validates an operation passes class-level-permissions set in the schema
+  static validatePermission(classPermissions, className, aclGroup, operation, action) {
+    if (SchemaController.testPermissions(classPermissions, aclGroup, operation)) {
+      return Promise.resolve();
+    }
+    if (!classPermissions || !classPermissions[operation]) {
+      return true;
+    }
+    const perms = classPermissions[operation];
+    const config = _Config.default.get(Parse.applicationId);
+    // If only for authenticated users
+    // make sure we have an aclGroup
+    if (perms['requiresAuthentication']) {
+      // If aclGroup has * (public)
+      if (!aclGroup || aclGroup.length == 0) {
+        throw (0, _Error.createSanitizedError)(Parse.Error.OBJECT_NOT_FOUND, 'Permission denied, user needs to be authenticated.', config);
+      } else if (aclGroup.indexOf('*') > -1 && aclGroup.length == 1) {
+        throw (0, _Error.createSanitizedError)(Parse.Error.OBJECT_NOT_FOUND, 'Permission denied, user needs to be authenticated.', config);
+      }
+      // requiresAuthentication passed, just move forward
+      // probably would be wise at some point to rename to 'authenticatedUser'
+      return Promise.resolve();
+    }
+
+    // No matching CLP, let's check the Pointer permissions
+    // And handle those later
+    const permissionField = ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';
+
+    // Reject create when write lockdown
+    if (permissionField == 'writeUserFields' && operation == 'create') {
+      throw (0, _Error.createSanitizedError)(Parse.Error.OPERATION_FORBIDDEN, `Permission denied for action ${operation} on class ${className}.`, config);
+    }
+
+    // Process the readUserFields later
+    if (Array.isArray(classPermissions[permissionField]) && classPermissions[permissionField].length > 0) {
+      return Promise.resolve();
+    }
+    const pointerFields = classPermissions[operation].pointerFields;
+    if (Array.isArray(pointerFields) && pointerFields.length > 0) {
+      // any op except 'addField as part of create' is ok.
+      if (operation !== 'addField' || action === 'update') {
+        // We can allow adding field on update flow only.
+        return Promise.resolve();
+      }
+    }
+    throw (0, _Error.createSanitizedError)(Parse.Error.OPERATION_FORBIDDEN, `Permission denied for action ${operation} on class ${className}.`, config);
+  }
+
+  // Validates an operation passes class-level-permissions set in the schema
+  validatePermission(className, aclGroup, operation, action) {
+    return SchemaController.validatePermission(this.getClassLevelPermissions(className), className, aclGroup, operation, action);
+  }
+  getClassLevelPermissions(className) {
+    return this.schemaData[className] && this.schemaData[className].classLevelPermissions;
+  }
+
+  // Returns the expected type for a className+key combination
+  // or undefined if the schema is not set
+  getExpectedType(className, fieldName) {
+    if (this.schemaData[className]) {
+      const expectedType = this.schemaData[className].fields[fieldName];
+      return expectedType === 'map' ? 'Object' : expectedType;
+    }
+    return undefined;
+  }
+
+  // Checks if a given class is in the schema.
+  hasClass(className) {
+    if (this.schemaData[className]) {
+      return Promise.resolve(true);
+    }
+    return this.reloadData().then(() => !!this.schemaData[className]);
+  }
+}
+
+// Returns a promise for a new Schema.
+exports.SchemaController = exports.default = SchemaController;
+const load = (dbAdapter, options) => {
+  const schema = new SchemaController(dbAdapter);
+  ttl.duration = dbAdapter.schemaCacheTtl;
+  return schema.reloadData(options).then(() => schema);
+};
+
+// Builds a new schema (in schema API response format) out of an
+// existing mongo schema + a schemas API put request. This response
+// does not include the default fields, as it is intended to be passed
+// to mongoSchemaFromFieldsAndClassName. No validation is done here, it
+// is done in mongoSchemaFromFieldsAndClassName.
+exports.load = load;
+function buildMergedSchemaObject(existingFields, putRequest) {
+  const newSchema = {};
+  // -disable-next
+  const sysSchemaField = Object.keys(defaultColumns).indexOf(existingFields._id) === -1 ? [] : Object.keys(defaultColumns[existingFields._id]);
+  for (const oldField in existingFields) {
+    if (oldField !== '_id' && oldField !== 'ACL' && oldField !== 'updatedAt' && oldField !== 'createdAt' && oldField !== 'objectId') {
+      if (sysSchemaField.length > 0 && sysSchemaField.indexOf(oldField) !== -1) {
+        continue;
+      }
+      const fieldIsDeleted = putRequest[oldField] && putRequest[oldField].__op === 'Delete';
+      if (!fieldIsDeleted) {
+        newSchema[oldField] = existingFields[oldField];
+      }
+    }
+  }
+  for (const newField in putRequest) {
+    if (newField !== 'objectId' && putRequest[newField].__op !== 'Delete') {
+      if (sysSchemaField.length > 0 && sysSchemaField.indexOf(newField) !== -1) {
+        continue;
+      }
+      newSchema[newField] = putRequest[newField];
+    }
+  }
+  return newSchema;
+}
+
+// Given a schema promise, construct another schema promise that
+// validates this field once the schema loads.
+function thenValidateRequiredColumns(schemaPromise, className, object, query) {
+  return schemaPromise.then(schema => {
+    return schema.validateRequiredColumns(className, object, query);
+  });
+}
+
+// Gets the type from a REST API formatted object, where 'type' is
+// extended past javascript types to include the rest of the Parse
+// type system.
+// The output should be a valid schema value.
+// TODO: ensure that this is compatible with the format used in Open DB
+function getType(obj) {
+  const type = typeof obj;
+  switch (type) {
+    case 'boolean':
+      return 'Boolean';
+    case 'string':
+      return 'String';
+    case 'number':
+      return 'Number';
+    case 'map':
+    case 'object':
+      if (!obj) {
+        return undefined;
+      }
+      return getObjectType(obj);
+    case 'function':
+    case 'symbol':
+    case 'undefined':
+    default:
+      throw 'bad obj: ' + obj;
+  }
+}
+
+// This gets the type for non-JSON types like pointers and files, but
+// also gets the appropriate type for $ operators.
+// Returns null if the type is unknown.
+function getObjectType(obj) {
+  if (Array.isArray(obj)) {
+    return 'Array';
+  }
+  if (obj.__type) {
+    switch (obj.__type) {
+      case 'Pointer':
+        if (obj.className) {
+          return {
+            type: 'Pointer',
+            targetClass: obj.className
+          };
+        }
+        break;
+      case 'Relation':
+        if (obj.className) {
+          return {
+            type: 'Relation',
+            targetClass: obj.className
+          };
+        }
+        break;
+      case 'File':
+        if (obj.name) {
+          return 'File';
+        }
+        break;
+      case 'Date':
+        if (obj.iso) {
+          return 'Date';
+        }
+        break;
+      case 'GeoPoint':
+        if (obj.latitude != null && obj.longitude != null) {
+          return 'GeoPoint';
+        }
+        break;
+      case 'Bytes':
+        if (obj.base64) {
+          return 'Bytes';
+        }
+        break;
+      case 'Polygon':
+        if (obj.coordinates) {
+          return 'Polygon';
+        }
+        break;
+    }
+    throw new Parse.Error(Parse.Error.INCORRECT_TYPE, 'This is not a valid ' + obj.__type);
+  }
+  if (obj['$ne']) {
+    return getObjectType(obj['$ne']);
+  }
+  if (obj.__op) {
+    switch (obj.__op) {
+      case 'Increment':
+        return 'Number';
+      case 'Delete':
+        return null;
+      case 'Add':
+      case 'AddUnique':
+      case 'Remove':
+        return 'Array';
+      case 'AddRelation':
+      case 'RemoveRelation':
+        return {
+          type: 'Relation',
+          targetClass: obj.objects[0].className
+        };
+      case 'Batch':
+        return getObjectType(obj.ops[0]);
+      default:
+        throw 'unexpected op: ' + obj.__op;
+    }
+  }
+  return 'Object';
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_StorageAdapter","require","_SchemaCache","_interopRequireDefault","_DatabaseController","_Config","_Error","e","__esModule","default","Parse","defaultColumns","exports","Object","freeze","_Default","objectId","type","createdAt","updatedAt","ACL","_User","username","password","email","emailVerified","authData","_Installation","installationId","deviceToken","channels","deviceType","pushType","GCMSenderId","timeZone","localeIdentifier","badge","appVersion","appName","appIdentifier","parseVersion","_Role","name","users","targetClass","roles","_Session","user","sessionToken","expiresAt","createdWith","_Product","productIdentifier","download","downloadName","icon","order","title","subtitle","_PushStatus","pushTime","source","query","payload","expiry","expiration_interval","status","numSent","numFailed","pushHash","errorMessage","sentPerType","failedPerType","sentPerUTCOffset","failedPerUTCOffset","count","_JobStatus","jobName","message","params","finishedAt","_JobSchedule","description","startAfter","daysOfWeek","timeOfDay","lastRun","repeatMinutes","_Hooks","functionName","className","triggerName","url","_GlobalConfig","masterKeyOnly","_GraphQLConfig","config","_Audience","lastUsed","timesUsed","_Idempotency","reqId","expire","requiredColumns","read","write","invalidColumns","systemClasses","volatileClasses","roleRegex","protectedFieldsPointerRegex","publicRegex","authenticatedRegex","requiresAuthenticationRegex","clpPointerRegex","protectedFieldsRegex","clpFieldsRegex","validatePermissionKey","key","userIdRegExp","matchesSome","regEx","match","valid","Error","INVALID_JSON","validateProtectedFieldsKey","CLPValidKeys","validateCLP","perms","fields","operationKey","indexOf","operation","validateCLPjson","fieldName","validatePointerPermission","entity","protectedFields","Array","isArray","field","prototype","hasOwnProperty","call","pointerFields","pointerField","permit","toString","invalidKeys","keys","filter","includes","invalidValues","values","length","join","joinClassRegex","classAndFieldRegex","classNameIsValid","test","fieldNameIsValid","fieldNameIsValidForClass","invalidClassNameMessage","invalidJsonError","validNonRelationOrPointerTypes","fieldTypeIsInvalid","INVALID_CLASS_NAME","undefined","INCORRECT_TYPE","convertSchemaToAdapterSchema","schema","injectDefaultSchema","_rperm","_wperm","_hashed_password","convertAdapterSchemaToParseSchema","indexes","SchemaData","constructor","allSchemas","__data","__protectedFields","forEach","defineProperty","get","data","classLevelPermissions","structuredClone","classProtectedFields","unq","Set","from","defaultSchema","_HooksSchema","_GlobalConfigSchema","_GraphQLConfigSchema","_PushStatusSchema","_JobStatusSchema","_JobScheduleSchema","_AudienceSchema","_IdempotencySchema","VolatileClassesSchemas","dbTypeMatchesObjectType","dbType","objectType","typeToString","ttl","date","Date","now","duration","SchemaController","databaseAdapter","_dbAdapter","Config","applicationId","schemaData","SchemaCache","all","customIds","allowCustomObjectId","customIdRegEx","autoIdRegEx","userIdRegEx","watch","reloadData","clearCache","reloadDataIfNeeded","enableSchemaHooks","options","reloadDataPromise","getAllClasses","then","err","setAllClasses","cached","Promise","resolve","map","put","getOneSchema","allowVolatileClasses","clear","oneSchema","find","reject","addClassIfNotExists","validationError","validateNewClass","code","error","adapterSchema","createClass","parseSchema","DUPLICATE_VALUE","updateClass","submittedFields","database","existingFields","__op","newSchema","buildMergedSchemaObject","defaultFields","fullNewSchema","assign","validateSchemaData","deletedFields","insertedFields","push","deletePromise","deleteFields","enforceFields","promises","enforceFieldExists","results","result","setPermissions","setIndexesWithSchemaFormat","ensureFields","reloadedSchema","catch","enforceClassExists","existingFieldNames","INVALID_KEY_NAME","fieldType","defaultValue","defaultValueType","getType","required","geoPoints","setClassLevelPermissions","isValidation","maintenance","x","y","split","isArrayIndex","every","c","fieldNameToValidate","charAt","substring","expectedType","getExpectedType","JSON","stringify","updateFieldOptions","addFieldIfNotExists","i","deleteField","fieldNames","schemaFields","adapter","deleteClass","validateObject","object","geocount","expected","promise","thenValidateRequiredColumns","validateRequiredColumns","columns","missingColumns","column","testPermissionsForClassName","aclGroup","testPermissions","getClassLevelPermissions","classPermissions","some","acl","validatePermission","action","createSanitizedError","OBJECT_NOT_FOUND","permissionField","OPERATION_FORBIDDEN","hasClass","load","dbAdapter","schemaCacheTtl","putRequest","sysSchemaField","_id","oldField","fieldIsDeleted","newField","schemaPromise","obj","getObjectType","__type","iso","latitude","longitude","base64","coordinates","objects","ops"],"sources":["../../src/Controllers/SchemaController.js"],"sourcesContent":["// @flow\n// This class handles schema validation, persistence, and modification.\n//\n// Each individual Schema object should be immutable. The helpers to\n// do things with the Schema just return a new schema when the schema\n// is changed.\n//\n// The canonical place to store this Schema is in the database itself,\n// in a _SCHEMA collection. This is not the right way to do it for an\n// open source framework, but it's backward compatible, so we're\n// keeping it this way for now.\n//\n// In API-handling code, you should only use the Schema class via the\n// DatabaseController. This will let us replace the schema logic for\n// different databases.\n// TODO: hide all schema logic inside the database adapter.\n// @flow-disable-next\nconst Parse = require('parse/node').Parse;\nimport { StorageAdapter } from '../Adapters/Storage/StorageAdapter';\nimport SchemaCache from '../Adapters/Cache/SchemaCache';\nimport DatabaseController from './DatabaseController';\nimport Config from '../Config';\nimport { createSanitizedError } from '../Error';\nimport type {\n  Schema,\n  SchemaFields,\n  ClassLevelPermissions,\n  SchemaField,\n  LoadSchemaOptions,\n} from './types';\n\nconst defaultColumns: { [string]: SchemaFields } = Object.freeze({\n  // Contain the default columns for every parse object type (except _Join collection)\n  _Default: {\n    objectId: { type: 'String' },\n    createdAt: { type: 'Date' },\n    updatedAt: { type: 'Date' },\n    ACL: { type: 'ACL' },\n  },\n  // The additional default columns for the _User collection (in addition to DefaultCols)\n  _User: {\n    username: { type: 'String' },\n    password: { type: 'String' },\n    email: { type: 'String' },\n    emailVerified: { type: 'Boolean' },\n    authData: { type: 'Object' },\n  },\n  // The additional default columns for the _Installation collection (in addition to DefaultCols)\n  _Installation: {\n    installationId: { type: 'String' },\n    deviceToken: { type: 'String' },\n    channels: { type: 'Array' },\n    deviceType: { type: 'String' },\n    pushType: { type: 'String' },\n    GCMSenderId: { type: 'String' },\n    timeZone: { type: 'String' },\n    localeIdentifier: { type: 'String' },\n    badge: { type: 'Number' },\n    appVersion: { type: 'String' },\n    appName: { type: 'String' },\n    appIdentifier: { type: 'String' },\n    parseVersion: { type: 'String' },\n  },\n  // The additional default columns for the _Role collection (in addition to DefaultCols)\n  _Role: {\n    name: { type: 'String' },\n    users: { type: 'Relation', targetClass: '_User' },\n    roles: { type: 'Relation', targetClass: '_Role' },\n  },\n  // The additional default columns for the _Session collection (in addition to DefaultCols)\n  _Session: {\n    user: { type: 'Pointer', targetClass: '_User' },\n    installationId: { type: 'String' },\n    sessionToken: { type: 'String' },\n    expiresAt: { type: 'Date' },\n    createdWith: { type: 'Object' },\n  },\n  _Product: {\n    productIdentifier: { type: 'String' },\n    download: { type: 'File' },\n    downloadName: { type: 'String' },\n    icon: { type: 'File' },\n    order: { type: 'Number' },\n    title: { type: 'String' },\n    subtitle: { type: 'String' },\n  },\n  _PushStatus: {\n    pushTime: { type: 'String' },\n    source: { type: 'String' }, // rest or webui\n    query: { type: 'String' }, // the stringified JSON query\n    payload: { type: 'String' }, // the stringified JSON payload,\n    title: { type: 'String' },\n    expiry: { type: 'Number' },\n    expiration_interval: { type: 'Number' },\n    status: { type: 'String' },\n    numSent: { type: 'Number' },\n    numFailed: { type: 'Number' },\n    pushHash: { type: 'String' },\n    errorMessage: { type: 'Object' },\n    sentPerType: { type: 'Object' },\n    failedPerType: { type: 'Object' },\n    sentPerUTCOffset: { type: 'Object' },\n    failedPerUTCOffset: { type: 'Object' },\n    count: { type: 'Number' }, // tracks # of batches queued and pending\n  },\n  _JobStatus: {\n    jobName: { type: 'String' },\n    source: { type: 'String' },\n    status: { type: 'String' },\n    message: { type: 'String' },\n    params: { type: 'Object' }, // params received when calling the job\n    finishedAt: { type: 'Date' },\n  },\n  _JobSchedule: {\n    jobName: { type: 'String' },\n    description: { type: 'String' },\n    params: { type: 'String' },\n    startAfter: { type: 'String' },\n    daysOfWeek: { type: 'Array' },\n    timeOfDay: { type: 'String' },\n    lastRun: { type: 'Number' },\n    repeatMinutes: { type: 'Number' },\n  },\n  _Hooks: {\n    functionName: { type: 'String' },\n    className: { type: 'String' },\n    triggerName: { type: 'String' },\n    url: { type: 'String' },\n  },\n  _GlobalConfig: {\n    objectId: { type: 'String' },\n    params: { type: 'Object' },\n    masterKeyOnly: { type: 'Object' },\n  },\n  _GraphQLConfig: {\n    objectId: { type: 'String' },\n    config: { type: 'Object' },\n  },\n  _Audience: {\n    objectId: { type: 'String' },\n    name: { type: 'String' },\n    query: { type: 'String' }, //storing query as JSON string to prevent \"Nested keys should not contain the '$' or '.' characters\" error\n    lastUsed: { type: 'Date' },\n    timesUsed: { type: 'Number' },\n  },\n  _Idempotency: {\n    reqId: { type: 'String' },\n    expire: { type: 'Date' },\n  },\n});\n\n// fields required for read or write operations on their respective classes.\nconst requiredColumns = Object.freeze({\n  read: {\n    _User: ['username'],\n  },\n  write: {\n    _Product: ['productIdentifier', 'icon', 'order', 'title', 'subtitle'],\n    _Role: ['name', 'ACL'],\n  },\n});\n\nconst invalidColumns = ['length'];\n\nconst systemClasses = Object.freeze([\n  '_User',\n  '_Installation',\n  '_Role',\n  '_Session',\n  '_Product',\n  '_PushStatus',\n  '_JobStatus',\n  '_JobSchedule',\n  '_Audience',\n  '_Idempotency',\n]);\n\nconst volatileClasses = Object.freeze([\n  '_JobStatus',\n  '_PushStatus',\n  '_Hooks',\n  '_GlobalConfig',\n  '_GraphQLConfig',\n  '_JobSchedule',\n  '_Audience',\n  '_Idempotency',\n]);\n\n// Anything that start with role\nconst roleRegex = /^role:.*/;\n// Anything that starts with userField (allowed for protected fields only)\nconst protectedFieldsPointerRegex = /^userField:.*/;\n// * permission\nconst publicRegex = /^\\*$/;\n\nconst authenticatedRegex = /^authenticated$/;\n\nconst requiresAuthenticationRegex = /^requiresAuthentication$/;\n\nconst clpPointerRegex = /^pointerFields$/;\n\n// regex for validating entities in protectedFields object\nconst protectedFieldsRegex = Object.freeze([\n  protectedFieldsPointerRegex,\n  publicRegex,\n  authenticatedRegex,\n  roleRegex,\n]);\n\n// clp regex\nconst clpFieldsRegex = Object.freeze([\n  clpPointerRegex,\n  publicRegex,\n  requiresAuthenticationRegex,\n  roleRegex,\n]);\n\nfunction validatePermissionKey(key, userIdRegExp) {\n  let matchesSome = false;\n  for (const regEx of clpFieldsRegex) {\n    if (key.match(regEx) !== null) {\n      matchesSome = true;\n      break;\n    }\n  }\n\n  // userId depends on startup options so it's dynamic\n  const valid = matchesSome || key.match(userIdRegExp) !== null;\n  if (!valid) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_JSON,\n      `'${key}' is not a valid key for class level permissions`\n    );\n  }\n}\n\nfunction validateProtectedFieldsKey(key, userIdRegExp) {\n  let matchesSome = false;\n  for (const regEx of protectedFieldsRegex) {\n    if (key.match(regEx) !== null) {\n      matchesSome = true;\n      break;\n    }\n  }\n\n  // userId regex depends on launch options so it's dynamic\n  const valid = matchesSome || key.match(userIdRegExp) !== null;\n  if (!valid) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_JSON,\n      `'${key}' is not a valid key for class level permissions`\n    );\n  }\n}\n\nconst CLPValidKeys = Object.freeze([\n  'ACL',\n  'find',\n  'count',\n  'get',\n  'create',\n  'update',\n  'delete',\n  'addField',\n  'readUserFields',\n  'writeUserFields',\n  'protectedFields',\n]);\n\n// validation before setting class-level permissions on collection\nfunction validateCLP(perms: ClassLevelPermissions, fields: SchemaFields, userIdRegExp: RegExp) {\n  if (!perms) {\n    return;\n  }\n  for (const operationKey in perms) {\n    if (CLPValidKeys.indexOf(operationKey) == -1) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_JSON,\n        `${operationKey} is not a valid operation for class level permissions`\n      );\n    }\n\n    const operation = perms[operationKey];\n    // proceed with next operationKey\n\n    // throws when root fields are of wrong type\n    validateCLPjson(operation, operationKey);\n\n    if (operationKey === 'readUserFields' || operationKey === 'writeUserFields') {\n      // validate grouped pointer permissions\n      // must be an array with field names\n      for (const fieldName of operation) {\n        validatePointerPermission(fieldName, fields, operationKey);\n      }\n      // readUserFields and writerUserFields do not have nesdted fields\n      // proceed with next operationKey\n      continue;\n    }\n\n    // validate protected fields\n    if (operationKey === 'protectedFields') {\n      for (const entity in operation) {\n        // throws on unexpected key\n        validateProtectedFieldsKey(entity, userIdRegExp);\n\n        const protectedFields = operation[entity];\n\n        if (!Array.isArray(protectedFields)) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `'${protectedFields}' is not a valid value for protectedFields[${entity}] - expected an array.`\n          );\n        }\n\n        // if the field is in form of array\n        for (const field of protectedFields) {\n          // do not alloow to protect default fields\n          if (defaultColumns._Default[field]) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              `Default field '${field}' can not be protected`\n            );\n          }\n          // field should exist on collection\n          if (!Object.prototype.hasOwnProperty.call(fields, field)) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              `Field '${field}' in protectedFields:${entity} does not exist`\n            );\n          }\n        }\n      }\n      // proceed with next operationKey\n      continue;\n    }\n\n    // validate other fields\n    // Entity can be:\n    // \"*\" - Public,\n    // \"requiresAuthentication\" - authenticated users,\n    // \"objectId\" - _User id,\n    // \"role:rolename\",\n    // \"pointerFields\" - array of field names containing pointers to users\n    for (const entity in operation) {\n      // throws on unexpected key\n      validatePermissionKey(entity, userIdRegExp);\n\n      // entity can be either:\n      // \"pointerFields\": string[]\n      if (entity === 'pointerFields') {\n        const pointerFields = operation[entity];\n\n        if (Array.isArray(pointerFields)) {\n          for (const pointerField of pointerFields) {\n            validatePointerPermission(pointerField, fields, operation);\n          }\n        } else {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `'${pointerFields}' is not a valid value for ${operationKey}[${entity}] - expected an array.`\n          );\n        }\n        // proceed with next entity key\n        continue;\n      }\n\n      const permit = operation[entity];\n\n      if (operationKey === 'ACL') {\n        if (Object.prototype.toString.call(permit) !== '[object Object]') {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `'${permit}' is not a valid value for class level permissions acl`\n          );\n        }\n        const invalidKeys = Object.keys(permit).filter(key => !['read', 'write'].includes(key));\n        const invalidValues = Object.values(permit).filter(key => typeof key !== 'boolean');\n        if (invalidKeys.length) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `'${invalidKeys.join(',')}' is not a valid key for class level permissions acl`\n          );\n        }\n\n        if (invalidValues.length) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `'${invalidValues.join(',')}' is not a valid value for class level permissions acl`\n          );\n        }\n      } else if (permit !== true) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `'${permit}' is not a valid value for class level permissions acl ${operationKey}:${entity}`\n        );\n      }\n    }\n  }\n}\n\nfunction validateCLPjson(operation: any, operationKey: string) {\n  if (operationKey === 'readUserFields' || operationKey === 'writeUserFields') {\n    if (!Array.isArray(operation)) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_JSON,\n        `'${operation}' is not a valid value for class level permissions ${operationKey} - must be an array`\n      );\n    }\n  } else {\n    if (typeof operation === 'object' && operation !== null) {\n      // ok to proceed\n      return;\n    } else {\n      throw new Parse.Error(\n        Parse.Error.INVALID_JSON,\n        `'${operation}' is not a valid value for class level permissions ${operationKey} - must be an object`\n      );\n    }\n  }\n}\n\nfunction validatePointerPermission(fieldName: string, fields: Object, operation: string) {\n  // Uses collection schema to ensure the field is of type:\n  // - Pointer<_User> (pointers)\n  // - Array\n  //\n  //    It's not possible to enforce type on Array's items in schema\n  //  so we accept any Array field, and later when applying permissions\n  //  only items that are pointers to _User are considered.\n  if (\n    !(\n      fields[fieldName] &&\n      ((fields[fieldName].type == 'Pointer' && fields[fieldName].targetClass == '_User') ||\n        fields[fieldName].type == 'Array')\n    )\n  ) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_JSON,\n      `'${fieldName}' is not a valid column for class level pointer permissions ${operation}`\n    );\n  }\n}\n\nconst joinClassRegex = /^_Join:[A-Za-z0-9_]+:[A-Za-z0-9_]+/;\nconst classAndFieldRegex = /^[A-Za-z][A-Za-z0-9_]*$/;\nfunction classNameIsValid(className: string): boolean {\n  // Valid classes must:\n  return (\n    // Be one of _User, _Installation, _Role, _Session OR\n    systemClasses.indexOf(className) > -1 ||\n    // Be a join table OR\n    joinClassRegex.test(className) ||\n    // Include only alpha-numeric and underscores, and not start with an underscore or number\n    fieldNameIsValid(className, className)\n  );\n}\n\n// Valid fields must be alpha-numeric, and not start with an underscore or number\n// must not be a reserved key\nfunction fieldNameIsValid(fieldName: string, className: string): boolean {\n  if (className && className !== '_Hooks') {\n    if (fieldName === 'className') {\n      return false;\n    }\n  }\n  return classAndFieldRegex.test(fieldName) && !invalidColumns.includes(fieldName);\n}\n\n// Checks that it's not trying to clobber one of the default fields of the class.\nfunction fieldNameIsValidForClass(fieldName: string, className: string): boolean {\n  if (!fieldNameIsValid(fieldName, className)) {\n    return false;\n  }\n  if (defaultColumns._Default[fieldName]) {\n    return false;\n  }\n  if (defaultColumns[className] && defaultColumns[className][fieldName]) {\n    return false;\n  }\n  return true;\n}\n\nfunction invalidClassNameMessage(className: string): string {\n  return (\n    'Invalid classname: ' +\n    className +\n    ', classnames can only have alphanumeric characters and _, and must start with an alpha character '\n  );\n}\n\nconst invalidJsonError = new Parse.Error(Parse.Error.INVALID_JSON, 'invalid JSON');\nconst validNonRelationOrPointerTypes = [\n  'Number',\n  'String',\n  'Boolean',\n  'Date',\n  'Object',\n  'Array',\n  'GeoPoint',\n  'File',\n  'Bytes',\n  'Polygon',\n];\n// Returns an error suitable for throwing if the type is invalid\nconst fieldTypeIsInvalid = ({ type, targetClass }) => {\n  if (['Pointer', 'Relation'].indexOf(type) >= 0) {\n    if (!targetClass) {\n      return new Parse.Error(135, `type ${type} needs a class name`);\n    } else if (typeof targetClass !== 'string') {\n      return invalidJsonError;\n    } else if (!classNameIsValid(targetClass)) {\n      return new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(targetClass));\n    } else {\n      return undefined;\n    }\n  }\n  if (typeof type !== 'string') {\n    return invalidJsonError;\n  }\n  if (validNonRelationOrPointerTypes.indexOf(type) < 0) {\n    return new Parse.Error(Parse.Error.INCORRECT_TYPE, `invalid field type: ${type}`);\n  }\n  return undefined;\n};\n\nconst convertSchemaToAdapterSchema = (schema: any) => {\n  schema = injectDefaultSchema(schema);\n  delete schema.fields.ACL;\n  schema.fields._rperm = { type: 'Array' };\n  schema.fields._wperm = { type: 'Array' };\n\n  if (schema.className === '_User') {\n    delete schema.fields.password;\n    schema.fields._hashed_password = { type: 'String' };\n  }\n\n  return schema;\n};\n\nconst convertAdapterSchemaToParseSchema = ({ ...schema }) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  schema.fields.ACL = { type: 'ACL' };\n\n  if (schema.className === '_User') {\n    delete schema.fields.authData; //Auth data is implicit\n    delete schema.fields._hashed_password;\n    schema.fields.password = { type: 'String' };\n  }\n\n  if (schema.indexes && Object.keys(schema.indexes).length === 0) {\n    delete schema.indexes;\n  }\n\n  return schema;\n};\n\nclass SchemaData {\n  __data: any;\n  __protectedFields: any;\n  constructor(allSchemas = [], protectedFields = {}) {\n    this.__data = {};\n    this.__protectedFields = protectedFields;\n    allSchemas.forEach(schema => {\n      if (volatileClasses.includes(schema.className)) {\n        return;\n      }\n      Object.defineProperty(this, schema.className, {\n        get: () => {\n          if (!this.__data[schema.className]) {\n            const data = {};\n            data.fields = injectDefaultSchema(schema).fields;\n            data.classLevelPermissions = structuredClone(schema.classLevelPermissions);\n            data.indexes = schema.indexes;\n\n            const classProtectedFields = this.__protectedFields[schema.className];\n            if (classProtectedFields) {\n              for (const key in classProtectedFields) {\n                const unq = new Set([\n                  ...(data.classLevelPermissions.protectedFields[key] || []),\n                  ...classProtectedFields[key],\n                ]);\n                data.classLevelPermissions.protectedFields[key] = Array.from(unq);\n              }\n            }\n\n            this.__data[schema.className] = data;\n          }\n          return this.__data[schema.className];\n        },\n      });\n    });\n\n    // Inject the in-memory classes\n    volatileClasses.forEach(className => {\n      Object.defineProperty(this, className, {\n        get: () => {\n          if (!this.__data[className]) {\n            const schema = injectDefaultSchema({\n              className,\n              fields: {},\n              classLevelPermissions: {},\n            });\n            const data = {};\n            data.fields = schema.fields;\n            data.classLevelPermissions = schema.classLevelPermissions;\n            data.indexes = schema.indexes;\n            this.__data[className] = data;\n          }\n          return this.__data[className];\n        },\n      });\n    });\n  }\n}\n\nconst injectDefaultSchema = ({ className, fields, classLevelPermissions, indexes }: Schema) => {\n  const defaultSchema: Schema = {\n    className,\n    fields: {\n      ...defaultColumns._Default,\n      ...(defaultColumns[className] || {}),\n      ...fields,\n    },\n    classLevelPermissions,\n  };\n  if (indexes && Object.keys(indexes).length !== 0) {\n    defaultSchema.indexes = indexes;\n  }\n  return defaultSchema;\n};\n\nconst _HooksSchema = { className: '_Hooks', fields: defaultColumns._Hooks };\nconst _GlobalConfigSchema = {\n  className: '_GlobalConfig',\n  fields: defaultColumns._GlobalConfig,\n};\nconst _GraphQLConfigSchema = {\n  className: '_GraphQLConfig',\n  fields: defaultColumns._GraphQLConfig,\n};\nconst _PushStatusSchema = convertSchemaToAdapterSchema(\n  injectDefaultSchema({\n    className: '_PushStatus',\n    fields: {},\n    classLevelPermissions: {},\n  })\n);\nconst _JobStatusSchema = convertSchemaToAdapterSchema(\n  injectDefaultSchema({\n    className: '_JobStatus',\n    fields: {},\n    classLevelPermissions: {},\n  })\n);\nconst _JobScheduleSchema = convertSchemaToAdapterSchema(\n  injectDefaultSchema({\n    className: '_JobSchedule',\n    fields: {},\n    classLevelPermissions: {},\n  })\n);\nconst _AudienceSchema = convertSchemaToAdapterSchema(\n  injectDefaultSchema({\n    className: '_Audience',\n    fields: defaultColumns._Audience,\n    classLevelPermissions: {},\n  })\n);\nconst _IdempotencySchema = convertSchemaToAdapterSchema(\n  injectDefaultSchema({\n    className: '_Idempotency',\n    fields: defaultColumns._Idempotency,\n    classLevelPermissions: {},\n  })\n);\nconst VolatileClassesSchemas = [\n  _HooksSchema,\n  _JobStatusSchema,\n  _JobScheduleSchema,\n  _PushStatusSchema,\n  _GlobalConfigSchema,\n  _GraphQLConfigSchema,\n  _AudienceSchema,\n  _IdempotencySchema,\n];\n\nconst dbTypeMatchesObjectType = (dbType: SchemaField | string, objectType: SchemaField) => {\n  if (dbType.type !== objectType.type) { return false; }\n  if (dbType.targetClass !== objectType.targetClass) { return false; }\n  if (dbType === objectType.type) { return true; }\n  if (dbType.type === objectType.type) { return true; }\n  return false;\n};\n\nconst typeToString = (type: SchemaField | string): string => {\n  if (typeof type === 'string') {\n    return type;\n  }\n  if (type.targetClass) {\n    return `${type.type}<${type.targetClass}>`;\n  }\n  return `${type.type}`;\n};\nconst ttl = {\n  date: Date.now(),\n  duration: undefined,\n};\n\n// Stores the entire schema of the app in a weird hybrid format somewhere between\n// the mongo format and the Parse format. Soon, this will all be Parse format.\nexport default class SchemaController {\n  _dbAdapter: StorageAdapter;\n  schemaData: { [string]: Schema };\n  reloadDataPromise: ?Promise<any>;\n  protectedFields: any;\n  userIdRegEx: RegExp;\n\n  constructor(databaseAdapter: StorageAdapter) {\n    this._dbAdapter = databaseAdapter;\n    const config = Config.get(Parse.applicationId);\n    this.schemaData = new SchemaData(SchemaCache.all(), this.protectedFields);\n    this.protectedFields = config.protectedFields;\n\n    const customIds = config.allowCustomObjectId;\n\n    const customIdRegEx = /^.{1,}$/u; // 1+ chars\n    const autoIdRegEx = /^[a-zA-Z0-9]{1,}$/;\n\n    this.userIdRegEx = customIds ? customIdRegEx : autoIdRegEx;\n\n    this._dbAdapter.watch(() => {\n      this.reloadData({ clearCache: true });\n    });\n  }\n\n  async reloadDataIfNeeded() {\n    if (this._dbAdapter.enableSchemaHooks) {\n      return;\n    }\n    const { date, duration } = ttl || {};\n    if (!duration) {\n      return;\n    }\n    const now = Date.now();\n    if (now - date > duration) {\n      ttl.date = now;\n      await this.reloadData({ clearCache: true });\n    }\n  }\n\n  reloadData(options: LoadSchemaOptions = { clearCache: false }): Promise<any> {\n    if (this.reloadDataPromise && !options.clearCache) {\n      return this.reloadDataPromise;\n    }\n    this.reloadDataPromise = this.getAllClasses(options)\n      .then(\n        allSchemas => {\n          this.schemaData = new SchemaData(allSchemas, this.protectedFields);\n          delete this.reloadDataPromise;\n        },\n        err => {\n          this.schemaData = new SchemaData();\n          delete this.reloadDataPromise;\n          throw err;\n        }\n      )\n      .then(() => {});\n    return this.reloadDataPromise;\n  }\n\n  async getAllClasses(options: LoadSchemaOptions = { clearCache: false }): Promise<Array<Schema>> {\n    if (options.clearCache) {\n      return this.setAllClasses();\n    }\n    await this.reloadDataIfNeeded();\n    const cached = SchemaCache.all();\n    if (cached && cached.length) {\n      return Promise.resolve(cached);\n    }\n    return this.setAllClasses();\n  }\n\n  setAllClasses(): Promise<Array<Schema>> {\n    return this._dbAdapter\n      .getAllClasses()\n      .then(allSchemas => allSchemas.map(injectDefaultSchema))\n      .then(allSchemas => {\n        SchemaCache.put(allSchemas);\n        return allSchemas;\n      });\n  }\n\n  getOneSchema(\n    className: string,\n    allowVolatileClasses: boolean = false,\n    options: LoadSchemaOptions = { clearCache: false }\n  ): Promise<Schema> {\n    if (options.clearCache) {\n      SchemaCache.clear();\n    }\n    if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {\n      const data = this.schemaData[className];\n      return Promise.resolve({\n        className,\n        fields: data.fields,\n        classLevelPermissions: data.classLevelPermissions,\n        indexes: data.indexes,\n      });\n    }\n    const cached = SchemaCache.get(className);\n    if (cached && !options.clearCache) {\n      return Promise.resolve(cached);\n    }\n    return this.setAllClasses().then(allSchemas => {\n      const oneSchema = allSchemas.find(schema => schema.className === className);\n      if (!oneSchema) {\n        return Promise.reject(undefined);\n      }\n      return oneSchema;\n    });\n  }\n\n  // Create a new class that includes the three default fields.\n  // ACL is an implicit column that does not get an entry in the\n  // _SCHEMAS database. Returns a promise that resolves with the\n  // created schema, in mongo format.\n  // on success, and rejects with an error on fail. Ensure you\n  // have authorization (master key, or client class creation\n  // enabled) before calling this function.\n  async addClassIfNotExists(\n    className: string,\n    fields: SchemaFields = {},\n    classLevelPermissions: any,\n    indexes: any = {}\n  ): Promise<void | Schema> {\n    var validationError = this.validateNewClass(className, fields, classLevelPermissions);\n    if (validationError) {\n      if (validationError instanceof Parse.Error) {\n        return Promise.reject(validationError);\n      } else if (validationError.code && validationError.error) {\n        return Promise.reject(new Parse.Error(validationError.code, validationError.error));\n      }\n      return Promise.reject(validationError);\n    }\n    try {\n      const adapterSchema = await this._dbAdapter.createClass(\n        className,\n        convertSchemaToAdapterSchema({\n          fields,\n          classLevelPermissions,\n          indexes,\n          className,\n        })\n      );\n      // TODO: Remove by updating schema cache directly\n      await this.reloadData({ clearCache: true });\n      const parseSchema = convertAdapterSchemaToParseSchema(adapterSchema);\n      return parseSchema;\n    } catch (error) {\n      if (error && error.code === Parse.Error.DUPLICATE_VALUE) {\n        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  updateClass(\n    className: string,\n    submittedFields: SchemaFields,\n    classLevelPermissions: any,\n    indexes: any,\n    database: DatabaseController\n  ) {\n    return this.getOneSchema(className)\n      .then(schema => {\n        const existingFields = schema.fields;\n        Object.keys(submittedFields).forEach(name => {\n          const field = submittedFields[name];\n          if (\n            existingFields[name] &&\n            existingFields[name].type !== field.type &&\n            field.__op !== 'Delete'\n          ) {\n            throw new Parse.Error(255, `Field ${name} exists, cannot update.`);\n          }\n          if (!existingFields[name] && field.__op === 'Delete') {\n            throw new Parse.Error(255, `Field ${name} does not exist, cannot delete.`);\n          }\n        });\n\n        delete existingFields._rperm;\n        delete existingFields._wperm;\n        const newSchema = buildMergedSchemaObject(existingFields, submittedFields);\n        const defaultFields = defaultColumns[className] || defaultColumns._Default;\n        const fullNewSchema = Object.assign({}, newSchema, defaultFields);\n        const validationError = this.validateSchemaData(\n          className,\n          newSchema,\n          classLevelPermissions,\n          Object.keys(existingFields)\n        );\n        if (validationError) {\n          throw new Parse.Error(validationError.code, validationError.error);\n        }\n\n        // Finally we have checked to make sure the request is valid and we can start deleting fields.\n        // Do all deletions first, then a single save to _SCHEMA collection to handle all additions.\n        const deletedFields: string[] = [];\n        const insertedFields = [];\n        Object.keys(submittedFields).forEach(fieldName => {\n          if (submittedFields[fieldName].__op === 'Delete') {\n            deletedFields.push(fieldName);\n          } else {\n            insertedFields.push(fieldName);\n          }\n        });\n\n        let deletePromise = Promise.resolve();\n        if (deletedFields.length > 0) {\n          deletePromise = this.deleteFields(deletedFields, className, database);\n        }\n        let enforceFields = [];\n        return (\n          deletePromise // Delete Everything\n            .then(() => this.reloadData({ clearCache: true })) // Reload our Schema, so we have all the new values\n            .then(() => {\n              const promises = insertedFields.map(fieldName => {\n                const type = submittedFields[fieldName];\n                return this.enforceFieldExists(className, fieldName, type);\n              });\n              return Promise.all(promises);\n            })\n            .then(results => {\n              enforceFields = results.filter(result => !!result);\n              return this.setPermissions(className, classLevelPermissions, newSchema);\n            })\n            .then(() =>\n              this._dbAdapter.setIndexesWithSchemaFormat(\n                className,\n                indexes,\n                schema.indexes,\n                fullNewSchema\n              )\n            )\n            .then(() => this.reloadData({ clearCache: true }))\n            //TODO: Move this logic into the database adapter\n            .then(() => {\n              this.ensureFields(enforceFields);\n              const schema = this.schemaData[className];\n              const reloadedSchema: Schema = {\n                className: className,\n                fields: schema.fields,\n                classLevelPermissions: schema.classLevelPermissions,\n              };\n              if (schema.indexes && Object.keys(schema.indexes).length !== 0) {\n                reloadedSchema.indexes = schema.indexes;\n              }\n              return reloadedSchema;\n            })\n        );\n      })\n      .catch(error => {\n        if (error === undefined) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_CLASS_NAME,\n            `Class ${className} does not exist.`\n          );\n        } else {\n          throw error;\n        }\n      });\n  }\n\n  // Returns a promise that resolves successfully to the new schema\n  // object or fails with a reason.\n  enforceClassExists(className: string): Promise<SchemaController> {\n    if (this.schemaData[className]) {\n      return Promise.resolve(this);\n    }\n    // We don't have this class. Update the schema\n    return (\n      // The schema update succeeded. Reload the schema\n      this.addClassIfNotExists(className)\n        .catch(() => {\n          // The schema update failed. This can be okay - it might\n          // have failed because there's a race condition and a different\n          // client is making the exact same schema update that we want.\n          // So just reload the schema.\n          return this.reloadData({ clearCache: true });\n        })\n        .then(() => {\n          // Ensure that the schema now validates\n          if (this.schemaData[className]) {\n            return this;\n          } else {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, `Failed to add ${className}`);\n          }\n        })\n        .catch(() => {\n          // The schema still doesn't validate. Give up\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'schema class name does not revalidate');\n        })\n    );\n  }\n\n  validateNewClass(className: string, fields: SchemaFields = {}, classLevelPermissions: any): any {\n    if (this.schemaData[className]) {\n      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);\n    }\n    if (!classNameIsValid(className)) {\n      return {\n        code: Parse.Error.INVALID_CLASS_NAME,\n        error: invalidClassNameMessage(className),\n      };\n    }\n    return this.validateSchemaData(className, fields, classLevelPermissions, []);\n  }\n\n  validateSchemaData(\n    className: string,\n    fields: SchemaFields,\n    classLevelPermissions: ClassLevelPermissions,\n    existingFieldNames: Array<string>\n  ) {\n    for (const fieldName in fields) {\n      if (existingFieldNames.indexOf(fieldName) < 0) {\n        if (!fieldNameIsValid(fieldName, className)) {\n          return {\n            code: Parse.Error.INVALID_KEY_NAME,\n            error: 'invalid field name: ' + fieldName,\n          };\n        }\n        if (!fieldNameIsValidForClass(fieldName, className)) {\n          return {\n            code: 136,\n            error: 'field ' + fieldName + ' cannot be added',\n          };\n        }\n        const fieldType = fields[fieldName];\n        const error = fieldTypeIsInvalid(fieldType);\n        if (error) { return { code: error.code, error: error.message }; }\n        if (fieldType.defaultValue !== undefined) {\n          let defaultValueType = getType(fieldType.defaultValue);\n          if (typeof defaultValueType === 'string') {\n            defaultValueType = { type: defaultValueType };\n          } else if (typeof defaultValueType === 'object' && fieldType.type === 'Relation') {\n            return {\n              code: Parse.Error.INCORRECT_TYPE,\n              error: `The 'default value' option is not applicable for ${typeToString(fieldType)}`,\n            };\n          }\n          if (!dbTypeMatchesObjectType(fieldType, defaultValueType)) {\n            return {\n              code: Parse.Error.INCORRECT_TYPE,\n              error: `schema mismatch for ${className}.${fieldName} default value; expected ${typeToString(\n                fieldType\n              )} but got ${typeToString(defaultValueType)}`,\n            };\n          }\n        } else if (fieldType.required) {\n          if (typeof fieldType === 'object' && fieldType.type === 'Relation') {\n            return {\n              code: Parse.Error.INCORRECT_TYPE,\n              error: `The 'required' option is not applicable for ${typeToString(fieldType)}`,\n            };\n          }\n        }\n      }\n    }\n\n    for (const fieldName in defaultColumns[className]) {\n      fields[fieldName] = defaultColumns[className][fieldName];\n    }\n\n    const geoPoints = Object.keys(fields).filter(\n      key => fields[key] && fields[key].type === 'GeoPoint'\n    );\n    if (geoPoints.length > 1) {\n      return {\n        code: Parse.Error.INCORRECT_TYPE,\n        error:\n          'currently, only one GeoPoint field may exist in an object. Adding ' +\n          geoPoints[1] +\n          ' when ' +\n          geoPoints[0] +\n          ' already exists.',\n      };\n    }\n    validateCLP(classLevelPermissions, fields, this.userIdRegEx);\n  }\n\n  // Sets the Class-level permissions for a given className, which must exist.\n  async setPermissions(className: string, perms: any, newSchema: SchemaFields) {\n    if (typeof perms === 'undefined') {\n      return Promise.resolve();\n    }\n    validateCLP(perms, newSchema, this.userIdRegEx);\n    await this._dbAdapter.setClassLevelPermissions(className, perms);\n    const cached = SchemaCache.get(className);\n    if (cached) {\n      cached.classLevelPermissions = perms;\n    }\n  }\n\n  // Returns a promise that resolves successfully to the new schema\n  // object if the provided className-fieldName-type tuple is valid.\n  // The className must already be validated.\n  // If 'freeze' is true, refuse to update the schema for this field.\n  enforceFieldExists(\n    className: string,\n    fieldName: string,\n    type: string | SchemaField,\n    isValidation?: boolean,\n    maintenance?: boolean\n  ) {\n    if (fieldName.indexOf('.') > 0) {\n      // \"<array>.<index>\" for Nested Arrays\n      // \"<embedded document>.<field>\" for Nested Objects\n      // JSON Arrays are treated as Nested Objects\n      const [x, y] = fieldName.split('.');\n      fieldName = x;\n      const isArrayIndex = Array.from(y).every(c => c >= '0' && c <= '9');\n      if (isArrayIndex && !['sentPerUTCOffset', 'failedPerUTCOffset'].includes(fieldName)) {\n        type = 'Array';\n      } else {\n        type = 'Object';\n      }\n    }\n    let fieldNameToValidate = `${fieldName}`;\n    if (maintenance && fieldNameToValidate.charAt(0) === '_') {\n      fieldNameToValidate = fieldNameToValidate.substring(1);\n    }\n    if (!fieldNameIsValid(fieldNameToValidate, className)) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`);\n    }\n\n    // If someone tries to create a new field with null/undefined as the value, return;\n    if (!type) {\n      return undefined;\n    }\n\n    const expectedType = this.getExpectedType(className, fieldName);\n    if (typeof type === 'string') {\n      type = ({ type }: SchemaField);\n    }\n\n    if (type.defaultValue !== undefined) {\n      let defaultValueType = getType(type.defaultValue);\n      if (typeof defaultValueType === 'string') {\n        defaultValueType = { type: defaultValueType };\n      }\n      if (!dbTypeMatchesObjectType(type, defaultValueType)) {\n        throw new Parse.Error(\n          Parse.Error.INCORRECT_TYPE,\n          `schema mismatch for ${className}.${fieldName} default value; expected ${typeToString(\n            type\n          )} but got ${typeToString(defaultValueType)}`\n        );\n      }\n    }\n\n    if (expectedType) {\n      if (!dbTypeMatchesObjectType(expectedType, type)) {\n        throw new Parse.Error(\n          Parse.Error.INCORRECT_TYPE,\n          `schema mismatch for ${className}.${fieldName}; expected ${typeToString(\n            expectedType\n          )} but got ${typeToString(type)}`\n        );\n      }\n      // If type options do not change\n      // we can safely return\n      if (isValidation || JSON.stringify(expectedType) === JSON.stringify(type)) {\n        return undefined;\n      }\n      // Field options are may be changed\n      // ensure to have an update to date schema field\n      return this._dbAdapter.updateFieldOptions(className, fieldName, type);\n    }\n\n    return this._dbAdapter\n      .addFieldIfNotExists(className, fieldName, type)\n      .catch(error => {\n        if (error.code == Parse.Error.INCORRECT_TYPE) {\n          // Make sure that we throw errors when it is appropriate to do so.\n          throw error;\n        }\n        // The update failed. This can be okay - it might have been a race\n        // condition where another client updated the schema in the same\n        // way that we wanted to. So, just reload the schema\n        return Promise.resolve();\n      })\n      .then(() => {\n        return {\n          className,\n          fieldName,\n          type,\n        };\n      });\n  }\n\n  ensureFields(fields: any) {\n    for (let i = 0; i < fields.length; i += 1) {\n      const { className, fieldName } = fields[i];\n      let { type } = fields[i];\n      const expectedType = this.getExpectedType(className, fieldName);\n      if (typeof type === 'string') {\n        type = { type: type };\n      }\n      if (!expectedType || !dbTypeMatchesObjectType(expectedType, type)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, `Could not add field ${fieldName}`);\n      }\n    }\n  }\n\n  // maintain compatibility\n  deleteField(fieldName: string, className: string, database: DatabaseController) {\n    return this.deleteFields([fieldName], className, database);\n  }\n\n  // Delete fields, and remove that data from all objects. This is intended\n  // to remove unused fields, if other writers are writing objects that include\n  // this field, the field may reappear. Returns a Promise that resolves with\n  // no object on success, or rejects with { code, error } on failure.\n  // Passing the database and prefix is necessary in order to drop relation collections\n  // and remove fields from objects. Ideally the database would belong to\n  // a database adapter and this function would close over it or access it via member.\n  deleteFields(fieldNames: Array<string>, className: string, database: DatabaseController) {\n    if (!classNameIsValid(className)) {\n      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(className));\n    }\n\n    fieldNames.forEach(fieldName => {\n      if (!fieldNameIsValid(fieldName, className)) {\n        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `invalid field name: ${fieldName}`);\n      }\n      //Don't allow deleting the default fields.\n      if (!fieldNameIsValidForClass(fieldName, className)) {\n        throw new Parse.Error(136, `field ${fieldName} cannot be changed`);\n      }\n    });\n\n    return this.getOneSchema(className, false, { clearCache: true })\n      .catch(error => {\n        if (error === undefined) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_CLASS_NAME,\n            `Class ${className} does not exist.`\n          );\n        } else {\n          throw error;\n        }\n      })\n      .then(schema => {\n        fieldNames.forEach(fieldName => {\n          if (!schema.fields[fieldName]) {\n            throw new Parse.Error(255, `Field ${fieldName} does not exist, cannot delete.`);\n          }\n        });\n\n        const schemaFields = { ...schema.fields };\n        return database.adapter.deleteFields(className, schema, fieldNames).then(() => {\n          return Promise.all(\n            fieldNames.map(fieldName => {\n              const field = schemaFields[fieldName];\n              if (field && field.type === 'Relation') {\n                //For relations, drop the _Join table\n                return database.adapter.deleteClass(`_Join:${fieldName}:${className}`);\n              }\n              return Promise.resolve();\n            })\n          );\n        });\n      })\n      .then(() => {\n        SchemaCache.clear();\n      });\n  }\n\n  // Validates an object provided in REST format.\n  // Returns a promise that resolves to the new schema if this object is\n  // valid.\n  async validateObject(className: string, object: any, query: any, maintenance: boolean) {\n    let geocount = 0;\n    const schema = await this.enforceClassExists(className);\n    const promises = [];\n\n    for (const fieldName in object) {\n      if (object[fieldName] && getType(object[fieldName]) === 'GeoPoint') {\n        geocount++;\n      }\n      if (geocount > 1) {\n        return Promise.reject(\n          new Parse.Error(\n            Parse.Error.INCORRECT_TYPE,\n            'there can only be one geopoint field in a class'\n          )\n        );\n      }\n    }\n    for (const fieldName in object) {\n      if (object[fieldName] === undefined) {\n        continue;\n      }\n      const expected = getType(object[fieldName]);\n      if (!expected) {\n        continue;\n      }\n      if (fieldName === 'ACL') {\n        // Every object has ACL implicitly.\n        continue;\n      }\n      promises.push(schema.enforceFieldExists(className, fieldName, expected, true, maintenance));\n    }\n    const results = await Promise.all(promises);\n    const enforceFields = results.filter(result => !!result);\n\n    if (enforceFields.length !== 0) {\n      // TODO: Remove by updating schema cache directly\n      await this.reloadData({ clearCache: true });\n    }\n    this.ensureFields(enforceFields);\n\n    const promise = Promise.resolve(schema);\n    return thenValidateRequiredColumns(promise, className, object, query);\n  }\n\n  // Validates that all the properties are set for the object\n  validateRequiredColumns(className: string, object: any, query: any) {\n    const columns = requiredColumns.write[className];\n    if (!columns || columns.length == 0) {\n      return Promise.resolve(this);\n    }\n\n    const missingColumns = columns.filter(function (column) {\n      if (query && query.objectId) {\n        if (object[column] && typeof object[column] === 'object') {\n          // Trying to delete a required column\n          return object[column].__op == 'Delete';\n        }\n        // Not trying to do anything there\n        return false;\n      }\n      return !object[column];\n    });\n\n    if (missingColumns.length > 0) {\n      throw new Parse.Error(Parse.Error.INCORRECT_TYPE, missingColumns[0] + ' is required.');\n    }\n    return Promise.resolve(this);\n  }\n\n  testPermissionsForClassName(className: string, aclGroup: string[], operation: string) {\n    return SchemaController.testPermissions(\n      this.getClassLevelPermissions(className),\n      aclGroup,\n      operation\n    );\n  }\n\n  // Tests that the class level permission let pass the operation for a given aclGroup\n  static testPermissions(classPermissions: ?any, aclGroup: string[], operation: string): boolean {\n    if (!classPermissions || !classPermissions[operation]) {\n      return true;\n    }\n    const perms = classPermissions[operation];\n    if (perms['*']) {\n      return true;\n    }\n    // Check permissions against the aclGroup provided (array of userId/roles)\n    if (\n      aclGroup.some(acl => {\n        return perms[acl] === true;\n      })\n    ) {\n      return true;\n    }\n    return false;\n  }\n\n  // Validates an operation passes class-level-permissions set in the schema\n  static validatePermission(\n    classPermissions: ?any,\n    className: string,\n    aclGroup: string[],\n    operation: string,\n    action?: string\n  ) {\n    if (SchemaController.testPermissions(classPermissions, aclGroup, operation)) {\n      return Promise.resolve();\n    }\n\n    if (!classPermissions || !classPermissions[operation]) {\n      return true;\n    }\n    const perms = classPermissions[operation];\n    const config = Config.get(Parse.applicationId)\n    // If only for authenticated users\n    // make sure we have an aclGroup\n    if (perms['requiresAuthentication']) {\n      // If aclGroup has * (public)\n      if (!aclGroup || aclGroup.length == 0) {\n        throw createSanitizedError(\n          Parse.Error.OBJECT_NOT_FOUND,\n          'Permission denied, user needs to be authenticated.',\n          config\n        );\n      } else if (aclGroup.indexOf('*') > -1 && aclGroup.length == 1) {\n        throw createSanitizedError(\n          Parse.Error.OBJECT_NOT_FOUND,\n          'Permission denied, user needs to be authenticated.',\n          config\n        );\n      }\n      // requiresAuthentication passed, just move forward\n      // probably would be wise at some point to rename to 'authenticatedUser'\n      return Promise.resolve();\n    }\n\n    // No matching CLP, let's check the Pointer permissions\n    // And handle those later\n    const permissionField =\n      ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';\n\n    // Reject create when write lockdown\n    if (permissionField == 'writeUserFields' && operation == 'create') {\n      throw createSanitizedError(\n        Parse.Error.OPERATION_FORBIDDEN,\n        `Permission denied for action ${operation} on class ${className}.`,\n        config\n      );\n    }\n\n    // Process the readUserFields later\n    if (\n      Array.isArray(classPermissions[permissionField]) &&\n      classPermissions[permissionField].length > 0\n    ) {\n      return Promise.resolve();\n    }\n\n    const pointerFields = classPermissions[operation].pointerFields;\n    if (Array.isArray(pointerFields) && pointerFields.length > 0) {\n      // any op except 'addField as part of create' is ok.\n      if (operation !== 'addField' || action === 'update') {\n        // We can allow adding field on update flow only.\n        return Promise.resolve();\n      }\n    }\n\n    throw createSanitizedError(\n      Parse.Error.OPERATION_FORBIDDEN,\n      `Permission denied for action ${operation} on class ${className}.`,\n      config\n    );\n  }\n\n  // Validates an operation passes class-level-permissions set in the schema\n  validatePermission(className: string, aclGroup: string[], operation: string, action?: string) {\n    return SchemaController.validatePermission(\n      this.getClassLevelPermissions(className),\n      className,\n      aclGroup,\n      operation,\n      action\n    );\n  }\n\n  getClassLevelPermissions(className: string): any {\n    return this.schemaData[className] && this.schemaData[className].classLevelPermissions;\n  }\n\n  // Returns the expected type for a className+key combination\n  // or undefined if the schema is not set\n  getExpectedType(className: string, fieldName: string): ?(SchemaField | string) {\n    if (this.schemaData[className]) {\n      const expectedType = this.schemaData[className].fields[fieldName];\n      return expectedType === 'map' ? 'Object' : expectedType;\n    }\n    return undefined;\n  }\n\n  // Checks if a given class is in the schema.\n  hasClass(className: string) {\n    if (this.schemaData[className]) {\n      return Promise.resolve(true);\n    }\n    return this.reloadData().then(() => !!this.schemaData[className]);\n  }\n}\n\n// Returns a promise for a new Schema.\nconst load = (dbAdapter: StorageAdapter, options: any): Promise<SchemaController> => {\n  const schema = new SchemaController(dbAdapter);\n  ttl.duration = dbAdapter.schemaCacheTtl;\n  return schema.reloadData(options).then(() => schema);\n};\n\n// Builds a new schema (in schema API response format) out of an\n// existing mongo schema + a schemas API put request. This response\n// does not include the default fields, as it is intended to be passed\n// to mongoSchemaFromFieldsAndClassName. No validation is done here, it\n// is done in mongoSchemaFromFieldsAndClassName.\nfunction buildMergedSchemaObject(existingFields: SchemaFields, putRequest: any): SchemaFields {\n  const newSchema = {};\n  // @flow-disable-next\n  const sysSchemaField =\n    Object.keys(defaultColumns).indexOf(existingFields._id) === -1\n      ? []\n      : Object.keys(defaultColumns[existingFields._id]);\n  for (const oldField in existingFields) {\n    if (\n      oldField !== '_id' &&\n      oldField !== 'ACL' &&\n      oldField !== 'updatedAt' &&\n      oldField !== 'createdAt' &&\n      oldField !== 'objectId'\n    ) {\n      if (sysSchemaField.length > 0 && sysSchemaField.indexOf(oldField) !== -1) {\n        continue;\n      }\n      const fieldIsDeleted = putRequest[oldField] && putRequest[oldField].__op === 'Delete';\n      if (!fieldIsDeleted) {\n        newSchema[oldField] = existingFields[oldField];\n      }\n    }\n  }\n  for (const newField in putRequest) {\n    if (newField !== 'objectId' && putRequest[newField].__op !== 'Delete') {\n      if (sysSchemaField.length > 0 && sysSchemaField.indexOf(newField) !== -1) {\n        continue;\n      }\n      newSchema[newField] = putRequest[newField];\n    }\n  }\n  return newSchema;\n}\n\n// Given a schema promise, construct another schema promise that\n// validates this field once the schema loads.\nfunction thenValidateRequiredColumns(schemaPromise, className, object, query) {\n  return schemaPromise.then(schema => {\n    return schema.validateRequiredColumns(className, object, query);\n  });\n}\n\n// Gets the type from a REST API formatted object, where 'type' is\n// extended past javascript types to include the rest of the Parse\n// type system.\n// The output should be a valid schema value.\n// TODO: ensure that this is compatible with the format used in Open DB\nfunction getType(obj: any): ?(SchemaField | string) {\n  const type = typeof obj;\n  switch (type) {\n    case 'boolean':\n      return 'Boolean';\n    case 'string':\n      return 'String';\n    case 'number':\n      return 'Number';\n    case 'map':\n    case 'object':\n      if (!obj) {\n        return undefined;\n      }\n      return getObjectType(obj);\n    case 'function':\n    case 'symbol':\n    case 'undefined':\n    default:\n      throw 'bad obj: ' + obj;\n  }\n}\n\n// This gets the type for non-JSON types like pointers and files, but\n// also gets the appropriate type for $ operators.\n// Returns null if the type is unknown.\nfunction getObjectType(obj): ?(SchemaField | string) {\n  if (Array.isArray(obj)) {\n    return 'Array';\n  }\n  if (obj.__type) {\n    switch (obj.__type) {\n      case 'Pointer':\n        if (obj.className) {\n          return {\n            type: 'Pointer',\n            targetClass: obj.className,\n          };\n        }\n        break;\n      case 'Relation':\n        if (obj.className) {\n          return {\n            type: 'Relation',\n            targetClass: obj.className,\n          };\n        }\n        break;\n      case 'File':\n        if (obj.name) {\n          return 'File';\n        }\n        break;\n      case 'Date':\n        if (obj.iso) {\n          return 'Date';\n        }\n        break;\n      case 'GeoPoint':\n        if (obj.latitude != null && obj.longitude != null) {\n          return 'GeoPoint';\n        }\n        break;\n      case 'Bytes':\n        if (obj.base64) {\n          return 'Bytes';\n        }\n        break;\n      case 'Polygon':\n        if (obj.coordinates) {\n          return 'Polygon';\n        }\n        break;\n    }\n    throw new Parse.Error(Parse.Error.INCORRECT_TYPE, 'This is not a valid ' + obj.__type);\n  }\n  if (obj['$ne']) {\n    return getObjectType(obj['$ne']);\n  }\n  if (obj.__op) {\n    switch (obj.__op) {\n      case 'Increment':\n        return 'Number';\n      case 'Delete':\n        return null;\n      case 'Add':\n      case 'AddUnique':\n      case 'Remove':\n        return 'Array';\n      case 'AddRelation':\n      case 'RemoveRelation':\n        return {\n          type: 'Relation',\n          targetClass: obj.objects[0].className,\n        };\n      case 'Batch':\n        return getObjectType(obj.ops[0]);\n      default:\n        throw 'unexpected op: ' + obj.__op;\n    }\n  }\n  return 'Object';\n}\n\nexport {\n  load,\n  classNameIsValid,\n  fieldNameIsValid,\n  invalidClassNameMessage,\n  buildMergedSchemaObject,\n  systemClasses,\n  defaultColumns,\n  convertSchemaToAdapterSchema,\n  VolatileClassesSchemas,\n  SchemaController,\n  requiredColumns,\n};\n"],"mappings":"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","ignoreList":[]}