Moves Controller types into a single file

Author: flovilmart

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -4,7 +4,7 @@ import MongoSchemaCollection from './MongoSchemaCollection';
 import { StorageAdapter, IndexingStorageAdapter }    from '../StorageAdapter';
 import type { SchemaType,
   QueryType,
-  QueryOptionsType } from '../StorageAdapter';
+  QueryOptions } from '../StorageAdapter';
 import {
   parse as parseUrl,
   format as formatUrl,
@@ -354,7 +354,7 @@ export class MongoStorageAdapter implements StorageAdapter, IndexingStorageAdapt
   }
 
   // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.
-  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptionsType) {
+  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptions) {
     schema = convertParseSchemaToMongoSchema(schema);
     const mongoWhere = transformWhere(className, query, schema);
     const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));

src/Adapters/Storage/Postgres/PostgresStorageAdapter.js

@@ -23,7 +23,7 @@ const debug = function(...args: any) {
 import { StorageAdapter }    from '../StorageAdapter';
 import type { SchemaType,
   QueryType,
-  QueryOptionsType } from '../StorageAdapter';
+  QueryOptions } from '../StorageAdapter';
 
 const parseTypeToPostgresType = type => {
   switch (type.type) {
@@ -1210,7 +1210,7 @@ export class PostgresStorageAdapter implements StorageAdapter {
     });
   }
 
-  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys }: QueryOptionsType) {
+  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys }: QueryOptions) {
     debug('find', className, query, {skip, limit, sort, keys });
     const hasLimit = limit !== undefined;
     const hasSkip = skip !== undefined;

src/Adapters/Storage/StorageAdapter.js

@@ -2,14 +2,27 @@
 export type SchemaType = any;
 export type StorageClass = any;
 export type QueryType = any;
-export type QueryOptionsType = {
-  skip?: ?number;
-  limit?: ?number;
-  sort?: ?any;
-  keys?: ?string[];
-  readPreference?: ?string;
+
+export type QueryOptions = {
+  skip?: number,
+  limit?: number,
+  acl?: string[],
+  sort?: {[string]: number},
+  count?: boolean | number,
+  keys?: string[],
+  op?: string,
+  distinct?: boolean,
+  pipeline?: any,
+  readPreference?: ?string,
 };
 
+export type UpdateQueryOptions = {
+  many?: boolean,
+  upsert?: boolean
+}
+
+export type FullQueryOptions = QueryOptions & UpdateQueryOptions;
+
 export interface StorageAdapter {
   classExists(className: string): Promise<boolean>;
   setClassLevelPermissions(className: string, clps: any): Promise<void>;
@@ -25,7 +38,7 @@ export interface StorageAdapter {
   updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any): Promise<[any]>;
   findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any): Promise<any>;
   upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any): Promise<any>;
-  find(className: string, schema: SchemaType, query: QueryType, options: QueryOptionsType): Promise<[any]>;
+  find(className: string, schema: SchemaType, query: QueryType, options: QueryOptions): Promise<[any]>;
   ensureUniqueness(className: string, schema: SchemaType, fieldNames: Array<string>): Promise<void>;
   count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string): Promise<number>;
   distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string): Promise<any>;

src/Controllers/DatabaseController.js

@@ -13,6 +13,9 @@ import deepcopy               from 'deepcopy';
 import logger                 from '../logger';
 import * as SchemaController       from './SchemaController';
 import { StorageAdapter }     from '../Adapters/Storage/StorageAdapter';
+import type { QueryOptions,
+  FullQueryOptions }          from '../Adapters/Storage/StorageAdapter';
+
 function addWriteACL(query, acl) {
   const newQuery = _.cloneDeep(query);
   //Can't be any existing '_wperm' query, we don't allow client queries on that, no need to $and
@@ -152,13 +155,7 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => {
   return object;
 };
 
-type Options = {
-  acl?: string[]
-}
-
-type LoadSchemaOptions = {
-  clearCache: boolean
-}
+import type { LoadSchemaOptions } from './types';
 
 // Runs an update on the database.
 // Returns a promise for an object with the new values for field
@@ -349,7 +346,7 @@ class DatabaseController {
   // 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 }: Options): Promise<boolean> {
+  validateObject(className: string, object: any, query: any, { acl }: QueryOptions): Promise<boolean> {
     let schema;
     const isMaster = acl === undefined;
     var aclGroup: string[]  = acl || [];
@@ -368,7 +365,7 @@ class DatabaseController {
     acl,
     many,
     upsert,
-  }: any = {}, skipSanitization: boolean = false): Promise<any> {
+  }: FullQueryOptions = {}, skipSanitization: boolean = false): Promise<any> {
     const originalQuery = query;
     const originalUpdate = update;
     // Make a copy of the object, so we don't mutate the incoming data.
@@ -544,7 +541,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 }: Options = {}): Promise<any> {
+  destroy(className: string, query: any, { acl }: QueryOptions = {}): Promise<any> {
     const isMaster = acl === undefined;
     const aclGroup = acl || [];
 
@@ -586,7 +583,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 }: Options = {}): Promise<any> {
+  create(className: string, object: any, { acl }: QueryOptions = {}): Promise<any> {
   // Make a copy of the object, so we don't mutate the incoming data.
     const originalObject = object;
     object = transformObjectACL(object);
@@ -646,7 +643,7 @@ class DatabaseController {
 
   // Returns a promise for a list of related ids given an owning id.
   // className here is the owning className.
-  relatedIds(className: string, key: string, owningId: string, queryOptions: any): Promise<Array<string>> {
+  relatedIds(className: string, key: string, owningId: string, queryOptions: QueryOptions): Promise<Array<string>> {
     const { skip, limit, sort } = queryOptions;
     const findOptions = {};
     if (sort && sort.createdAt && this.adapter.canSortOnJoinTables) {

src/Controllers/SchemaController.js

@@ -14,35 +14,17 @@
 // DatabaseController. This will let us replace the schema logic for
 // different databases.
 // TODO: hide all schema logic inside the database adapter.
-type SchemaField = {
-  type: string;
-  targetClass?: ?string;
-}
-
-type SchemaFields = { [string]: SchemaField }
-
-type Schema = {
-  className: string,
-  fields: SchemaFields,
-  classLevelPermissions: ClassLevelPermissions
-};
-
-type ClassLevelPermissions = {
-  find?: {[string]: boolean};
-  count?: {[string]: boolean};
-  get?: {[string]: boolean};
-  create?: {[string]: boolean};
-  update?: {[string]: boolean};
-  delete?: {[string]: boolean};
-  addField?: {[string]: boolean};
-  readUserFields?: string[];
-  writeUserFields?: string[];
-};
-
 // @flow-disable-next
 const Parse = require('parse/node').Parse;
 import { StorageAdapter }     from '../Adapters/Storage/StorageAdapter';
 import DatabaseController     from './DatabaseController';
+import type {
+  Schema,
+  SchemaFields,
+  ClassLevelPermissions,
+  SchemaField,
+  LoadSchemaOptions,
+} from './types';
 
 const defaultColumns: {[string]: SchemaFields} = Object.freeze({
   // Contain the default columns for every parse object type (except _Join collection)
@@ -396,7 +378,7 @@ export default class SchemaController {
     this.perms = {};
   }
 
-  reloadData(options: any = {clearCache: false}): Promise<any> {
+  reloadData(options: LoadSchemaOptions = {clearCache: false}): Promise<any> {
     let promise = Promise.resolve();
     if (options.clearCache) {
       promise = promise.then(() => {
@@ -434,7 +416,7 @@ export default class SchemaController {
     return this.reloadDataPromise;
   }
 
-  getAllClasses(options: any = {clearCache: false}): Promise<Array<Schema>> {
+  getAllClasses(options: LoadSchemaOptions = {clearCache: false}): Promise<Array<Schema>> {
     let promise = Promise.resolve();
     if (options.clearCache) {
       promise = this._cache.clear();
@@ -455,7 +437,7 @@ export default class SchemaController {
     });
   }
 
-  getOneSchema(className: string, allowVolatileClasses: boolean = false, options: any = {clearCache: false}): Promise<Schema> {
+  getOneSchema(className: string, allowVolatileClasses: boolean = false, options: LoadSchemaOptions = {clearCache: false}): Promise<Schema> {
     let promise = Promise.resolve();
     if (options.clearCache) {
       promise = this._cache.clear();

src/Controllers/types.js

@@ -0,0 +1,28 @@
+export type LoadSchemaOptions = {
+  clearCache: boolean
+};
+
+export type SchemaField = {
+  type: string;
+  targetClass?: ?string;
+}
+
+export type SchemaFields = { [string]: SchemaField }
+
+export type Schema = {
+  className: string,
+  fields: SchemaFields,
+  classLevelPermissions: ClassLevelPermissions
+};
+
+export type ClassLevelPermissions = {
+  find?: {[string]: boolean};
+  count?: {[string]: boolean};
+  get?: {[string]: boolean};
+  create?: {[string]: boolean};
+  update?: {[string]: boolean};
+  delete?: {[string]: boolean};
+  addField?: {[string]: boolean};
+  readUserFields?: string[];
+  writeUserFields?: string[];
+};