parse-server 2.8.4 → 8.6.2

package/lib/Controllers/SchemaController.js

@@ -1,22 +1,22 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SchemaController = exports.VolatileClassesSchemas = exports.convertSchemaToAdapterSchema = exports.defaultColumns = exports.systemClasses = exports.buildMergedSchemaObject = exports.invalidClassNameMessage = exports.fieldNameIsValid = exports.classNameIsValid = exports.load = undefined;
-
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-var _StorageAdapter = require('../Adapters/Storage/StorageAdapter');
-
-var _DatabaseController = require('./DatabaseController');
-
-var _DatabaseController2 = _interopRequireDefault(_DatabaseController);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
-
+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");
+var _deepcopy = _interopRequireDefault(require("deepcopy"));
+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
@@ -35,187 +35,485 @@ function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in ob
 // -disable-next
 const Parse = require('parse/node').Parse;
 
+// -disable-next
 
-const defaultColumns = Object.freeze({
+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' }
+    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' }
+    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' }
+    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' }
+    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: {
-    "restricted": { type: 'Boolean' },
-    "user": { type: 'Pointer', targetClass: '_User' },
-    "installationId": { type: 'String' },
-    "sessionToken": { type: 'String' },
-    "expiresAt": { type: 'Date' },
-    "createdWith": { type: 'Object' }
+    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' }
+    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
-    } },
+    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' }
+    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' }
+    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' }
+    functionName: {
+      type: 'String'
+    },
+    className: {
+      type: 'String'
+    },
+    triggerName: {
+      type: 'String'
+    },
+    url: {
+      type: 'String'
+    }
   },
   _GlobalConfig: {
-    "objectId": { type: 'String' },
-    "params": { type: 'Object' }
+    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' }
+    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'
+    }
   }
 });
 
-const requiredColumns = Object.freeze({
-  _Product: ["productIdentifier", "icon", "order", "title", "subtitle"],
-  _Role: ["name", "ACL"]
+// 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']);
 
-const systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience']);
-
-const volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule', '_Audience']);
-
-// 10 alpha numberic chars + uppercase
-const userIdRegex = /^[a-zA-Z0-9]{10}$/;
 // 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;
+    }
+  }
 
-const requireAuthenticationRegex = /^requiresAuthentication$/;
-
-const permissionKeyRegex = Object.freeze([userIdRegex, roleRegex, publicRegex, requireAuthenticationRegex]);
+  // 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;
+    }
+  }
 
-function verifyPermissionKey(key) {
-  const result = permissionKeyRegex.reduce((isGood, regEx) => {
-    isGood = isGood || key.match(regEx) != null;
-    return isGood;
-  }, false);
-  if (!result) {
+  // 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']);
 
-const CLPValidKeys = Object.freeze(['find', 'count', 'get', 'create', 'update', 'delete', 'addField', 'readUserFields', 'writeUserFields']);
-function validateCLP(perms, fields) {
+// validation before setting class-level permissions on collection
+function validateCLP(perms, fields, userIdRegExp) {
   if (!perms) {
     return;
   }
-  Object.keys(perms).forEach(operation => {
-    if (CLPValidKeys.indexOf(operation) == -1) {
-      throw new Parse.Error(Parse.Error.INVALID_JSON, `${operation} is not a valid operation for class level permissions`);
+  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`);
     }
-    if (!perms[operation]) {
-      return;
+    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;
     }
 
-    if (operation === 'readUserFields' || operation === 'writeUserFields') {
-      if (!Array.isArray(perms[operation])) {
-        // -disable-next
-        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perms[operation]}' is not a valid value for class level permissions ${operation}`);
-      } else {
-        perms[operation].forEach(key => {
-          if (!fields[key] || fields[key].type != 'Pointer' || fields[key].targetClass != '_User') {
-            throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid column for class level pointer permissions ${operation}`);
+    // 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`);
+          }
+        }
       }
-      return;
+      // proceed with next operationKey
+      continue;
     }
 
-    // -disable-next
-    Object.keys(perms[operation]).forEach(key => {
-      verifyPermissionKey(key);
-      // -disable-next
-      const perm = perms[operation][key];
-      if (perm !== true) {
-        // -disable-next
-        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perm}' is not a valid value for class level permissions ${operation}:${key}:${perm}`);
+    // 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_]*$/;
@@ -227,18 +525,24 @@ function classNameIsValid(className) {
     // Be a join table OR
     joinClassRegex.test(className) ||
     // Include only alpha-numeric and underscores, and not start with an underscore or number
-    fieldNameIsValid(className)
+    fieldNameIsValid(className, className)
   );
 }
 
 // Valid fields must be alpha-numeric, and not start with an underscore or number
-function fieldNameIsValid(fieldName) {
-  return classAndFieldRegex.test(fieldName);
+// 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)) {
+  if (!fieldNameIsValid(fieldName, className)) {
     return false;
   }
   if (defaultColumns._Default[fieldName]) {
@@ -249,15 +553,16 @@ function fieldNameIsValidForClass(fieldName, className) {
   }
   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 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 }) => {
+const fieldTypeIsInvalid = ({
+  type,
+  targetClass
+}) => {
   if (['Pointer', 'Relation'].indexOf(type) >= 0) {
     if (!targetClass) {
       return new Parse.Error(135, `type ${type} needs a class name`);
@@ -277,46 +582,108 @@ const fieldTypeIsInvalid = ({ type, targetClass }) => {
   }
   return undefined;
 };
-
 const convertSchemaToAdapterSchema = schema => {
   schema = injectDefaultSchema(schema);
   delete schema.fields.ACL;
-  schema.fields._rperm = { type: 'Array' };
-  schema.fields._wperm = { type: 'Array' };
-
+  schema.fields._rperm = {
+    type: 'Array'
+  };
+  schema.fields._wperm = {
+    type: 'Array'
+  };
   if (schema.className === '_User') {
     delete schema.fields.password;
-    schema.fields._hashed_password = { type: 'String' };
+    schema.fields._hashed_password = {
+      type: 'String'
+    };
   }
-
   return schema;
 };
-
-const convertAdapterSchemaToParseSchema = (_ref) => {
-  let schema = _objectWithoutProperties(_ref, []);
-
+exports.convertSchemaToAdapterSchema = convertSchemaToAdapterSchema;
+const convertAdapterSchemaToParseSchema = ({
+  ...schema
+}) => {
   delete schema.fields._rperm;
   delete schema.fields._wperm;
-
-  schema.fields.ACL = { type: 'ACL' };
-
+  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' };
+    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 = (0, _deepcopy.default)(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];
+        }
+      });
+    });
 
-const injectDefaultSchema = ({ className, fields, classLevelPermissions, indexes }) => {
+    // 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: _extends({}, defaultColumns._Default, defaultColumns[className] || {}, fields),
+    fields: {
+      ...defaultColumns._Default,
+      ...(defaultColumns[className] || {}),
+      ...fields
+    },
     classLevelPermissions
   };
   if (indexes && Object.keys(indexes).length !== 0) {
@@ -324,39 +691,59 @@ const injectDefaultSchema = ({ className, fields, classLevelPermissions, indexes
   }
   return defaultSchema;
 };
-
-const _HooksSchema = { className: "_Hooks", fields: defaultColumns._Hooks };
-const _GlobalConfigSchema = { className: "_GlobalConfig", fields: defaultColumns._GlobalConfig };
+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",
+  className: '_PushStatus',
   fields: {},
   classLevelPermissions: {}
 }));
 const _JobStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
-  className: "_JobStatus",
+  className: '_JobStatus',
   fields: {},
   classLevelPermissions: {}
 }));
 const _JobScheduleSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
-  className: "_JobSchedule",
+  className: '_JobSchedule',
   fields: {},
   classLevelPermissions: {}
 }));
 const _AudienceSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
-  className: "_Audience",
+  className: '_Audience',
   fields: defaultColumns._Audience,
   classLevelPermissions: {}
 }));
-const VolatileClassesSchemas = [_HooksSchema, _JobStatusSchema, _JobScheduleSchema, _PushStatusSchema, _GlobalConfigSchema, _AudienceSchema];
-
+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;
+  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;
@@ -366,108 +753,108 @@ const typeToString = type => {
   }
   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, schemaCache) {
+  constructor(databaseAdapter) {
     this._dbAdapter = databaseAdapter;
-    this._cache = schemaCache;
-    // this.data[className][fieldName] tells you the type of that field, in mongo format
-    this.data = {};
-    // this.perms[className][operation] tells you the acl-style permissions
-    this.perms = {};
-    // this.indexes[className][operation] tells you the indexes
-    this.indexes = {};
+    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
+      });
+    });
   }
-
-  reloadData(options = { clearCache: false }) {
-    let promise = Promise.resolve();
-    if (options.clearCache) {
-      promise = promise.then(() => {
-        return this._cache.clear();
+  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 = promise.then(() => {
-      return this.getAllClasses(options).then(allSchemas => {
-        const data = {};
-        const perms = {};
-        const indexes = {};
-        allSchemas.forEach(schema => {
-          data[schema.className] = injectDefaultSchema(schema).fields;
-          perms[schema.className] = schema.classLevelPermissions;
-          indexes[schema.className] = schema.indexes;
-        });
-
-        // Inject the in-memory classes
-        volatileClasses.forEach(className => {
-          const schema = injectDefaultSchema({ className, fields: {}, classLevelPermissions: {} });
-          data[className] = schema.fields;
-          perms[className] = schema.classLevelPermissions;
-          indexes[className] = schema.indexes;
-        });
-        this.data = data;
-        this.perms = perms;
-        this.indexes = indexes;
-        delete this.reloadDataPromise;
-      }, err => {
-        this.data = {};
-        this.perms = {};
-        this.indexes = {};
-        delete this.reloadDataPromise;
-        throw err;
-      });
+    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;
   }
-
-  getAllClasses(options = { clearCache: false }) {
-    let promise = Promise.resolve();
+  async getAllClasses(options = {
+    clearCache: false
+  }) {
     if (options.clearCache) {
-      promise = this._cache.clear();
+      return this.setAllClasses();
     }
-    return promise.then(() => {
-      return this._cache.getAllClasses();
-    }).then(allClasses => {
-      if (allClasses && allClasses.length && !options.clearCache) {
-        return Promise.resolve(allClasses);
-      }
-      return this._dbAdapter.getAllClasses().then(allSchemas => allSchemas.map(injectDefaultSchema)).then(allSchemas => {
-        return this._cache.setAllClasses(allSchemas).then(() => {
-          return allSchemas;
-        });
-      });
+    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 }) {
-    let promise = Promise.resolve();
+  getOneSchema(className, allowVolatileClasses = false, options = {
+    clearCache: false
+  }) {
     if (options.clearCache) {
-      promise = this._cache.clear();
-    }
-    return promise.then(() => {
-      if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {
-        return Promise.resolve({
-          className,
-          fields: this.data[className],
-          classLevelPermissions: this.perms[className],
-          indexes: this.indexes[className]
-        });
-      }
-      return this._cache.getOneSchema(className).then(cached => {
-        if (cached && !options.clearCache) {
-          return Promise.resolve(cached);
-        }
-        return this._dbAdapter.getClass(className).then(injectDefaultSchema).then(result => {
-          return this._cache.setOneSchema(className, result).then(() => {
-            return result;
-          });
-        });
+      _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;
     });
   }
 
@@ -478,38 +865,49 @@ class SchemaController {
   // on success, and rejects with an error on fail. Ensure you
   // have authorization (master key, or client class creation
   // enabled) before calling this function.
-  addClassIfNotExists(className, fields = {}, classLevelPermissions, indexes = {}) {
+  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);
     }
-
-    return this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({ fields, classLevelPermissions, indexes, className })).then(convertAdapterSchemaToParseSchema).then(res => {
-      return this._cache.clear().then(() => {
-        return Promise.resolve(res);
+    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
       });
-    }).catch(error => {
+      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] && field.__op !== 'Delete') {
+        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);
@@ -531,29 +929,38 @@ class SchemaController {
           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(() => 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(() => this.setPermissions(className, classLevelPermissions, newSchema)).then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, fullNewSchema)).then(() => this.reloadData({ clearCache: true }))
+      }).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: this.data[className],
-          classLevelPermissions: this.perms[className]
+          fields: schema.fields,
+          classLevelPermissions: schema.classLevelPermissions
         };
-        if (this.indexes[className] && Object.keys(this.indexes[className]).length !== 0) {
-          reloadedSchema.indexes = this.indexes[className];
+        if (schema.indexes && Object.keys(schema.indexes).length !== 0) {
+          reloadedSchema.indexes = schema.indexes;
         }
         return reloadedSchema;
       });
@@ -569,33 +976,35 @@ class SchemaController {
   // Returns a promise that resolves successfully to the new schema
   // object or fails with a reason.
   enforceClassExists(className) {
-    if (this.data[className]) {
+    if (this.schemaData[className]) {
       return Promise.resolve(this);
     }
     // We don't have this class. Update the schema
-    return this.addClassIfNotExists(className)
-    // The schema update succeeded. Reload the schema
-    .then(() => this.reloadData({ clearCache: true })).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.data[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');
-    });
+    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.data[className]) {
+    if (this.schemaData[className]) {
       throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);
     }
     if (!classNameIsValid(className)) {
@@ -606,11 +1015,10 @@ class SchemaController {
     }
     return this.validateSchemaData(className, fields, classLevelPermissions, []);
   }
-
   validateSchemaData(className, fields, classLevelPermissions, existingFieldNames) {
     for (const fieldName in fields) {
       if (existingFieldNames.indexOf(fieldName) < 0) {
-        if (!fieldNameIsValid(fieldName)) {
+        if (!fieldNameIsValid(fieldName, className)) {
           return {
             code: Parse.Error.INVALID_KEY_NAME,
             error: 'invalid field name: ' + fieldName
@@ -622,15 +1030,45 @@ class SchemaController {
             error: 'field ' + fieldName + ' cannot be added'
           };
         }
-        const error = fieldTypeIsInvalid(fields[fieldName]);
-        if (error) return { code: error.code, error: error.message };
+        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 {
@@ -638,76 +1076,118 @@ class SchemaController {
         error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.'
       };
     }
-    validateCLP(classLevelPermissions, fields);
+    validateCLP(classLevelPermissions, fields, this.userIdRegEx);
   }
 
   // Sets the Class-level permissions for a given className, which must exist.
-  setPermissions(className, perms, newSchema) {
+  async setPermissions(className, perms, newSchema) {
     if (typeof perms === 'undefined') {
       return Promise.resolve();
     }
-    validateCLP(perms, newSchema);
-    return this._dbAdapter.setClassLevelPermissions(className, perms);
+    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) {
-    if (fieldName.indexOf(".") > 0) {
-      // subdocument key (x.y) => ok if x is of type 'object'
-      fieldName = fieldName.split(".")[0];
-      type = 'Object';
+  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(fieldName)) {
+    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 Promise.resolve(this);
+      return undefined;
     }
-
-    return this.reloadData().then(() => {
+    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 = {
+          type: type
+        };
       }
-
-      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)}`);
-        }
-        return this;
+      if (!expectedType || !dbTypeMatchesObjectType(expectedType, type)) {
+        throw new Parse.Error(Parse.Error.INVALID_JSON, `Could not add field ${fieldName}`);
       }
-
-      return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => {
-        // The update succeeded. Reload the schema
-        return this.reloadData({ clearCache: true });
-      }, 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 this.reloadData({ clearCache: true });
-      }).then(() => {
-        // Ensure that the schema now validates
-        const expectedType = this.getExpectedType(className, fieldName);
-        if (typeof type === 'string') {
-          type = { type };
-        }
-        if (!expectedType || !dbTypeMatchesObjectType(expectedType, type)) {
-          throw new Parse.Error(Parse.Error.INVALID_JSON, `Could not add field ${fieldName}`);
-        }
-        // Remove the cached schema
-        this._cache.clear();
-        return this;
-      });
-    });
+    }
   }
 
   // maintain compatibility
@@ -726,9 +1206,8 @@ class SchemaController {
     if (!classNameIsValid(className)) {
       throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(className));
     }
-
     fieldNames.forEach(fieldName => {
-      if (!fieldNameIsValid(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.
@@ -736,8 +1215,9 @@ class SchemaController {
         throw new Parse.Error(136, `field ${fieldName} cannot be changed`);
       }
     });
-
-    return this.getOneSchema(className, false, { clearCache: true }).catch(error => {
+    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 {
@@ -749,8 +1229,9 @@ class SchemaController {
           throw new Parse.Error(255, `Field ${fieldName} does not exist, cannot delete.`);
         }
       });
-
-      const schemaFields = _extends({}, schema.fields);
+      const schemaFields = {
+        ...schema.fields
+      };
       return database.adapter.deleteFields(className, schema, fieldNames).then(() => {
         return Promise.all(fieldNames.map(fieldName => {
           const field = schemaFields[fieldName];
@@ -762,31 +1243,30 @@ class SchemaController {
         }));
       });
     }).then(() => {
-      this._cache.clear();
+      _SchemaCache.default.clear();
     });
   }
 
   // Validates an object provided in REST format.
   // Returns a promise that resolves to the new schema if this object is
   // valid.
-  validateObject(className, object, query) {
+  async validateObject(className, object, query, maintenance) {
     let geocount = 0;
-    let promise = this.enforceClassExists(className);
+    const schema = await this.enforceClassExists(className);
+    const promises = [];
     for (const fieldName in object) {
-      if (object[fieldName] === undefined) {
-        continue;
-      }
-      const expected = getType(object[fieldName]);
-      if (expected === 'GeoPoint') {
+      if (object[fieldName] && getType(object[fieldName]) === 'GeoPoint') {
         geocount++;
       }
       if (geocount > 1) {
-        // Make sure all field validation operations run before we return.
-        // If not - we are continuing to run logic, but already provided response from the server.
-        return promise.then(() => {
-          return Promise.reject(new Parse.Error(Parse.Error.INCORRECT_TYPE, 'there can only be one geopoint field in a class'));
-        });
+        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;
       }
@@ -794,23 +1274,30 @@ class SchemaController {
         // Every object has ACL implicitly.
         continue;
       }
-
-      promise = promise.then(schema => schema.enforceFieldExists(className, fieldName, expected));
+      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
+      });
     }
-    promise = thenValidateRequiredColumns(promise, className, object, query);
-    return promise;
+    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[className];
+    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") {
+        if (object[column] && typeof object[column] === 'object') {
           // Trying to delete a required column
           return object[column].__op == 'Delete';
         }
@@ -819,21 +1306,21 @@ class SchemaController {
       }
       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);
+  }
 
-  // Validates the base CLP for an operation
-  testBaseCLP(className, aclGroup, operation) {
-    if (!this.perms[className] || !this.perms[className][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 classPerms = this.perms[className];
-    const perms = classPerms[operation];
-    // Handle the public scenario quickly
+    const perms = classPermissions[operation];
     if (perms['*']) {
       return true;
     }
@@ -847,26 +1334,23 @@ class SchemaController {
   }
 
   // Validates an operation passes class-level-permissions set in the schema
-  validatePermission(className, aclGroup, operation) {
-
-    if (this.testBaseCLP(className, aclGroup, operation)) {
+  static validatePermission(classPermissions, className, aclGroup, operation, action) {
+    if (SchemaController.testPermissions(classPermissions, aclGroup, operation)) {
       return Promise.resolve();
     }
-
-    if (!this.perms[className] || !this.perms[className][operation]) {
+    if (!classPermissions || !classPermissions[operation]) {
       return true;
     }
-    const classPerms = this.perms[className];
-    const perms = classPerms[operation];
-
+    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 new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Permission denied, user needs to be authenticated.');
+        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 new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Permission denied, user needs to be authenticated.');
+        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'
@@ -879,21 +1363,37 @@ class SchemaController {
 
     // Reject create when write lockdown
     if (permissionField == 'writeUserFields' && operation == 'create') {
-      throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, `Permission denied for action ${operation} on class ${className}.`);
+      throw (0, _Error.createSanitizedError)(Parse.Error.OPERATION_FORBIDDEN, `Permission denied for action ${operation} on class ${className}.`, config);
     }
 
     // Process the readUserFields later
-    if (Array.isArray(classPerms[permissionField]) && classPerms[permissionField].length > 0) {
+    if (Array.isArray(classPermissions[permissionField]) && classPermissions[permissionField].length > 0) {
       return Promise.resolve();
     }
-    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, `Permission denied for action ${operation} on class ${className}.`);
+    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.data && this.data[className]) {
-      const expectedType = this.data[className][fieldName];
+    if (this.schemaData[className]) {
+      const expectedType = this.schemaData[className].fields[fieldName];
       return expectedType === 'map' ? 'Object' : expectedType;
     }
     return undefined;
@@ -901,14 +1401,18 @@ class SchemaController {
 
   // Checks if a given class is in the schema.
   hasClass(className) {
-    return this.reloadData().then(() => !!this.data[className]);
+    if (this.schemaData[className]) {
+      return Promise.resolve(true);
+    }
+    return this.reloadData().then(() => !!this.schemaData[className]);
   }
 }
 
-exports.default = SchemaController; // Returns a promise for a new Schema.
-
-const load = (dbAdapter, schemaCache, options) => {
-  const schema = new SchemaController(dbAdapter, schemaCache);
+// 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);
 };
 
@@ -917,6 +1421,7 @@ const load = (dbAdapter, schemaCache, options) => {
 // 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
@@ -1030,7 +1535,7 @@ function getObjectType(obj) {
         }
         break;
     }
-    throw new Parse.Error(Parse.Error.INCORRECT_TYPE, "This is not a valid " + obj.__type);
+    throw new Parse.Error(Parse.Error.INCORRECT_TYPE, 'This is not a valid ' + obj.__type);
   }
   if (obj['$ne']) {
     return getObjectType(obj['$ne']);
@@ -1059,15 +1564,4 @@ function getObjectType(obj) {
   }
   return 'Object';
 }
-
-exports.load = load;
-exports.classNameIsValid = classNameIsValid;
-exports.fieldNameIsValid = fieldNameIsValid;
-exports.invalidClassNameMessage = invalidClassNameMessage;
-exports.buildMergedSchemaObject = buildMergedSchemaObject;
-exports.systemClasses = systemClasses;
-exports.defaultColumns = defaultColumns;
-exports.convertSchemaToAdapterSchema = convertSchemaToAdapterSchema;
-exports.VolatileClassesSchemas = VolatileClassesSchemas;
-exports.SchemaController = SchemaController;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/SchemaController.js"],"names":["Parse","require","defaultColumns","Object","freeze","_Default","type","_User","_Installation","_Role","targetClass","_Session","_Product","_PushStatus","_JobStatus","_JobSchedule","_Hooks","_GlobalConfig","_Audience","requiredColumns","systemClasses","volatileClasses","userIdRegex","roleRegex","publicRegex","requireAuthenticationRegex","permissionKeyRegex","verifyPermissionKey","key","result","reduce","isGood","regEx","match","Error","INVALID_JSON","CLPValidKeys","validateCLP","perms","fields","keys","forEach","operation","indexOf","Array","isArray","perm","joinClassRegex","classAndFieldRegex","classNameIsValid","className","test","fieldNameIsValid","fieldName","fieldNameIsValidForClass","invalidClassNameMessage","invalidJsonError","validNonRelationOrPointerTypes","fieldTypeIsInvalid","INVALID_CLASS_NAME","undefined","INCORRECT_TYPE","convertSchemaToAdapterSchema","schema","injectDefaultSchema","ACL","_rperm","_wperm","password","_hashed_password","convertAdapterSchemaToParseSchema","authData","indexes","length","classLevelPermissions","defaultSchema","_HooksSchema","_GlobalConfigSchema","_PushStatusSchema","_JobStatusSchema","_JobScheduleSchema","_AudienceSchema","VolatileClassesSchemas","dbTypeMatchesObjectType","dbType","objectType","typeToString","SchemaController","constructor","databaseAdapter","schemaCache","_dbAdapter","_cache","data","reloadData","options","clearCache","promise","Promise","resolve","then","clear","reloadDataPromise","getAllClasses","allSchemas","err","allClasses","map","setAllClasses","getOneSchema","allowVolatileClasses","cached","getClass","setOneSchema","addClassIfNotExists","validationError","validateNewClass","reject","createClass","res","catch","error","code","DUPLICATE_VALUE","updateClass","submittedFields","database","existingFields","name","field","__op","newSchema","buildMergedSchemaObject","defaultFields","fullNewSchema","assign","validateSchemaData","deletedFields","insertedFields","push","deletePromise","deleteFields","promises","enforceFieldExists","all","setPermissions","setIndexesWithSchemaFormat","reloadedSchema","enforceClassExists","existingFieldNames","INVALID_KEY_NAME","message","geoPoints","filter","setClassLevelPermissions","split","expectedType","getExpectedType","addFieldIfNotExists","deleteField","fieldNames","schemaFields","adapter","deleteClass","validateObject","object","query","geocount","expected","getType","thenValidateRequiredColumns","validateRequiredColumns","columns","missingColumns","column","objectId","testBaseCLP","aclGroup","classPerms","some","acl","validatePermission","OBJECT_NOT_FOUND","permissionField","OPERATION_FORBIDDEN","hasClass","load","dbAdapter","putRequest","sysSchemaField","_id","oldField","fieldIsDeleted","newField","schemaPromise","obj","getObjectType","__type","iso","latitude","longitude","base64","coordinates","objects","ops"],"mappings":"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","file":"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 DatabaseController     from './DatabaseController';\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    \"restricted\":     {type:'Boolean'},\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  },\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});\n\nconst requiredColumns = Object.freeze({\n  _Product: [\"productIdentifier\", \"icon\", \"order\", \"title\", \"subtitle\"],\n  _Role: [\"name\", \"ACL\"]\n});\n\nconst systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience']);\n\nconst volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule', '_Audience']);\n\n// 10 alpha numberic chars + uppercase\nconst userIdRegex = /^[a-zA-Z0-9]{10}$/;\n// Anything that start with role\nconst roleRegex = /^role:.*/;\n// * permission\nconst publicRegex = /^\\*$/\n\nconst requireAuthenticationRegex = /^requiresAuthentication$/\n\nconst permissionKeyRegex = Object.freeze([userIdRegex, roleRegex, publicRegex, requireAuthenticationRegex]);\n\nfunction verifyPermissionKey(key) {\n  const result = permissionKeyRegex.reduce((isGood, regEx) => {\n    isGood = isGood || key.match(regEx) != null;\n    return isGood;\n  }, false);\n  if (!result) {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid key for class level permissions`);\n  }\n}\n\nconst CLPValidKeys = Object.freeze(['find', 'count', 'get', 'create', 'update', 'delete', 'addField', 'readUserFields', 'writeUserFields']);\nfunction validateCLP(perms: ClassLevelPermissions, fields: SchemaFields) {\n  if (!perms) {\n    return;\n  }\n  Object.keys(perms).forEach((operation) => {\n    if (CLPValidKeys.indexOf(operation) == -1) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, `${operation} is not a valid operation for class level permissions`);\n    }\n    if (!perms[operation]) {\n      return;\n    }\n\n    if (operation === 'readUserFields' || operation === 'writeUserFields') {\n      if (!Array.isArray(perms[operation])) {\n        // @flow-disable-next\n        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perms[operation]}' is not a valid value for class level permissions ${operation}`);\n      } else {\n        perms[operation].forEach((key) => {\n          if (!fields[key] || fields[key].type != 'Pointer' || fields[key].targetClass != '_User') {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid column for class level pointer permissions ${operation}`);\n          }\n        });\n      }\n      return;\n    }\n\n    // @flow-disable-next\n    Object.keys(perms[operation]).forEach((key) => {\n      verifyPermissionKey(key);\n      // @flow-disable-next\n      const perm = perms[operation][key];\n      if (perm !== true) {\n        // @flow-disable-next\n        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perm}' is not a valid value for class level permissions ${operation}:${key}:${perm}`);\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)\n  );\n}\n\n// Valid fields must be alpha-numeric, and not start with an underscore or number\nfunction fieldNameIsValid(fieldName: string): boolean {\n  return classAndFieldRegex.test(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)) {\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 'Invalid classname: ' + className + ', classnames can only have alphanumeric characters and _, and must start with an alpha character ';\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\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 = { className: \"_GlobalConfig\", fields: defaultColumns._GlobalConfig }\nconst _PushStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_PushStatus\",\n  fields: {},\n  classLevelPermissions: {}\n}));\nconst _JobStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_JobStatus\",\n  fields: {},\n  classLevelPermissions: {}\n}));\nconst _JobScheduleSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_JobSchedule\",\n  fields: {},\n  classLevelPermissions: {}\n}));\nconst _AudienceSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_Audience\",\n  fields: defaultColumns._Audience,\n  classLevelPermissions: {}\n}));\nconst VolatileClassesSchemas = [_HooksSchema, _JobStatusSchema, _JobScheduleSchema, _PushStatusSchema, _GlobalConfigSchema, _AudienceSchema];\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}\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  data: any;\n  perms: any;\n  indexes: any;\n  _cache: any;\n  reloadDataPromise: Promise<any>;\n\n  constructor(databaseAdapter: StorageAdapter, schemaCache: any) {\n    this._dbAdapter = databaseAdapter;\n    this._cache = schemaCache;\n    // this.data[className][fieldName] tells you the type of that field, in mongo format\n    this.data = {};\n    // this.perms[className][operation] tells you the acl-style permissions\n    this.perms = {};\n    // this.indexes[className][operation] tells you the indexes\n    this.indexes = {};\n  }\n\n  reloadData(options: LoadSchemaOptions = {clearCache: false}): Promise<any> {\n    let promise = Promise.resolve();\n    if (options.clearCache) {\n      promise = promise.then(() => {\n        return this._cache.clear();\n      });\n    }\n    if (this.reloadDataPromise && !options.clearCache) {\n      return this.reloadDataPromise;\n    }\n    this.reloadDataPromise = promise.then(() => {\n      return this.getAllClasses(options).then((allSchemas) => {\n        const data = {};\n        const perms = {};\n        const indexes = {};\n        allSchemas.forEach(schema => {\n          data[schema.className] = injectDefaultSchema(schema).fields;\n          perms[schema.className] = schema.classLevelPermissions;\n          indexes[schema.className] = schema.indexes;\n        });\n\n        // Inject the in-memory classes\n        volatileClasses.forEach(className => {\n          const schema = injectDefaultSchema({ className, fields: {}, classLevelPermissions: {} });\n          data[className] = schema.fields;\n          perms[className] = schema.classLevelPermissions;\n          indexes[className] = schema.indexes;\n        });\n        this.data = data;\n        this.perms = perms;\n        this.indexes = indexes;\n        delete this.reloadDataPromise;\n      }, (err) => {\n        this.data = {};\n        this.perms = {};\n        this.indexes = {};\n        delete this.reloadDataPromise;\n        throw err;\n      })\n    }).then(() => {});\n    return this.reloadDataPromise;\n  }\n\n  getAllClasses(options: LoadSchemaOptions = {clearCache: false}): Promise<Array<Schema>> {\n    let promise = Promise.resolve();\n    if (options.clearCache) {\n      promise = this._cache.clear();\n    }\n    return promise.then(() => {\n      return this._cache.getAllClasses()\n    }).then((allClasses) => {\n      if (allClasses && allClasses.length && !options.clearCache) {\n        return Promise.resolve(allClasses);\n      }\n      return this._dbAdapter.getAllClasses()\n        .then(allSchemas => allSchemas.map(injectDefaultSchema))\n        .then(allSchemas => {\n          return this._cache.setAllClasses(allSchemas).then(() => {\n            return allSchemas;\n          });\n        })\n    });\n  }\n\n  getOneSchema(className: string, allowVolatileClasses: boolean = false, options: LoadSchemaOptions = {clearCache: false}): Promise<Schema> {\n    let promise = Promise.resolve();\n    if (options.clearCache) {\n      promise = this._cache.clear();\n    }\n    return promise.then(() => {\n      if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {\n        return Promise.resolve({\n          className,\n          fields: this.data[className],\n          classLevelPermissions: this.perms[className],\n          indexes: this.indexes[className]\n        });\n      }\n      return this._cache.getOneSchema(className).then((cached) => {\n        if (cached && !options.clearCache) {\n          return Promise.resolve(cached);\n        }\n        return this._dbAdapter.getClass(className)\n          .then(injectDefaultSchema)\n          .then((result) => {\n            return this._cache.setOneSchema(className, result).then(() => {\n              return result;\n            })\n          });\n      });\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  addClassIfNotExists(className: string, fields: SchemaFields = {}, classLevelPermissions: any, indexes: any = {}): Promise<void> {\n    var validationError = this.validateNewClass(className, fields, classLevelPermissions);\n    if (validationError) {\n      return Promise.reject(validationError);\n    }\n\n    return this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({ fields, classLevelPermissions, indexes, className }))\n      .then(convertAdapterSchemaToParseSchema)\n      .then((res) => {\n        return this._cache.clear().then(() => {\n          return Promise.resolve(res);\n        });\n      })\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(className: string, submittedFields: SchemaFields, classLevelPermissions: any, indexes: any, database: DatabaseController) {\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 (existingFields[name] && field.__op !== 'Delete') {\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(className, newSchema, classLevelPermissions, Object.keys(existingFields));\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        return 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(() => this.setPermissions(className, classLevelPermissions, newSchema))\n          .then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, fullNewSchema))\n          .then(() => this.reloadData({ clearCache: true }))\n        //TODO: Move this logic into the database adapter\n          .then(() => {\n            const reloadedSchema: Schema = {\n              className: className,\n              fields: this.data[className],\n              classLevelPermissions: this.perms[className],\n            };\n            if (this.indexes[className] && Object.keys(this.indexes[className]).length !== 0) {\n              reloadedSchema.indexes = this.indexes[className];\n            }\n            return reloadedSchema;\n          });\n      })\n      .catch(error => {\n        if (error === undefined) {\n          throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);\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.data[className]) {\n      return Promise.resolve(this);\n    }\n    // We don't have this class. Update the schema\n    return this.addClassIfNotExists(className)\n    // The schema update succeeded. Reload the schema\n      .then(() => this.reloadData({ clearCache: true }))\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.data[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  validateNewClass(className: string, fields: SchemaFields = {}, classLevelPermissions: any): any {\n    if (this.data[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(className: string, fields: SchemaFields, classLevelPermissions: ClassLevelPermissions, existingFieldNames: Array<string>) {\n    for (const fieldName in fields) {\n      if (existingFieldNames.indexOf(fieldName) < 0) {\n        if (!fieldNameIsValid(fieldName)) {\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 error = fieldTypeIsInvalid(fields[fieldName]);\n        if (error) return { code: error.code, error: error.message };\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(key => fields[key] && fields[key].type === 'GeoPoint');\n    if (geoPoints.length > 1) {\n      return {\n        code: Parse.Error.INCORRECT_TYPE,\n        error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.',\n      };\n    }\n    validateCLP(classLevelPermissions, fields);\n  }\n\n  // Sets the Class-level permissions for a given className, which must exist.\n  setPermissions(className: string, perms: any, newSchema: SchemaFields) {\n    if (typeof perms === 'undefined') {\n      return Promise.resolve();\n    }\n    validateCLP(perms, newSchema);\n    return this._dbAdapter.setClassLevelPermissions(className, perms);\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(className: string, fieldName: string, type: string | SchemaField) {\n    if (fieldName.indexOf(\".\") > 0) {\n      // subdocument key (x.y) => ok if x is of type 'object'\n      fieldName = fieldName.split(\".\")[ 0 ];\n      type = 'Object';\n    }\n    if (!fieldNameIsValid(fieldName)) {\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 Promise.resolve(this);\n    }\n\n    return this.reloadData().then(() => {\n      const expectedType = this.getExpectedType(className, fieldName);\n      if (typeof type === 'string') {\n        type = { type };\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(expectedType)} but got ${typeToString(type)}`\n          );\n        }\n        return this;\n      }\n\n      return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => {\n        // The update succeeded. Reload the schema\n        return this.reloadData({ clearCache: true });\n      }, (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 this.reloadData({ clearCache: true });\n      }).then(() => {\n        // Ensure that the schema now validates\n        const expectedType = this.getExpectedType(className, fieldName);\n        if (typeof type === 'string') {\n          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        // Remove the cached schema\n        this._cache.clear();\n        return this;\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)) {\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(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);\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)\n          .then(() => {\n            return Promise.all(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      }).then(() => {\n        this._cache.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  validateObject(className: string, object: any, query: any) {\n    let geocount = 0;\n    let promise = this.enforceClassExists(className);\n    for (const fieldName in object) {\n      if (object[fieldName] === undefined) {\n        continue;\n      }\n      const expected = getType(object[fieldName]);\n      if (expected === 'GeoPoint') {\n        geocount++;\n      }\n      if (geocount > 1) {\n        // Make sure all field validation operations run before we return.\n        // If not - we are continuing to run logic, but already provided response from the server.\n        return promise.then(() => {\n          return Promise.reject(new Parse.Error(Parse.Error.INCORRECT_TYPE,\n            'there can only be one geopoint field in a class'));\n        });\n      }\n      if (!expected) {\n        continue;\n      }\n      if (fieldName === 'ACL') {\n        // Every object has ACL implicitly.\n        continue;\n      }\n\n      promise = promise.then(schema => schema.enforceFieldExists(className, fieldName, expected));\n    }\n    promise = thenValidateRequiredColumns(promise, className, object, query);\n    return promise;\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[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(\n        Parse.Error.INCORRECT_TYPE,\n        missingColumns[0] + ' is required.');\n    }\n    return Promise.resolve(this);\n  }\n\n  // Validates the base CLP for an operation\n  testBaseCLP(className: string, aclGroup: string[], operation: string) {\n    if (!this.perms[className] || !this.perms[className][operation]) {\n      return true;\n    }\n    const classPerms = this.perms[className];\n    const perms = classPerms[operation];\n    // Handle the public scenario quickly\n    if (perms['*']) {\n      return true;\n    }\n    // Check permissions against the aclGroup provided (array of userId/roles)\n    if (aclGroup.some(acl => { return perms[acl] === true })) {\n      return true;\n    }\n    return false;\n  }\n\n  // Validates an operation passes class-level-permissions set in the schema\n  validatePermission(className: string, aclGroup: string[], operation: string) {\n\n    if (this.testBaseCLP(className, aclGroup, operation)) {\n      return Promise.resolve();\n    }\n\n    if (!this.perms[className] || !this.perms[className][operation]) {\n      return true;\n    }\n    const classPerms = this.perms[className];\n    const perms = classPerms[operation];\n\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 new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n          'Permission denied, user needs to be authenticated.');\n      } else if (aclGroup.indexOf('*') > -1 && aclGroup.length == 1) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n          'Permission denied, user needs to be authenticated.');\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 = ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';\n\n    // Reject create when write lockdown\n    if (permissionField == 'writeUserFields' && operation == 'create') {\n      throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n        `Permission denied for action ${operation} on class ${className}.`);\n    }\n\n    // Process the readUserFields later\n    if (Array.isArray(classPerms[permissionField]) && classPerms[permissionField].length > 0) {\n      return Promise.resolve();\n    }\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n      `Permission denied for action ${operation} on class ${className}.`);\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.data && this.data[className]) {\n      const expectedType = this.data[className][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    return this.reloadData().then(() => !!(this.data[className]));\n  }\n}\n\n// Returns a promise for a new Schema.\nconst load = (dbAdapter: StorageAdapter, schemaCache: any, options: any): Promise<SchemaController> => {\n  const schema = new SchemaController(dbAdapter, schemaCache);\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 = Object.keys(defaultColumns).indexOf(existingFields._id) === -1 ? [] : Object.keys(defaultColumns[existingFields._id]);\n  for (const oldField in existingFields) {\n    if (oldField !== '_id' && oldField !== 'ACL' &&  oldField !== 'updatedAt' && oldField !== 'createdAt' && oldField !== 'objectId') {\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 (obj instanceof Array) {\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};\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_StorageAdapter","require","_SchemaCache","_interopRequireDefault","_DatabaseController","_Config","_Error","_deepcopy","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","deepcopy","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';\n// @flow-disable-next\nimport deepcopy from 'deepcopy';\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 = deepcopy(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 (obj instanceof Array) {\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":[]}