parse-server 5.0.0-alpha.2 → 5.0.0-alpha.23

package/lib/Routers/SchemasRouter.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SchemasRouter = void 0;
+exports.SchemasRouter = exports.internalUpdateSchema = exports.internalCreateSchema = void 0;
 
 var _PromiseRouter = _interopRequireDefault(require("../PromiseRouter"));
 
@@ -26,7 +26,9 @@ function classNameMismatchResponse(bodyClass, pathClass) {
 function getAllSchemas(req) {
   return req.config.database.loadSchema({
     clearCache: true
-  }).then(schemaController => schemaController.getAllClasses(true)).then(schemas => ({
+  }).then(schemaController => schemaController.getAllClasses({
+    clearCache: true
+  })).then(schemas => ({
     response: {
       results: schemas
     }
@@ -48,7 +50,41 @@ function getOneSchema(req) {
   });
 }
 
-function createSchema(req) {
+const checkIfDefinedSchemasIsUsed = req => {
+  var _req$config, _req$config$schema;
+
+  if (((_req$config = req.config) === null || _req$config === void 0 ? void 0 : (_req$config$schema = _req$config.schema) === null || _req$config$schema === void 0 ? void 0 : _req$config$schema.lockSchemas) === true) {
+    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform this operation when schemas options is used.');
+  }
+};
+
+const internalCreateSchema = async (className, body, config) => {
+  const controller = await config.database.loadSchema({
+    clearCache: true
+  });
+  const response = await controller.addClassIfNotExists(className, body.fields, body.classLevelPermissions, body.indexes);
+  return {
+    response
+  };
+};
+
+exports.internalCreateSchema = internalCreateSchema;
+
+const internalUpdateSchema = async (className, body, config) => {
+  const controller = await config.database.loadSchema({
+    clearCache: true
+  });
+  const response = await controller.updateClass(className, body.fields || {}, body.classLevelPermissions, body.indexes, config.database);
+  return {
+    response
+  };
+};
+
+exports.internalUpdateSchema = internalUpdateSchema;
+
+async function createSchema(req) {
+  checkIfDefinedSchemasIsUsed(req);
+
   if (req.auth.isReadOnly) {
     throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, "read-only masterKey isn't allowed to create a schema.");
   }
@@ -65,14 +101,12 @@ function createSchema(req) {
     throw new Parse.Error(135, `POST ${req.path} needs a class name.`);
   }
 
-  return req.config.database.loadSchema({
-    clearCache: true
-  }).then(schema => schema.addClassIfNotExists(className, req.body.fields, req.body.classLevelPermissions, req.body.indexes)).then(schema => ({
-    response: schema
-  }));
+  return await internalCreateSchema(className, req.body, req.config);
 }
 
 function modifySchema(req) {
+  checkIfDefinedSchemasIsUsed(req);
+
   if (req.auth.isReadOnly) {
     throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, "read-only masterKey isn't allowed to update a schema.");
   }
@@ -81,13 +115,8 @@ function modifySchema(req) {
     return classNameMismatchResponse(req.body.className, req.params.className);
   }
 
-  const submittedFields = req.body.fields || {};
   const className = req.params.className;
-  return req.config.database.loadSchema({
-    clearCache: true
-  }).then(schema => schema.updateClass(className, submittedFields, req.body.classLevelPermissions, req.body.indexes, req.config.database)).then(result => ({
-    response: result
-  }));
+  return internalUpdateSchema(className, req.body, req.config);
 }
 
 const deleteSchema = req => {
@@ -117,4 +146,4 @@ class SchemasRouter extends _PromiseRouter.default {
 }
 
 exports.SchemasRouter = SchemasRouter;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/SchemasRouter.js"],"names":["Parse","require","SchemaController","classNameMismatchResponse","bodyClass","pathClass","Error","INVALID_CLASS_NAME","getAllSchemas","req","config","database","loadSchema","clearCache","then","schemaController","getAllClasses","schemas","response","results","getOneSchema","className","params","schema","catch","error","undefined","INTERNAL_SERVER_ERROR","createSchema","auth","isReadOnly","OPERATION_FORBIDDEN","body","path","addClassIfNotExists","fields","classLevelPermissions","indexes","modifySchema","submittedFields","updateClass","result","deleteSchema","classNameIsValid","invalidClassNameMessage","SchemasRouter","PromiseRouter","mountRoutes","route","middleware","promiseEnforceMasterKeyAccess"],"mappings":"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","sourcesContent":["// schemas.js\n\nvar Parse = require('parse/node').Parse,\n  SchemaController = require('../Controllers/SchemaController');\n\nimport PromiseRouter from '../PromiseRouter';\nimport * as middleware from '../middlewares';\n\nfunction classNameMismatchResponse(bodyClass, pathClass) {\n  throw new Parse.Error(\n    Parse.Error.INVALID_CLASS_NAME,\n    `Class name mismatch between ${bodyClass} and ${pathClass}.`\n  );\n}\n\nfunction getAllSchemas(req) {\n  return req.config.database\n    .loadSchema({ clearCache: true })\n    .then(schemaController => schemaController.getAllClasses(true))\n    .then(schemas => ({ response: { results: schemas } }));\n}\n\nfunction getOneSchema(req) {\n  const className = req.params.className;\n  return req.config.database\n    .loadSchema({ clearCache: true })\n    .then(schemaController => schemaController.getOneSchema(className, true))\n    .then(schema => ({ response: schema }))\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 new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.');\n      }\n    });\n}\n\nfunction createSchema(req) {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"read-only masterKey isn't allowed to create a schema.\"\n    );\n  }\n  if (req.params.className && req.body.className) {\n    if (req.params.className != req.body.className) {\n      return classNameMismatchResponse(req.body.className, req.params.className);\n    }\n  }\n\n  const className = req.params.className || req.body.className;\n  if (!className) {\n    throw new Parse.Error(135, `POST ${req.path} needs a class name.`);\n  }\n\n  return req.config.database\n    .loadSchema({ clearCache: true })\n    .then(schema =>\n      schema.addClassIfNotExists(\n        className,\n        req.body.fields,\n        req.body.classLevelPermissions,\n        req.body.indexes\n      )\n    )\n    .then(schema => ({ response: schema }));\n}\n\nfunction modifySchema(req) {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"read-only masterKey isn't allowed to update a schema.\"\n    );\n  }\n  if (req.body.className && req.body.className != req.params.className) {\n    return classNameMismatchResponse(req.body.className, req.params.className);\n  }\n\n  const submittedFields = req.body.fields || {};\n  const className = req.params.className;\n\n  return req.config.database\n    .loadSchema({ clearCache: true })\n    .then(schema =>\n      schema.updateClass(\n        className,\n        submittedFields,\n        req.body.classLevelPermissions,\n        req.body.indexes,\n        req.config.database\n      )\n    )\n    .then(result => ({ response: result }));\n}\n\nconst deleteSchema = req => {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"read-only masterKey isn't allowed to delete a schema.\"\n    );\n  }\n  if (!SchemaController.classNameIsValid(req.params.className)) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_CLASS_NAME,\n      SchemaController.invalidClassNameMessage(req.params.className)\n    );\n  }\n  return req.config.database.deleteSchema(req.params.className).then(() => ({ response: {} }));\n};\n\nexport class SchemasRouter extends PromiseRouter {\n  mountRoutes() {\n    this.route('GET', '/schemas', middleware.promiseEnforceMasterKeyAccess, getAllSchemas);\n    this.route(\n      'GET',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      getOneSchema\n    );\n    this.route('POST', '/schemas', middleware.promiseEnforceMasterKeyAccess, createSchema);\n    this.route(\n      'POST',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      createSchema\n    );\n    this.route(\n      'PUT',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      modifySchema\n    );\n    this.route(\n      'DELETE',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      deleteSchema\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/SchemasRouter.js"],"names":["Parse","require","SchemaController","classNameMismatchResponse","bodyClass","pathClass","Error","INVALID_CLASS_NAME","getAllSchemas","req","config","database","loadSchema","clearCache","then","schemaController","getAllClasses","schemas","response","results","getOneSchema","className","params","schema","catch","error","undefined","INTERNAL_SERVER_ERROR","checkIfDefinedSchemasIsUsed","lockSchemas","OPERATION_FORBIDDEN","internalCreateSchema","body","controller","addClassIfNotExists","fields","classLevelPermissions","indexes","internalUpdateSchema","updateClass","createSchema","auth","isReadOnly","path","modifySchema","deleteSchema","classNameIsValid","invalidClassNameMessage","SchemasRouter","PromiseRouter","mountRoutes","route","middleware","promiseEnforceMasterKeyAccess"],"mappings":"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","sourcesContent":["// schemas.js\n\nvar Parse = require('parse/node').Parse,\n  SchemaController = require('../Controllers/SchemaController');\n\nimport PromiseRouter from '../PromiseRouter';\nimport * as middleware from '../middlewares';\n\nfunction classNameMismatchResponse(bodyClass, pathClass) {\n  throw new Parse.Error(\n    Parse.Error.INVALID_CLASS_NAME,\n    `Class name mismatch between ${bodyClass} and ${pathClass}.`\n  );\n}\n\nfunction getAllSchemas(req) {\n  return req.config.database\n    .loadSchema({ clearCache: true })\n    .then(schemaController => schemaController.getAllClasses({ clearCache: true }))\n    .then(schemas => ({ response: { results: schemas } }));\n}\n\nfunction getOneSchema(req) {\n  const className = req.params.className;\n  return req.config.database\n    .loadSchema({ clearCache: true })\n    .then(schemaController => schemaController.getOneSchema(className, true))\n    .then(schema => ({ response: schema }))\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 new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.');\n      }\n    });\n}\n\nconst checkIfDefinedSchemasIsUsed = req => {\n  if (req.config?.schema?.lockSchemas === true) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      'Cannot perform this operation when schemas options is used.'\n    );\n  }\n};\n\nexport const internalCreateSchema = async (className, body, config) => {\n  const controller = await config.database.loadSchema({ clearCache: true });\n  const response = await controller.addClassIfNotExists(\n    className,\n    body.fields,\n    body.classLevelPermissions,\n    body.indexes\n  );\n  return {\n    response,\n  };\n};\n\nexport const internalUpdateSchema = async (className, body, config) => {\n  const controller = await config.database.loadSchema({ clearCache: true });\n  const response = await controller.updateClass(\n    className,\n    body.fields || {},\n    body.classLevelPermissions,\n    body.indexes,\n    config.database\n  );\n  return { response };\n};\n\nasync function createSchema(req) {\n  checkIfDefinedSchemasIsUsed(req);\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"read-only masterKey isn't allowed to create a schema.\"\n    );\n  }\n  if (req.params.className && req.body.className) {\n    if (req.params.className != req.body.className) {\n      return classNameMismatchResponse(req.body.className, req.params.className);\n    }\n  }\n\n  const className = req.params.className || req.body.className;\n  if (!className) {\n    throw new Parse.Error(135, `POST ${req.path} needs a class name.`);\n  }\n\n  return await internalCreateSchema(className, req.body, req.config);\n}\n\nfunction modifySchema(req) {\n  checkIfDefinedSchemasIsUsed(req);\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"read-only masterKey isn't allowed to update a schema.\"\n    );\n  }\n  if (req.body.className && req.body.className != req.params.className) {\n    return classNameMismatchResponse(req.body.className, req.params.className);\n  }\n  const className = req.params.className;\n\n  return internalUpdateSchema(className, req.body, req.config);\n}\n\nconst deleteSchema = req => {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(\n      Parse.Error.OPERATION_FORBIDDEN,\n      \"read-only masterKey isn't allowed to delete a schema.\"\n    );\n  }\n  if (!SchemaController.classNameIsValid(req.params.className)) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_CLASS_NAME,\n      SchemaController.invalidClassNameMessage(req.params.className)\n    );\n  }\n  return req.config.database.deleteSchema(req.params.className).then(() => ({ response: {} }));\n};\n\nexport class SchemasRouter extends PromiseRouter {\n  mountRoutes() {\n    this.route('GET', '/schemas', middleware.promiseEnforceMasterKeyAccess, getAllSchemas);\n    this.route(\n      'GET',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      getOneSchema\n    );\n    this.route('POST', '/schemas', middleware.promiseEnforceMasterKeyAccess, createSchema);\n    this.route(\n      'POST',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      createSchema\n    );\n    this.route(\n      'PUT',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      modifySchema\n    );\n    this.route(\n      'DELETE',\n      '/schemas/:className',\n      middleware.promiseEnforceMasterKeyAccess,\n      deleteSchema\n    );\n  }\n}\n"]}

package/lib/SchemaMigrations/DefinedSchemas.js

@@ -0,0 +1,421 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DefinedSchemas = void 0;
+
+var _logger = require("../logger");
+
+var _Config = _interopRequireDefault(require("../Config"));
+
+var _SchemasRouter = require("../Routers/SchemasRouter");
+
+var _SchemaController = require("../Controllers/SchemaController");
+
+var _Options = require("../Options");
+
+var Migrations = _interopRequireWildcard(require("./Migrations"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// -disable-next Cannot resolve module `parse/node`.
+const Parse = require('parse/node');
+
+class DefinedSchemas {
+  constructor(schemaOptions, config) {
+    this.localSchemas = [];
+    this.config = _Config.default.get(config.appId);
+    this.schemaOptions = schemaOptions;
+
+    if (schemaOptions && schemaOptions.definitions) {
+      if (!Array.isArray(schemaOptions.definitions)) {
+        throw `"schema.definitions" must be an array of schemas`;
+      }
+
+      this.localSchemas = schemaOptions.definitions;
+    }
+
+    this.retries = 0;
+    this.maxRetries = 3;
+  }
+
+  async saveSchemaToDB(schema) {
+    const payload = {
+      className: schema.className,
+      fields: schema._fields,
+      indexes: schema._indexes,
+      classLevelPermissions: schema._clp
+    };
+    await (0, _SchemasRouter.internalCreateSchema)(schema.className, payload, this.config);
+    this.resetSchemaOps(schema);
+  }
+
+  resetSchemaOps(schema) {
+    // Reset ops like SDK
+    schema._fields = {};
+    schema._indexes = {};
+  } // Simulate update like the SDK
+  // We cannot use SDK since routes are disabled
+
+
+  async updateSchemaToDB(schema) {
+    const payload = {
+      className: schema.className,
+      fields: schema._fields,
+      indexes: schema._indexes,
+      classLevelPermissions: schema._clp
+    };
+    await (0, _SchemasRouter.internalUpdateSchema)(schema.className, payload, this.config);
+    this.resetSchemaOps(schema);
+  }
+
+  async execute() {
+    try {
+      _logger.logger.info('Running Migrations');
+
+      if (this.schemaOptions && this.schemaOptions.beforeMigration) {
+        await Promise.resolve(this.schemaOptions.beforeMigration());
+      }
+
+      await this.executeMigrations();
+
+      if (this.schemaOptions && this.schemaOptions.afterMigration) {
+        await Promise.resolve(this.schemaOptions.afterMigration());
+      }
+
+      _logger.logger.info('Running Migrations Completed');
+    } catch (e) {
+      _logger.logger.error(`Failed to run migrations: ${e}`);
+
+      if (process.env.NODE_ENV === 'production') process.exit(1);
+    }
+  }
+
+  async executeMigrations() {
+    let timeout = null;
+
+    try {
+      // Set up a time out in production
+      // if we fail to get schema
+      // pm2 or K8s and many other process managers will try to restart the process
+      // after the exit
+      if (process.env.NODE_ENV === 'production') {
+        timeout = setTimeout(() => {
+          _logger.logger.error('Timeout occurred during execution of migrations. Exiting...');
+
+          process.exit(1);
+        }, 20000);
+      } // Hack to force session schema to be created
+
+
+      await this.createDeleteSession();
+      this.allCloudSchemas = await Parse.Schema.all();
+      clearTimeout(timeout);
+      await Promise.all(this.localSchemas.map(async localSchema => this.saveOrUpdate(localSchema)));
+      this.checkForMissingSchemas();
+      await this.enforceCLPForNonProvidedClass();
+    } catch (e) {
+      if (timeout) clearTimeout(timeout);
+
+      if (this.retries < this.maxRetries) {
+        this.retries++; // first retry 1sec, 2sec, 3sec total 6sec retry sequence
+        // retry will only happen in case of deploying multi parse server instance
+        // at the same time. Modern systems like k8 avoid this by doing rolling updates
+
+        await this.wait(1000 * this.retries);
+        await this.executeMigrations();
+      } else {
+        _logger.logger.error(`Failed to run migrations: ${e}`);
+
+        if (process.env.NODE_ENV === 'production') process.exit(1);
+      }
+    }
+  }
+
+  checkForMissingSchemas() {
+    if (this.schemaOptions.strict !== true) {
+      return;
+    }
+
+    const cloudSchemas = this.allCloudSchemas.map(s => s.className);
+    const localSchemas = this.localSchemas.map(s => s.className);
+    const missingSchemas = cloudSchemas.filter(c => !localSchemas.includes(c) && !_SchemaController.systemClasses.includes(c));
+
+    if (new Set(localSchemas).size !== localSchemas.length) {
+      _logger.logger.error(`The list of schemas provided contains duplicated "className"  "${localSchemas.join('","')}"`);
+
+      process.exit(1);
+    }
+
+    if (this.schemaOptions.strict && missingSchemas.length) {
+      _logger.logger.warn(`The following schemas are currently present in the database, but not explicitly defined in a schema: "${missingSchemas.join('", "')}"`);
+    }
+  } // Required for testing purpose
+
+
+  wait(time) {
+    return new Promise(resolve => setTimeout(resolve, time));
+  }
+
+  async enforceCLPForNonProvidedClass() {
+    const nonProvidedClasses = this.allCloudSchemas.filter(cloudSchema => !this.localSchemas.some(localSchema => localSchema.className === cloudSchema.className));
+    await Promise.all(nonProvidedClasses.map(async schema => {
+      const parseSchema = new Parse.Schema(schema.className);
+      this.handleCLP(schema, parseSchema);
+      await this.updateSchemaToDB(parseSchema);
+    }));
+  } // Create a fake session since Parse do not create the _Session until
+  // a session is created
+
+
+  async createDeleteSession() {
+    const session = new Parse.Session();
+    await session.save(null, {
+      useMasterKey: true
+    });
+    await session.destroy({
+      useMasterKey: true
+    });
+  }
+
+  async saveOrUpdate(localSchema) {
+    const cloudSchema = this.allCloudSchemas.find(sc => sc.className === localSchema.className);
+
+    if (cloudSchema) {
+      try {
+        await this.updateSchema(localSchema, cloudSchema);
+      } catch (e) {
+        throw `Error during update of schema for type ${cloudSchema.className}: ${e}`;
+      }
+    } else {
+      try {
+        await this.saveSchema(localSchema);
+      } catch (e) {
+        throw `Error while saving Schema for type ${localSchema.className}: ${e}`;
+      }
+    }
+  }
+
+  async saveSchema(localSchema) {
+    const newLocalSchema = new Parse.Schema(localSchema.className);
+
+    if (localSchema.fields) {
+      // Handle fields
+      Object.keys(localSchema.fields).filter(fieldName => !this.isProtectedFields(localSchema.className, fieldName)).forEach(fieldName => {
+        if (localSchema.fields) {
+          const field = localSchema.fields[fieldName];
+          this.handleFields(newLocalSchema, fieldName, field);
+        }
+      });
+    } // Handle indexes
+
+
+    if (localSchema.indexes) {
+      Object.keys(localSchema.indexes).forEach(indexName => {
+        if (localSchema.indexes && !this.isProtectedIndex(localSchema.className, indexName)) {
+          newLocalSchema.addIndex(indexName, localSchema.indexes[indexName]);
+        }
+      });
+    }
+
+    this.handleCLP(localSchema, newLocalSchema);
+    return await this.saveSchemaToDB(newLocalSchema);
+  }
+
+  async updateSchema(localSchema, cloudSchema) {
+    const newLocalSchema = new Parse.Schema(localSchema.className); // Handle fields
+    // Check addition
+
+    if (localSchema.fields) {
+      Object.keys(localSchema.fields).filter(fieldName => !this.isProtectedFields(localSchema.className, fieldName)).forEach(fieldName => {
+        // -disable-next
+        const field = localSchema.fields[fieldName];
+
+        if (!cloudSchema.fields[fieldName]) {
+          this.handleFields(newLocalSchema, fieldName, field);
+        }
+      });
+    }
+
+    const fieldsToDelete = [];
+    const fieldsToRecreate = [];
+    const fieldsWithChangedParams = []; // Check deletion
+
+    Object.keys(cloudSchema.fields).filter(fieldName => !this.isProtectedFields(localSchema.className, fieldName)).forEach(fieldName => {
+      const field = cloudSchema.fields[fieldName];
+
+      if (!localSchema.fields || !localSchema.fields[fieldName]) {
+        fieldsToDelete.push(fieldName);
+        return;
+      }
+
+      const localField = localSchema.fields[fieldName]; // Check if field has a changed type
+
+      if (!this.paramsAreEquals({
+        type: field.type,
+        targetClass: field.targetClass
+      }, {
+        type: localField.type,
+        targetClass: localField.targetClass
+      })) {
+        fieldsToRecreate.push({
+          fieldName,
+          from: {
+            type: field.type,
+            targetClass: field.targetClass
+          },
+          to: {
+            type: localField.type,
+            targetClass: localField.targetClass
+          }
+        });
+        return;
+      } // Check if something changed other than the type (like required, defaultValue)
+
+
+      if (!this.paramsAreEquals(field, localField)) {
+        fieldsWithChangedParams.push(fieldName);
+      }
+    });
+
+    if (this.schemaOptions.deleteExtraFields === true) {
+      fieldsToDelete.forEach(fieldName => {
+        newLocalSchema.deleteField(fieldName);
+      }); // Delete fields from the schema then apply changes
+
+      await this.updateSchemaToDB(newLocalSchema);
+    } else if (this.schemaOptions.strict === true && fieldsToDelete.length) {
+      _logger.logger.warn(`The following fields exist in the database for "${localSchema.className}", but are missing in the schema : "${fieldsToDelete.join('" ,"')}"`);
+    }
+
+    if (this.schemaOptions.recreateModifiedFields === true) {
+      fieldsToRecreate.forEach(field => {
+        newLocalSchema.deleteField(field.fieldName);
+      }); // Delete fields from the schema then apply changes
+
+      await this.updateSchemaToDB(newLocalSchema);
+      fieldsToRecreate.forEach(fieldInfo => {
+        if (localSchema.fields) {
+          const field = localSchema.fields[fieldInfo.fieldName];
+          this.handleFields(newLocalSchema, fieldInfo.fieldName, field);
+        }
+      });
+    } else if (this.schemaOptions.strict === true && fieldsToRecreate.length) {
+      fieldsToRecreate.forEach(field => {
+        const from = field.from.type + (field.from.targetClass ? ` (${field.from.targetClass})` : '');
+        const to = field.to.type + (field.to.targetClass ? ` (${field.to.targetClass})` : '');
+
+        _logger.logger.warn(`The field "${field.fieldName}" type differ between the schema and the database for "${localSchema.className}"; Schema is defined as "${to}" and current database type is "${from}"`);
+      });
+    }
+
+    fieldsWithChangedParams.forEach(fieldName => {
+      if (localSchema.fields) {
+        const field = localSchema.fields[fieldName];
+        this.handleFields(newLocalSchema, fieldName, field);
+      }
+    }); // Handle Indexes
+    // Check addition
+
+    if (localSchema.indexes) {
+      Object.keys(localSchema.indexes).forEach(indexName => {
+        if ((!cloudSchema.indexes || !cloudSchema.indexes[indexName]) && !this.isProtectedIndex(localSchema.className, indexName)) {
+          if (localSchema.indexes) {
+            newLocalSchema.addIndex(indexName, localSchema.indexes[indexName]);
+          }
+        }
+      });
+    }
+
+    const indexesToAdd = []; // Check deletion
+
+    if (cloudSchema.indexes) {
+      Object.keys(cloudSchema.indexes).forEach(indexName => {
+        if (!this.isProtectedIndex(localSchema.className, indexName)) {
+          if (!localSchema.indexes || !localSchema.indexes[indexName]) {
+            newLocalSchema.deleteIndex(indexName);
+          } else if (!this.paramsAreEquals(localSchema.indexes[indexName], cloudSchema.indexes[indexName])) {
+            newLocalSchema.deleteIndex(indexName);
+
+            if (localSchema.indexes) {
+              indexesToAdd.push({
+                indexName,
+                index: localSchema.indexes[indexName]
+              });
+            }
+          }
+        }
+      });
+    }
+
+    this.handleCLP(localSchema, newLocalSchema, cloudSchema); // Apply changes
+
+    await this.updateSchemaToDB(newLocalSchema); // Apply new/changed indexes
+
+    if (indexesToAdd.length) {
+      _logger.logger.debug(`Updating indexes for "${newLocalSchema.className}" :  ${indexesToAdd.join(' ,')}`);
+
+      indexesToAdd.forEach(o => newLocalSchema.addIndex(o.indexName, o.index));
+      await this.updateSchemaToDB(newLocalSchema);
+    }
+  }
+
+  handleCLP(localSchema, newLocalSchema, cloudSchema) {
+    if (!localSchema.classLevelPermissions && !cloudSchema) {
+      _logger.logger.warn(`classLevelPermissions not provided for ${localSchema.className}.`);
+    } // Use spread to avoid read only issue (encountered by Moumouls using directAccess)
+
+
+    const clp = _objectSpread({}, localSchema.classLevelPermissions) || {}; // To avoid inconsistency we need to remove all rights on addField
+
+    clp.addField = {};
+    newLocalSchema.setCLP(clp);
+  }
+
+  isProtectedFields(className, fieldName) {
+    return !!_SchemaController.defaultColumns._Default[fieldName] || !!(_SchemaController.defaultColumns[className] && _SchemaController.defaultColumns[className][fieldName]);
+  }
+
+  isProtectedIndex(className, indexName) {
+    let indexes = ['_id_'];
+
+    if (className === '_User') {
+      indexes = [...indexes, 'case_insensitive_username', 'case_insensitive_email', 'username_1', 'email_1'];
+    }
+
+    return indexes.indexOf(indexName) !== -1;
+  }
+
+  paramsAreEquals(objA, objB) {
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB); // Check key name
+
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(k => objA[k] === objB[k]);
+  }
+
+  handleFields(newLocalSchema, fieldName, field) {
+    if (field.type === 'Relation') {
+      newLocalSchema.addRelation(fieldName, field.targetClass);
+    } else if (field.type === 'Pointer') {
+      newLocalSchema.addPointer(fieldName, field.targetClass, field);
+    } else {
+      newLocalSchema.addField(fieldName, field.type, field);
+    }
+  }
+
+}
+
+exports.DefinedSchemas = DefinedSchemas;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/SchemaMigrations/DefinedSchemas.js"],"names":["Parse","require","DefinedSchemas","constructor","schemaOptions","config","localSchemas","Config","get","appId","definitions","Array","isArray","retries","maxRetries","saveSchemaToDB","schema","payload","className","fields","_fields","indexes","_indexes","classLevelPermissions","_clp","resetSchemaOps","updateSchemaToDB","execute","logger","info","beforeMigration","Promise","resolve","executeMigrations","afterMigration","e","error","process","env","NODE_ENV","exit","timeout","setTimeout","createDeleteSession","allCloudSchemas","Schema","all","clearTimeout","map","localSchema","saveOrUpdate","checkForMissingSchemas","enforceCLPForNonProvidedClass","wait","strict","cloudSchemas","s","missingSchemas","filter","c","includes","systemClasses","Set","size","length","join","warn","time","nonProvidedClasses","cloudSchema","some","parseSchema","handleCLP","session","Session","save","useMasterKey","destroy","find","sc","updateSchema","saveSchema","newLocalSchema","Object","keys","fieldName","isProtectedFields","forEach","field","handleFields","indexName","isProtectedIndex","addIndex","fieldsToDelete","fieldsToRecreate","fieldsWithChangedParams","push","localField","paramsAreEquals","type","targetClass","from","to","deleteExtraFields","deleteField","recreateModifiedFields","fieldInfo","indexesToAdd","deleteIndex","index","debug","o","clp","addField","setCLP","defaultColumns","_Default","indexOf","objA","objB","keysA","keysB","every","k","addRelation","addPointer"],"mappings":"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","sourcesContent":["// @flow\n// @flow-disable-next Cannot resolve module `parse/node`.\nconst Parse = require('parse/node');\nimport { logger } from '../logger';\nimport Config from '../Config';\nimport { internalCreateSchema, internalUpdateSchema } from '../Routers/SchemasRouter';\nimport { defaultColumns, systemClasses } from '../Controllers/SchemaController';\nimport { ParseServerOptions } from '../Options';\nimport * as Migrations from './Migrations';\n\nexport class DefinedSchemas {\n  config: ParseServerOptions;\n  schemaOptions: Migrations.SchemaOptions;\n  localSchemas: Migrations.JSONSchema[];\n  retries: number;\n  maxRetries: number;\n  allCloudSchemas: Parse.Schema[];\n\n  constructor(schemaOptions: Migrations.SchemaOptions, config: ParseServerOptions) {\n    this.localSchemas = [];\n    this.config = Config.get(config.appId);\n    this.schemaOptions = schemaOptions;\n    if (schemaOptions && schemaOptions.definitions) {\n      if (!Array.isArray(schemaOptions.definitions)) {\n        throw `\"schema.definitions\" must be an array of schemas`;\n      }\n\n      this.localSchemas = schemaOptions.definitions;\n    }\n\n    this.retries = 0;\n    this.maxRetries = 3;\n  }\n\n  async saveSchemaToDB(schema: Parse.Schema): Promise<void> {\n    const payload = {\n      className: schema.className,\n      fields: schema._fields,\n      indexes: schema._indexes,\n      classLevelPermissions: schema._clp,\n    };\n    await internalCreateSchema(schema.className, payload, this.config);\n    this.resetSchemaOps(schema);\n  }\n\n  resetSchemaOps(schema: Parse.Schema) {\n    // Reset ops like SDK\n    schema._fields = {};\n    schema._indexes = {};\n  }\n\n  // Simulate update like the SDK\n  // We cannot use SDK since routes are disabled\n  async updateSchemaToDB(schema: Parse.Schema) {\n    const payload = {\n      className: schema.className,\n      fields: schema._fields,\n      indexes: schema._indexes,\n      classLevelPermissions: schema._clp,\n    };\n    await internalUpdateSchema(schema.className, payload, this.config);\n    this.resetSchemaOps(schema);\n  }\n\n  async execute() {\n    try {\n      logger.info('Running Migrations');\n      if (this.schemaOptions && this.schemaOptions.beforeMigration) {\n        await Promise.resolve(this.schemaOptions.beforeMigration());\n      }\n\n      await this.executeMigrations();\n\n      if (this.schemaOptions && this.schemaOptions.afterMigration) {\n        await Promise.resolve(this.schemaOptions.afterMigration());\n      }\n\n      logger.info('Running Migrations Completed');\n    } catch (e) {\n      logger.error(`Failed to run migrations: ${e}`);\n      if (process.env.NODE_ENV === 'production') process.exit(1);\n    }\n  }\n\n  async executeMigrations() {\n    let timeout = null;\n    try {\n      // Set up a time out in production\n      // if we fail to get schema\n      // pm2 or K8s and many other process managers will try to restart the process\n      // after the exit\n      if (process.env.NODE_ENV === 'production') {\n        timeout = setTimeout(() => {\n          logger.error('Timeout occurred during execution of migrations. Exiting...');\n          process.exit(1);\n        }, 20000);\n      }\n\n      // Hack to force session schema to be created\n      await this.createDeleteSession();\n      this.allCloudSchemas = await Parse.Schema.all();\n      clearTimeout(timeout);\n      await Promise.all(this.localSchemas.map(async localSchema => this.saveOrUpdate(localSchema)));\n\n      this.checkForMissingSchemas();\n      await this.enforceCLPForNonProvidedClass();\n    } catch (e) {\n      if (timeout) clearTimeout(timeout);\n      if (this.retries < this.maxRetries) {\n        this.retries++;\n        // first retry 1sec, 2sec, 3sec total 6sec retry sequence\n        // retry will only happen in case of deploying multi parse server instance\n        // at the same time. Modern systems like k8 avoid this by doing rolling updates\n        await this.wait(1000 * this.retries);\n        await this.executeMigrations();\n      } else {\n        logger.error(`Failed to run migrations: ${e}`);\n        if (process.env.NODE_ENV === 'production') process.exit(1);\n      }\n    }\n  }\n\n  checkForMissingSchemas() {\n    if (this.schemaOptions.strict !== true) {\n      return;\n    }\n\n    const cloudSchemas = this.allCloudSchemas.map(s => s.className);\n    const localSchemas = this.localSchemas.map(s => s.className);\n    const missingSchemas = cloudSchemas.filter(\n      c => !localSchemas.includes(c) && !systemClasses.includes(c)\n    );\n\n    if (new Set(localSchemas).size !== localSchemas.length) {\n      logger.error(\n        `The list of schemas provided contains duplicated \"className\"  \"${localSchemas.join(\n          '\",\"'\n        )}\"`\n      );\n      process.exit(1);\n    }\n\n    if (this.schemaOptions.strict && missingSchemas.length) {\n      logger.warn(\n        `The following schemas are currently present in the database, but not explicitly defined in a schema: \"${missingSchemas.join(\n          '\", \"'\n        )}\"`\n      );\n    }\n  }\n\n  // Required for testing purpose\n  wait(time: number) {\n    return new Promise<void>(resolve => setTimeout(resolve, time));\n  }\n\n  async enforceCLPForNonProvidedClass(): Promise<void> {\n    const nonProvidedClasses = this.allCloudSchemas.filter(\n      cloudSchema =>\n        !this.localSchemas.some(localSchema => localSchema.className === cloudSchema.className)\n    );\n    await Promise.all(\n      nonProvidedClasses.map(async schema => {\n        const parseSchema = new Parse.Schema(schema.className);\n        this.handleCLP(schema, parseSchema);\n        await this.updateSchemaToDB(parseSchema);\n      })\n    );\n  }\n\n  // Create a fake session since Parse do not create the _Session until\n  // a session is created\n  async createDeleteSession() {\n    const session = new Parse.Session();\n    await session.save(null, { useMasterKey: true });\n    await session.destroy({ useMasterKey: true });\n  }\n\n  async saveOrUpdate(localSchema: Migrations.JSONSchema) {\n    const cloudSchema = this.allCloudSchemas.find(sc => sc.className === localSchema.className);\n    if (cloudSchema) {\n      try {\n        await this.updateSchema(localSchema, cloudSchema);\n      } catch (e) {\n        throw `Error during update of schema for type ${cloudSchema.className}: ${e}`;\n      }\n    } else {\n      try {\n        await this.saveSchema(localSchema);\n      } catch (e) {\n        throw `Error while saving Schema for type ${localSchema.className}: ${e}`;\n      }\n    }\n  }\n\n  async saveSchema(localSchema: Migrations.JSONSchema) {\n    const newLocalSchema = new Parse.Schema(localSchema.className);\n    if (localSchema.fields) {\n      // Handle fields\n      Object.keys(localSchema.fields)\n        .filter(fieldName => !this.isProtectedFields(localSchema.className, fieldName))\n        .forEach(fieldName => {\n          if (localSchema.fields) {\n            const field = localSchema.fields[fieldName];\n            this.handleFields(newLocalSchema, fieldName, field);\n          }\n        });\n    }\n    // Handle indexes\n    if (localSchema.indexes) {\n      Object.keys(localSchema.indexes).forEach(indexName => {\n        if (localSchema.indexes && !this.isProtectedIndex(localSchema.className, indexName)) {\n          newLocalSchema.addIndex(indexName, localSchema.indexes[indexName]);\n        }\n      });\n    }\n\n    this.handleCLP(localSchema, newLocalSchema);\n\n    return await this.saveSchemaToDB(newLocalSchema);\n  }\n\n  async updateSchema(localSchema: Migrations.JSONSchema, cloudSchema: Parse.Schema) {\n    const newLocalSchema = new Parse.Schema(localSchema.className);\n\n    // Handle fields\n    // Check addition\n    if (localSchema.fields) {\n      Object.keys(localSchema.fields)\n        .filter(fieldName => !this.isProtectedFields(localSchema.className, fieldName))\n        .forEach(fieldName => {\n          // @flow-disable-next\n          const field = localSchema.fields[fieldName];\n          if (!cloudSchema.fields[fieldName]) {\n            this.handleFields(newLocalSchema, fieldName, field);\n          }\n        });\n    }\n\n    const fieldsToDelete: string[] = [];\n    const fieldsToRecreate: {\n      fieldName: string,\n      from: { type: string, targetClass?: string },\n      to: { type: string, targetClass?: string },\n    }[] = [];\n    const fieldsWithChangedParams: string[] = [];\n\n    // Check deletion\n    Object.keys(cloudSchema.fields)\n      .filter(fieldName => !this.isProtectedFields(localSchema.className, fieldName))\n      .forEach(fieldName => {\n        const field = cloudSchema.fields[fieldName];\n        if (!localSchema.fields || !localSchema.fields[fieldName]) {\n          fieldsToDelete.push(fieldName);\n          return;\n        }\n\n        const localField = localSchema.fields[fieldName];\n        // Check if field has a changed type\n        if (\n          !this.paramsAreEquals(\n            { type: field.type, targetClass: field.targetClass },\n            { type: localField.type, targetClass: localField.targetClass }\n          )\n        ) {\n          fieldsToRecreate.push({\n            fieldName,\n            from: { type: field.type, targetClass: field.targetClass },\n            to: { type: localField.type, targetClass: localField.targetClass },\n          });\n          return;\n        }\n\n        // Check if something changed other than the type (like required, defaultValue)\n        if (!this.paramsAreEquals(field, localField)) {\n          fieldsWithChangedParams.push(fieldName);\n        }\n      });\n\n    if (this.schemaOptions.deleteExtraFields === true) {\n      fieldsToDelete.forEach(fieldName => {\n        newLocalSchema.deleteField(fieldName);\n      });\n\n      // Delete fields from the schema then apply changes\n      await this.updateSchemaToDB(newLocalSchema);\n    } else if (this.schemaOptions.strict === true && fieldsToDelete.length) {\n      logger.warn(\n        `The following fields exist in the database for \"${\n          localSchema.className\n        }\", but are missing in the schema : \"${fieldsToDelete.join('\" ,\"')}\"`\n      );\n    }\n\n    if (this.schemaOptions.recreateModifiedFields === true) {\n      fieldsToRecreate.forEach(field => {\n        newLocalSchema.deleteField(field.fieldName);\n      });\n\n      // Delete fields from the schema then apply changes\n      await this.updateSchemaToDB(newLocalSchema);\n\n      fieldsToRecreate.forEach(fieldInfo => {\n        if (localSchema.fields) {\n          const field = localSchema.fields[fieldInfo.fieldName];\n          this.handleFields(newLocalSchema, fieldInfo.fieldName, field);\n        }\n      });\n    } else if (this.schemaOptions.strict === true && fieldsToRecreate.length) {\n      fieldsToRecreate.forEach(field => {\n        const from =\n          field.from.type + (field.from.targetClass ? ` (${field.from.targetClass})` : '');\n        const to = field.to.type + (field.to.targetClass ? ` (${field.to.targetClass})` : '');\n\n        logger.warn(\n          `The field \"${field.fieldName}\" type differ between the schema and the database for \"${localSchema.className}\"; Schema is defined as \"${to}\" and current database type is \"${from}\"`\n        );\n      });\n    }\n\n    fieldsWithChangedParams.forEach(fieldName => {\n      if (localSchema.fields) {\n        const field = localSchema.fields[fieldName];\n        this.handleFields(newLocalSchema, fieldName, field);\n      }\n    });\n\n    // Handle Indexes\n    // Check addition\n    if (localSchema.indexes) {\n      Object.keys(localSchema.indexes).forEach(indexName => {\n        if (\n          (!cloudSchema.indexes || !cloudSchema.indexes[indexName]) &&\n          !this.isProtectedIndex(localSchema.className, indexName)\n        ) {\n          if (localSchema.indexes) {\n            newLocalSchema.addIndex(indexName, localSchema.indexes[indexName]);\n          }\n        }\n      });\n    }\n\n    const indexesToAdd = [];\n\n    // Check deletion\n    if (cloudSchema.indexes) {\n      Object.keys(cloudSchema.indexes).forEach(indexName => {\n        if (!this.isProtectedIndex(localSchema.className, indexName)) {\n          if (!localSchema.indexes || !localSchema.indexes[indexName]) {\n            newLocalSchema.deleteIndex(indexName);\n          } else if (\n            !this.paramsAreEquals(localSchema.indexes[indexName], cloudSchema.indexes[indexName])\n          ) {\n            newLocalSchema.deleteIndex(indexName);\n            if (localSchema.indexes) {\n              indexesToAdd.push({\n                indexName,\n                index: localSchema.indexes[indexName],\n              });\n            }\n          }\n        }\n      });\n    }\n\n    this.handleCLP(localSchema, newLocalSchema, cloudSchema);\n    // Apply changes\n    await this.updateSchemaToDB(newLocalSchema);\n    // Apply new/changed indexes\n    if (indexesToAdd.length) {\n      logger.debug(\n        `Updating indexes for \"${newLocalSchema.className}\" :  ${indexesToAdd.join(' ,')}`\n      );\n      indexesToAdd.forEach(o => newLocalSchema.addIndex(o.indexName, o.index));\n      await this.updateSchemaToDB(newLocalSchema);\n    }\n  }\n\n  handleCLP(\n    localSchema: Migrations.JSONSchema,\n    newLocalSchema: Parse.Schema,\n    cloudSchema: Parse.Schema\n  ) {\n    if (!localSchema.classLevelPermissions && !cloudSchema) {\n      logger.warn(`classLevelPermissions not provided for ${localSchema.className}.`);\n    }\n    // Use spread to avoid read only issue (encountered by Moumouls using directAccess)\n    const clp = ({ ...localSchema.classLevelPermissions } || {}: Parse.CLP.PermissionsMap);\n    // To avoid inconsistency we need to remove all rights on addField\n    clp.addField = {};\n    newLocalSchema.setCLP(clp);\n  }\n\n  isProtectedFields(className: string, fieldName: string) {\n    return (\n      !!defaultColumns._Default[fieldName] ||\n      !!(defaultColumns[className] && defaultColumns[className][fieldName])\n    );\n  }\n\n  isProtectedIndex(className: string, indexName: string) {\n    let indexes = ['_id_'];\n    if (className === '_User') {\n      indexes = [\n        ...indexes,\n        'case_insensitive_username',\n        'case_insensitive_email',\n        'username_1',\n        'email_1',\n      ];\n    }\n\n    return indexes.indexOf(indexName) !== -1;\n  }\n\n  paramsAreEquals<T: { [key: string]: any }>(objA: T, objB: T) {\n    const keysA: string[] = Object.keys(objA);\n    const keysB: string[] = Object.keys(objB);\n\n    // Check key name\n    if (keysA.length !== keysB.length) return false;\n    return keysA.every(k => objA[k] === objB[k]);\n  }\n\n  handleFields(newLocalSchema: Parse.Schema, fieldName: string, field: Migrations.FieldType) {\n    if (field.type === 'Relation') {\n      newLocalSchema.addRelation(fieldName, field.targetClass);\n    } else if (field.type === 'Pointer') {\n      newLocalSchema.addPointer(fieldName, field.targetClass, field);\n    } else {\n      newLocalSchema.addField(fieldName, field.type, field);\n    }\n  }\n}\n"]}