Added validations,

Author: sadortun

src/LiveQuery/ParseLiveQueryServer.js

@@ -851,9 +851,8 @@ class ParseLiveQueryServer {
       const parseQuery = new Parse.Query(className);
       parseQuery.withJSON(request.query);
       request.query = subscription.query;
-      request.requestId = request.requestId;
-      request.sessionToken =  subscriptionInfo.sessionToken;
-      request.useMasterKey =  client.hasMasterKey;
+      request.sessionToken = subscriptionInfo.sessionToken;
+      request.useMasterKey = client.hasMasterKey;
       request.installationId = client.installationId;
 
       await runTrigger(trigger, `beforeUnsubscribe.${className}`, request, auth);

src/Options/index.js

@@ -8,6 +8,7 @@ import { MailAdapter } from '../Adapters/Email/MailAdapter';
 import { PubSubAdapter } from '../Adapters/PubSub/PubSubAdapter';
 import { WSSAdapter } from '../Adapters/WebSocketServer/WSSAdapter';
 import { CheckGroup } from '../Security/CheckGroup';
+import type { MigrationsOptions } from '../SchemaMigrations/Migrations';
 
 type Adapter<T> = string | any | T;
 type NumberOrBoolean = number | boolean;
@@ -244,7 +245,7 @@ export interface ParseServerOptions {
   /* Callback when server has started and before running schemas migration operations if schemas key provided */
   beforeSchemasMigration: ?() => void | Promise<void>;
   /* Rest representation on Parse.Schema https://docs.parseplatform.org/rest/guide/#adding-a-schema */
-  schemas: ?(JSONSchema[]);
+  migrations: ?MigrationsOptions;
   /* Callback when server has closed */
   serverCloseComplete: ?() => void;
   /* The security options to identify and report weak security settings.

src/ParseServer.js

@@ -44,7 +44,7 @@ import { ParseGraphQLServer } from './GraphQL/ParseGraphQLServer';
 import { SecurityRouter } from './Routers/SecurityRouter';
 import CheckRunner from './Security/CheckRunner';
 import Deprecator from './Deprecator/Deprecator';
-import { DefinedSchemas } from './DefinedSchemas';
+import { DefinedSchemas } from './SchemaMigrations/DefinedSchemas';
 
 // Mutate the Parse object to add the Cloud Code handlers
 addParseCloud();
@@ -70,7 +70,7 @@ class ParseServer {
       serverURL = requiredParameter('You must provide a serverURL!'),
       serverStartComplete,
       beforeSchemasMigration,
-      schemas,
+      migrations,
     } = options;
     // Initialize the node client SDK automatically
     Parse.initialize(appId, javascriptKey || 'unused', masterKey);
@@ -91,8 +91,8 @@ class ParseServer {
         if (beforeSchemasMigration) {
           await Promise.resolve(beforeSchemasMigration());
         }
-        if (schemas) {
-          await new DefinedSchemas(schemas, this.config).execute();
+        if (migrations) {
+          await new DefinedSchemas(migrations, this.config).execute();
         }
         if (serverStartComplete) {
           serverStartComplete();

src/SchemaMigrations/DefinedSchemas.js

@@ -1,15 +1,29 @@
-import Parse from 'parse/node';
+// @flow
+// import Parse from 'parse/node';
+const Parse = require('parse/node');
 import { logger } from '../logger';
 import Config from '../Config';
 import { internalCreateSchema, internalUpdateSchema } from '../Routers/SchemasRouter';
-import { defaultColumns } from '../Controllers/SchemaController';
+import { defaultColumns, systemClasses } from '../Controllers/SchemaController';
 import { ParseServerOptions } from '../Options';
 import * as Migrations from './Migrations';
 
 export class DefinedSchemas {
-  constructor(localSchemas: Migrations.JSONSchema[], config: ParseServerOptions) {
+  config: ParseServerOptions;
+  migrationOptions: Migrations.MigrationsOptions;
+  localSchemas: Migrations.JSONSchema[];
+  retries: number;
+  maxRetries: number;
+
+  constructor(migrationsOptions: Migrations.MigrationsOptions[], config: ParseServerOptions) {
+    this.localSchemas = [];
     this.config = Config.get(config.appId);
-    this.localSchemas = localSchemas;
+    this.migrationsOptions = migrationsOptions;
+
+    if (migrationsOptions && migrationsOptions.schemas) {
+      this.localSchemas = migrationsOptions.schemas;
+    }
+
     this.retries = 0;
     this.maxRetries = 3;
   }
@@ -65,6 +79,8 @@ export class DefinedSchemas {
       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);
@@ -83,6 +99,26 @@ export class DefinedSchemas {
     }
   }
 
+  checkForMissingSchemas() {
+    if (this.migrationsOptions.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) && !systemClasses.includes(c)
+    );
+
+    if (missingSchemas.length) {
+      logger.warn(
+        `The following schemas are currently present in the database, but not explicitly defined in a schema: "${missingSchemas.join(
+          '", "'
+        )}"`
+      );
+    }
+  }
+
   // Required for testing purpose
   async wait(time) {
     await new Promise(resolve => setTimeout(resolve, time));
@@ -169,7 +205,11 @@ export class DefinedSchemas {
     }
 
     const fieldsToDelete: string[] = [];
-    const fieldsToRecreate: string[] = [];
+    const fieldsToRecreate: {
+      fieldName: string,
+      from: { type: string, targetClass: string },
+      to: { type: string, targetClass: string },
+    }[] = [];
     const fieldsWithChangedParams: string[] = [];
 
     // Check deletion
@@ -190,8 +230,11 @@ export class DefinedSchemas {
             { type: localField.type, targetClass: localField.targetClass }
           )
         ) {
-          fieldsToRecreate.push(fieldName);
-          fieldsToDelete.push(fieldName);
+          fieldsToRecreate.push({
+            fieldName,
+            from: { type: field.type, targetClass: field.targetClass },
+            to: { type: localField.type, targetClass: localField.targetClass },
+          });
           return;
         }
 
@@ -201,17 +244,45 @@ export class DefinedSchemas {
         }
       });
 
-    fieldsToDelete.forEach(fieldName => {
-      newLocalSchema.deleteField(fieldName);
-    });
+    if (this.migrationsOptions.deleteExtraFields === true) {
+      fieldsToDelete.forEach(fieldName => {
+        newLocalSchema.deleteField(fieldName);
+      });
 
-    // Delete fields from the schema then apply changes
-    await this.updateSchemaToDB(newLocalSchema);
+      // Delete fields from the schema then apply changes
+      await this.updateSchemaToDB(newLocalSchema);
+    } else if (this.migrationsOptions.strict === true && fieldsToDelete.length) {
+      logger.warn(
+        `The following fields exist in the database for "${
+          localSchema.className
+        }", but are missing in the schema : "${fieldsToDelete.join('" ,"')}"`
+      );
+    }
+
+    if (this.migrationsOptions.recreateModifiedFields === true) {
+      fieldsToRecreate.forEach(fieldName => {
+        newLocalSchema.deleteField(fieldName);
+      });
+
+      // Delete fields from the schema then apply changes
+      await this.updateSchemaToDB(newLocalSchema);
+
+      fieldsToRecreate.forEach(fieldName => {
+        const field = localSchema.fields[fieldName];
+        this.handleFields(newLocalSchema, fieldName, field);
+      });
+    } else if (this.migrationsOptions.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.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}"`
+        );
+      });
+    }
 
-    fieldsToRecreate.forEach(fieldName => {
-      const field = localSchema.fields[fieldName];
-      this.handleFields(newLocalSchema, fieldName, field);
-    });
     fieldsWithChangedParams.forEach(fieldName => {
       const field = localSchema.fields[fieldName];
       this.handleFields(newLocalSchema, fieldName, field);

src/SchemaMigrations/Migrations.js

@@ -42,6 +42,13 @@ export interface IndexesInterface {
   [key: string]: IndexInterface;
 }
 
+export interface MigrationsOptions {
+  schemas: JSONSchema[];
+  strict: ?boolean;
+  deleteExtraFields: ?boolean;
+  recreateModifiedFields: ?boolean;
+}
+
 export interface JSONSchema {
   className: ClassNameType;
   fields?: { [key: string]: FieldType };
@@ -74,26 +81,21 @@ function CLP(ops: CLPType, value: CLPInterface): CLPInterface {
 
 export class CLPHelper {
   static requiresAuthentication(ops: CLPType): CLPInterface {
-    return CLPHelper(ops, { requiresAuthentication: true });
+    return CLP(ops, { requiresAuthentication: true });
   }
 
   static requiresAnonymous(ops: CLPType): CLPInterface {
-    return CLPHelper(ops, { '*': true });
+    return CLP(ops, { '*': true });
   }
 }
 
 export function makeSchema(className: ClassNameType, schema: JSONSchema): JSONSchema {
   return {
     className,
     fields: {
-      objectId: { type: 'String' },
-      createdAt: { type: 'Date' },
-      updatedAt: { type: 'Date' },
-      ACL: { type: 'ACL' },
       ...schema.fields,
     },
     indexes: {
-      objectId: { objectId: 1 },
       ...schema.indexes,
     },
     classLevelPermissions: {

src/cloud-code/Parse.Cloud.js

@@ -677,8 +677,6 @@ ParseCloud.onLiveQueryEvent = function (handler) {
   triggers.addLiveQueryEventHandler(handler, Parse.applicationId);
 };
 
-
-
 /**
  * Registers a before live query subscription function.
  *
@@ -719,8 +717,6 @@ ParseCloud.onLiveQueryEvent = function (handler) {
   triggers.addLiveQueryEventHandler(handler, Parse.applicationId);
 };
 
-
-
 /**
  * Registers an after live query server event function.
  *