Adds flow types to SchemaCOntroller,

- runs flow on pre tests
- fixes flow

Author: flovilmart

package.json

@@ -67,7 +67,7 @@
   },
   "scripts": {
     "dev": "npm run build && node bin/dev",
-    "lint": "eslint --cache ./",
+    "lint": "flow && eslint --cache ./",
     "build": "babel src/ -d lib/ --copy-files",
     "pretest": "npm run lint",
     "test": "cross-env MONGODB_VERSION=${MONGODB_VERSION:=3.2.6} MONGODB_STORAGE_ENGINE=mmapv1 TESTING=1 $COVERAGE_OPTION jasmine",

src/Adapters/Files/GridStoreAdapter.js

@@ -6,6 +6,7 @@
  @flow weak
  */
 
+// @flow-disable-next
 import { MongoClient, GridStore, Db} from 'mongodb';
 import { FilesAdapter }              from './FilesAdapter';
 import defaults                      from '../../defaults';

src/Adapters/Storage/Postgres/PostgresStorageAdapter.js

@@ -620,8 +620,8 @@ export class PostgresStorageAdapter implements StorageAdapter {
     });
   }
 
-  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any, conn: any): Promise<void> {
-    conn = conn || this._client;
+  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any, client: ?any): Promise<void> {
+    const conn = client || this._client;
     if (submittedIndexes === undefined) {
       return Promise.resolve();
     }

src/Adapters/Storage/StorageAdapter.js

@@ -34,7 +34,7 @@ export interface StorageAdapter {
 
   // Indexing
   createIndexes(className: string, indexes: any, conn: ?any): Promise<void>;
-  createIndexesIfNeeded(className: string, fieldName: string, type: any, conn: ?any): Promise<void>;
   getIndexes(className: string, connection: ?any): Promise<void>;
   updateSchemaWithIndexes(): Promise<void>;
+  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any, fields: any, conn: ?any): Promise<void>;
 }

src/Controllers/DatabaseController.js

@@ -11,7 +11,7 @@ import intersect              from 'intersect';
 // @flow-disable-next
 import deepcopy               from 'deepcopy';
 import logger                 from '../logger';
-import * as SchemaController  from './SchemaController';
+import * as SchemaController       from './SchemaController';
 import { StorageAdapter }     from '../Adapters/Storage/StorageAdapter';
 function addWriteACL(query, acl) {
   const newQuery = _.cloneDeep(query);
@@ -152,6 +152,14 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => {
   return object;
 };
 
+type Options = {
+  acl?: string[]
+}
+
+type LoadSchemaOptions = {
+  clearCache: boolean
+}
+
 // Runs an update on the database.
 // Returns a promise for an object with the new values for field
 // modifications that don't know their results ahead of time, like
@@ -285,7 +293,7 @@ const relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { ty
 class DatabaseController {
   adapter: StorageAdapter;
   schemaCache: any;
-  schemaPromise: ?Promise<any>;
+  schemaPromise: ?Promise<SchemaController.SchemaController>;
 
   constructor(adapter: StorageAdapter, schemaCache: any) {
     this.adapter = adapter;
@@ -314,7 +322,7 @@ class DatabaseController {
   }
 
   // Returns a promise for a schemaController.
-  loadSchema(options : any = {clearCache: false}): Promise<any> {
+  loadSchema(options: LoadSchemaOptions = {clearCache: false}): Promise<SchemaController.SchemaController> {
     if (this.schemaPromise != null) {
       return this.schemaPromise;
     }
@@ -327,25 +335,24 @@ class DatabaseController {
   // Returns a promise for the classname that is related to the given
   // classname through the key.
   // TODO: make this not in the DatabaseController interface
-  redirectClassNameForKey(className: string, key: string): Promise<string> {
+  redirectClassNameForKey(className: string, key: string): Promise<?string> {
     return this.loadSchema().then((schema) => {
-      var t = schema.getExpectedType(className, key);
-      if (t && t.type == 'Relation') {
+      var t  = schema.getExpectedType(className, key);
+      if (t != null && typeof t !== 'string' && t.type === 'Relation') {
         return t.targetClass;
-      } else {
-        return className;
       }
+      return className;
     });
   }
 
   // Uses the schema to validate the object (REST API format).
   // Returns a promise that resolves to the new schema.
   // This does not update this.schema, because in a situation like a
   // batch request, that could confuse other users of the schema.
-  validateObject(className: string, object: any, query: any, { acl }: any): Promise<boolean> {
+  validateObject(className: string, object: any, query: any, { acl }: Options): Promise<boolean> {
     let schema;
     const isMaster = acl === undefined;
-    var aclGroup = acl || [];
+    var aclGroup: string[]  = acl || [];
     return this.loadSchema().then(s => {
       schema = s;
       if (isMaster) {
@@ -537,7 +544,7 @@ class DatabaseController {
   //   acl:  a list of strings. If the object to be updated has an ACL,
   //         one of the provided strings must provide the caller with
   //         write permissions.
-  destroy(className: string, query: any, { acl }: any = {}): Promise<any> {
+  destroy(className: string, query: any, { acl }: Options = {}): Promise<any> {
     const isMaster = acl === undefined;
     const aclGroup = acl || [];
 
@@ -579,7 +586,7 @@ class DatabaseController {
 
   // Inserts an object into the database.
   // Returns a promise that resolves successfully iff the object saved.
-  create(className: string, object: any, { acl }: any = {}): Promise<any> {
+  create(className: string, object: any, { acl }: Options = {}): Promise<any> {
   // Make a copy of the object, so we don't mutate the incoming data.
     const originalObject = object;
     object = transformObjectACL(object);
@@ -610,7 +617,7 @@ class DatabaseController {
       })
   }
 
-  canAddField(schema: any, className: string, object: any, aclGroup: string[]): Promise<void> {
+  canAddField(schema: SchemaController.SchemaController, className: string, object: any, aclGroup: string[]): Promise<void> {
     const classSchema = schema.data[className];
     if (!classSchema) {
       return Promise.resolve();
@@ -843,7 +850,7 @@ class DatabaseController {
     distinct,
     pipeline,
     readPreference
-  }: any = {}): Promise<[any]> {
+  }: any = {}): Promise<any> {
     const isMaster = acl === undefined;
     const aclGroup = acl || [];
     op = op || (typeof query.objectId == 'string' && Object.keys(query).length === 1 ? 'get' : 'find');
@@ -938,7 +945,7 @@ class DatabaseController {
   }
 
   deleteSchema(className: string): Promise<void> {
-    return this.loadSchema(true)
+    return this.loadSchema({ clearCache: true })
       .then(schemaController => schemaController.getOneSchema(className, true))
       .catch(error => {
         if (error === undefined) {

src/Controllers/HooksController.js

@@ -1,7 +1,9 @@
 /** @flow weak */
 
 import * as triggers        from "../triggers";
+// @flow-disable-next
 import * as Parse           from "parse/node";
+// @flow-disable-next
 import * as request         from "request";
 import { logger }           from '../logger';
 
@@ -28,15 +30,15 @@ export class HooksController {
   }
 
   getFunction(functionName) {
-    return this._getHooks({ functionName: functionName }, 1).then(results => results[0]);
+    return this._getHooks({ functionName: functionName }).then(results => results[0]);
   }
 
   getFunctions() {
     return this._getHooks({ functionName: { $exists: true } });
   }
 
   getTrigger(className, triggerName) {
-    return this._getHooks({ className: className, triggerName: triggerName }, 1).then(results => results[0]);
+    return this._getHooks({ className: className, triggerName: triggerName }).then(results => results[0]);
   }
 
   getTriggers() {