parse-server 4.10.4 → 5.0.0-alpha.12

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"]}

package/lib/SchemaMigrations/Migrations.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeSchema = makeSchema;
+exports.CLP = void 0;
+
+// @Typescript 4.1+ // type CLPPermission = 'requiresAuthentication' | '*' |  `user:${string}` | `role:${string}`
+class CLP {
+  static allow(perms) {
+    const out = {};
+
+    for (const [perm, ops] of Object.entries(perms)) {
+      // -disable-next Property `@@iterator` is missing in mixed [1] but exists in `$Iterable` [2].
+      for (const op of ops) {
+        out[op] = out[op] || {};
+        out[op][perm] = true;
+      }
+    }
+
+    return out;
+  }
+
+}
+
+exports.CLP = CLP;
+
+function makeSchema(className, schema) {
+  // This function solve two things:
+  // 1. It provides auto-completion to the users who are implementing schemas
+  // 2. It allows forward-compatible point in order to allow future changes to the internal structure of JSONSchema without affecting all the users
+  schema.className = className;
+  return schema;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Security/Check.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+var _lodash = require("lodash");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @module SecurityCheck
+ */
+
+/**
+ * A security check.
+ * @class Check
+ */
+class Check {
+  /**
+   * Constructs a new security check.
+   * @param {Object} params The parameters.
+   * @param {String} params.title The title.
+   * @param {String} params.warning The warning message if the check fails.
+   * @param {String} params.solution The solution to fix the check.
+   * @param {Promise} params.check The check as synchronous or asynchronous function.
+   */
+  constructor(params) {
+    this._validateParams(params);
+
+    const {
+      title,
+      warning,
+      solution,
+      check
+    } = params;
+    this.title = title;
+    this.warning = warning;
+    this.solution = solution;
+    this.check = check; // Set default properties
+
+    this._checkState = CheckState.none;
+    this.error;
+  }
+  /**
+   * Returns the current check state.
+   * @return {CheckState} The check state.
+   */
+
+
+  checkState() {
+    return this._checkState;
+  }
+
+  async run() {
+    // Get check as synchronous or asynchronous function
+    const check = this.check instanceof Promise ? await this.check : this.check; // Run check
+
+    try {
+      check();
+      this._checkState = CheckState.success;
+    } catch (e) {
+      this.stateFailError = e;
+      this._checkState = CheckState.fail;
+    }
+  }
+  /**
+   * Validates the constructor parameters.
+   * @param {Object} params The parameters to validate.
+   */
+
+
+  _validateParams(params) {
+    _Utils.default.validateParams(params, {
+      group: {
+        t: 'string',
+        v: _lodash.isString
+      },
+      title: {
+        t: 'string',
+        v: _lodash.isString
+      },
+      warning: {
+        t: 'string',
+        v: _lodash.isString
+      },
+      solution: {
+        t: 'string',
+        v: _lodash.isString
+      },
+      check: {
+        t: 'function',
+        v: _lodash.isFunction
+      }
+    });
+  }
+
+}
+/**
+ * The check state.
+ */
+
+
+const CheckState = Object.freeze({
+  none: 'none',
+  fail: 'fail',
+  success: 'success'
+});
+var _default = Check;
+exports.default = _default;
+module.exports = {
+  Check,
+  CheckState
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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