Introduces flow types for storage

Author: flovilmart

.flowconfig

@@ -7,3 +7,4 @@
 [libs]
 
 [options]
+suppress_comment= \\(.\\|\n\\)*\\@flow-disable-next

package.json

@@ -59,6 +59,7 @@
     "deep-diff": "0.3.8",
     "eslint": "^4.9.0",
     "eslint-plugin-flowtype": "^2.39.1",
+    "flow-bin": "^0.59.0",
     "gaze": "1.1.2",
     "jasmine": "2.8.0",
     "jasmine-spec-reporter": "^4.1.0",

spec/MongoStorageAdapter.spec.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter');
+const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter').MongoStorageAdapter;
 const MongoClient = require('mongodb').MongoClient;
 const databaseURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase';
 

spec/ParsePolygon.spec.js

@@ -1,5 +1,5 @@
 const TestObject = Parse.Object.extend('TestObject');
-const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter');
+const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter').MongoStorageAdapter;
 const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase';
 const rp = require('request-promise');
 const defaultHeaders = {

spec/ParseQuery.FullTextSearch.spec.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter');
+const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter').MongoStorageAdapter;
 const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase';
-const PostgresStorageAdapter = require('../src/Adapters/Storage/Postgres/PostgresStorageAdapter');
+const PostgresStorageAdapter = require('../src/Adapters/Storage/Postgres/PostgresStorageAdapter').PostgresStorageAdapter;
 const postgresURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database';
 const Parse = require('parse/node');
 const rp = require('request-promise');

spec/PostgresInitOptions.spec.js

@@ -1,5 +1,5 @@
 const Parse = require('parse/node').Parse;
-const PostgresStorageAdapter = require('../src/Adapters/Storage/Postgres/PostgresStorageAdapter');
+const PostgresStorageAdapter = require('../src/Adapters/Storage/Postgres/PostgresStorageAdapter').PostgresStorageAdapter;
 const postgresURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database';
 const ParseServer = require("../src/index");
 const express = require('express');

spec/helper.js

@@ -27,10 +27,10 @@ var cache = require('../src/cache').default;
 var ParseServer = require('../src/index').ParseServer;
 var path = require('path');
 var TestUtils = require('../src/TestUtils');
-var MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter');
+var MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter').MongoStorageAdapter;
 const GridStoreAdapter = require('../src/Adapters/Files/GridStoreAdapter').GridStoreAdapter;
 const FSAdapter = require('parse-server-fs-adapter');
-const PostgresStorageAdapter = require('../src/Adapters/Storage/Postgres/PostgresStorageAdapter');
+const PostgresStorageAdapter = require('../src/Adapters/Storage/Postgres/PostgresStorageAdapter').PostgresStorageAdapter;
 const RedisCacheAdapter = require('../src/Adapters/Cache/RedisCacheAdapter').default;
 
 const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase';

spec/index.spec.js

@@ -6,7 +6,7 @@ var ParseServer = require("../src/index");
 var Config = require('../src/Config');
 var express = require('express');
 
-const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter');
+const MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAdapter').MongoStorageAdapter;
 
 describe('server', () => {
   it('requires a master key and app id', done => {

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -1,5 +1,10 @@
+// @flow
 import MongoCollection       from './MongoCollection';
 import MongoSchemaCollection from './MongoSchemaCollection';
+import { StorageAdapter, IndexingStorageAdapter }    from '../StorageAdapter';
+import type { SchemaType,
+  QueryType,
+  QueryOptionsType } from '../StorageAdapter';
 import {
   parse as parseUrl,
   format as formatUrl,
@@ -11,10 +16,13 @@ import {
   transformWhere,
   transformUpdate,
 } from './MongoTransform';
+// $FlowFixMe
 import Parse                 from 'parse/node';
+// $FlowFixMe
 import _                     from 'lodash';
 import defaults              from '../../../defaults';
 
+// $FlowFixMe
 const mongodb = require('mongodb');
 const MongoClient = mongodb.MongoClient;
 const ReadPreference = mongodb.ReadPreference;
@@ -58,7 +66,8 @@ const mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPe
     _id: className,
     objectId: 'string',
     updatedAt: 'string',
-    createdAt: 'string'
+    createdAt: 'string',
+    _metadata: undefined,
   };
 
   for (const fieldName in fields) {
@@ -78,20 +87,22 @@ const mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPe
 }
 
 
-export class MongoStorageAdapter {
+export class MongoStorageAdapter implements StorageAdapter, IndexingStorageAdapter {
   // Private
   _uri: string;
   _collectionPrefix: string;
   _mongoOptions: Object;
   // Public
   connectionPromise;
-  database;
-  canSortOnJoinTables;
+  database: any;
+  _maxTimeMS: ?number;
+  canSortOnJoinTables: boolean;
+
   constructor({
     uri = defaults.DefaultMongoURI,
     collectionPrefix = '',
     mongoOptions = {},
-  }) {
+  }: any) {
     this._uri = uri;
     this._collectionPrefix = collectionPrefix;
     this._mongoOptions = mongoOptions;
@@ -150,22 +161,22 @@ export class MongoStorageAdapter {
       .then(collection => new MongoSchemaCollection(collection));
   }
 
-  classExists(name) {
+  classExists(name: string) {
     return this.connect().then(() => {
       return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();
     }).then(collections => {
       return collections.length > 0;
     });
   }
 
-  setClassLevelPermissions(className, CLPs) {
+  setClassLevelPermissions(className: string, CLPs: any) {
     return this._schemaCollection()
       .then(schemaCollection => schemaCollection.updateSchema(className, {
         $set: { _metadata: { class_permissions: CLPs } }
       }));
   }
 
-  createClass(className, schema) {
+  createClass(className: string, schema: SchemaType) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions);
     mongoObject._id = className;
@@ -181,15 +192,15 @@ export class MongoStorageAdapter {
       })
   }
 
-  addFieldIfNotExists(className, fieldName, type) {
+  addFieldIfNotExists(className: string, fieldName: string, type: any) {
     return this._schemaCollection()
       .then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type))
       .then(() => this.createIndexesIfNeeded(className, fieldName, type));
   }
 
   // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)
   // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.
-  deleteClass(className) {
+  deleteClass(className: string) {
     return this._adaptiveCollection(className)
       .then(collection => collection.drop())
       .catch(error => {
@@ -230,7 +241,7 @@ export class MongoStorageAdapter {
   // may do so.
 
   // Returns a Promise.
-  deleteFields(className, schema, fieldNames) {
+  deleteFields(className: string, schema: SchemaType, fieldNames: string[]) {
     const mongoFormatNames = fieldNames.map(fieldName => {
       if (schema.fields[fieldName].type === 'Pointer') {
         return `_p_${fieldName}`
@@ -264,15 +275,15 @@ export class MongoStorageAdapter {
   // Return a promise for the schema with the given name, in Parse format. If
   // this adapter doesn't know about the schema, return a promise that rejects with
   // undefined as the reason.
-  getClass(className) {
+  getClass(className: string) {
     return this._schemaCollection()
       .then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className))
   }
 
   // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema,
   // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs
   // the schema only for the legacy mongo format. We'll figure that out later.
-  createObject(className, schema, object) {
+  createObject(className: string, schema: SchemaType, object: any) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoObject = parseObjectToMongoObjectForCreate(className, object, schema);
     return this._adaptiveCollection(className)
@@ -296,7 +307,7 @@ export class MongoStorageAdapter {
   // Remove all objects that match the given Parse Query.
   // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.
   // If there is some other error, reject with INTERNAL_SERVER_ERROR.
-  deleteObjectsByQuery(className, schema, query) {
+  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {
     schema = convertParseSchemaToMongoSchema(schema);
     return this._adaptiveCollection(className)
       .then(collection => {
@@ -314,7 +325,7 @@ export class MongoStorageAdapter {
   }
 
   // Apply the update to all objects that match the given Parse Query.
-  updateObjectsByQuery(className, schema, query, update) {
+  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoUpdate = transformUpdate(className, update, schema);
     const mongoWhere = transformWhere(className, query, schema);
@@ -324,7 +335,7 @@ export class MongoStorageAdapter {
 
   // Atomically finds and updates an object based on query.
   // Return value not currently well specified.
-  findOneAndUpdate(className, schema, query, update) {
+  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoUpdate = transformUpdate(className, update, schema);
     const mongoWhere = transformWhere(className, query, schema);
@@ -334,7 +345,7 @@ export class MongoStorageAdapter {
   }
 
   // Hopefully we can get rid of this. It's only used for config and hooks.
-  upsertOneObject(className, schema, query, update) {
+  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoUpdate = transformUpdate(className, update, schema);
     const mongoWhere = transformWhere(className, query, schema);
@@ -343,7 +354,7 @@ export class MongoStorageAdapter {
   }
 
   // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.
-  find(className, schema, query, { skip, limit, sort, keys, readPreference }) {
+  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptionsType) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoWhere = transformWhere(className, query, schema);
     const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));
@@ -371,7 +382,7 @@ export class MongoStorageAdapter {
   // As such, we shouldn't expose this function to users of parse until we have an out-of-band
   // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,
   // which is why we use sparse indexes.
-  ensureUniqueness(className, schema, fieldNames) {
+  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {
     schema = convertParseSchemaToMongoSchema(schema);
     const indexCreationRequest = {};
     const mongoFieldNames = fieldNames.map(fieldName => transformKey(className, fieldName, schema));
@@ -389,14 +400,14 @@ export class MongoStorageAdapter {
   }
 
   // Used in tests
-  _rawFind(className, query) {
+  _rawFind(className: string, query: QueryType) {
     return this._adaptiveCollection(className).then(collection => collection.find(query, {
       maxTimeMS: this._maxTimeMS,
     }));
   }
 
   // Executes a count.
-  count(className, schema, query, readPreference) {
+  count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string) {
     schema = convertParseSchemaToMongoSchema(schema);
     readPreference = this._parseReadPreference(readPreference);
     return this._adaptiveCollection(className)
@@ -406,13 +417,13 @@ export class MongoStorageAdapter {
       }));
   }
 
-  distinct(className, schema, query, fieldName) {
+  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {
     schema = convertParseSchemaToMongoSchema(schema);
     return this._adaptiveCollection(className)
       .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)));
   }
 
-  aggregate(className, pipeline, readPreference) {
+  aggregate(className: string, pipeline: any, readPreference: ?string) {
     readPreference = this._parseReadPreference(readPreference);
     return this._adaptiveCollection(className)
       .then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS }))
@@ -427,7 +438,7 @@ export class MongoStorageAdapter {
       });
   }
 
-  _parseReadPreference(readPreference) {
+  _parseReadPreference(readPreference: ?string): ?string {
     if (readPreference) {
       switch (readPreference) {
       case 'PRIMARY':
@@ -452,16 +463,16 @@ export class MongoStorageAdapter {
     return readPreference;
   }
 
-  performInitialization() {
+  performInitialization(): Promise<void> {
     return Promise.resolve();
   }
 
-  createIndex(className, index) {
+  createIndex(className: string, index: any) {
     return this._adaptiveCollection(className)
       .then(collection => collection._mongoCollection.createIndex(index));
   }
 
-  createIndexesIfNeeded(className, fieldName, type) {
+  createIndexesIfNeeded(className: string, fieldName: string, type: any) {
     if (type && type.type === 'Polygon') {
       const index = {
         [fieldName]: '2dsphere'
@@ -471,7 +482,7 @@ export class MongoStorageAdapter {
     return Promise.resolve();
   }
 
-  createTextIndexesIfNeeded(className, query) {
+  createTextIndexesIfNeeded(className: string, query: QueryType) {
     for(const fieldName in query) {
       if (!query[fieldName] || !query[fieldName].$text) {
         continue;
@@ -492,11 +503,10 @@ export class MongoStorageAdapter {
     return Promise.resolve();
   }
 
-  getIndexes(className) {
+  getIndexes(className: string) {
     return this._adaptiveCollection(className)
       .then(collection => collection._mongoCollection.indexes());
   }
 }
 
 export default MongoStorageAdapter;
-module.exports = MongoStorageAdapter; // Required for tests