Merge pull request #87 from philikon/refactoring

Refactor and improve Flow typing

Author: andrewimm

src/Delta.js

@@ -25,6 +25,8 @@
 
 var Id = require('./Id');
 
+import type { FlattenedObjectData } from './ObjectStore';
+
 /**
  * A Delta represents a change that has been verified by the server, but has
  * not yet been merged into the "Last True State" (typically because some
@@ -39,10 +41,10 @@ class Delta {
   destroy: ?boolean;
 
   constructor(
-      id: Id,
-      data: { [key: string]: any },
-      options?: { [key: string]: boolean }
-    ) {
+    id: Id,
+    data: FlattenedObjectData,
+    options?: { [key: string]: boolean }
+  ) {
     if (!(id instanceof Id)) {
       throw new TypeError('Cannot create a Delta with an invalid target Id');
     }
@@ -80,8 +82,6 @@ class Delta {
     for (var attr in source.map) {
       this.map[attr] = source.map[attr];
     }
-
-    return this;
   }
 }
 

src/MutationBatch.js

@@ -25,7 +25,7 @@
 
 var Parse = require('./StubParse');
 
-import type ParseRequestOptions from './MutationExecutor';
+import type { ParseRequestOptions } from './MutationExecutor';
 
 class MutationBatch {
   static maxBatchSize: number;

src/MutationExecutor.js

@@ -34,13 +34,14 @@ export type ParseRequestOptions = {
   objectId?: string;
 };
 
+import type { Mutation } from './Mutation';
 import type * as MutationBatch from './MutationBatch';
 
 
 var toString = Object.prototype.toString;
 // Special version of Parse._encode to handle our unique representations of
 // pointers
-function encode(data, seen?) {
+function encode(data: any, seen?: Array<any>): any {
   if (!seen) {
     seen = [];
   }
@@ -112,16 +113,16 @@ function sendRequest(options: ParseRequestOptions): Parse.Promise {
 }
 
 function execute(
-  action: string,
-  target: Id|string,
-  data: any,
+  mutation: Mutation,
   batch: ?MutationBatch
 ): Parse.Promise {
+  var target = mutation.target;
+  var data = mutation.data;
   var className = (typeof target === 'string') ? target : target.className;
   var objectId = (typeof target === 'string') ? '' : target.objectId;
   var payload;
   var request = batch ? batch.addRequest : sendRequest;
-  switch (action) {
+  switch (mutation.action) {
     case 'CREATE':
       return request({
         method: 'POST',
@@ -233,15 +234,10 @@ function execute(
         data: payload
       });
   }
-  throw new TypeError('Invalid Mutation action: ' + action);
+  throw new TypeError('Invalid Mutation action: ' + mutation.action);
 }
 
-var MutationExecutor: any = {
-  execute: execute,
-};
-
+module.exports.execute = execute;
 if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-  MutationExecutor.encode = encode;
+  module.exports.encode = encode;
 }
-
-module.exports = MutationExecutor;

src/ObjectStore.js

@@ -23,13 +23,25 @@
 
 'use strict';
 
-import type * as Delta from './Delta';
-import type { Mutation } from './Mutation';
-
 var flatten = require('./flatten');
 var Id = require('./Id');
 var queryHash = require('./QueryTools').queryHash;
 
+import type * as Delta from './Delta';
+import type { Mutation } from './Mutation';
+
+export type OrderingInfo = { [key: string]: any };
+export type IdWithOrderingInfo = {
+  id: Id;
+  ordering: OrderingInfo;
+};
+export type FlattenedObjectData = { [attr: string]: any };
+export type ObjectChangeDescriptor = {
+  id: Id;
+  latest: any;  // TODO: this should really be FlattenedObjectData
+  fields?: Array<string>;
+};
+
 /**
  * ObjectStore is a local cache for Parse Objects. It stores the last known
  * server version of each object it has seen, as well as a stack of pending
@@ -42,7 +54,7 @@ var queryHash = require('./QueryTools').queryHash;
 // queries subscribed to the object.
 var store: {
   [id: Id]: {
-    data: { [attr: string]: any };
+    data: FlattenedObjectData;
     queries: { [hash: string]: boolean }
   }
 } = {};
@@ -66,7 +78,7 @@ var mutationCount = 0;
  * storeObject: takes a flattened object as the single argument, and places it
  * in the Store, indexed by its Id.
  */
-function storeObject(data: { [attr: string]: any }): Id {
+function storeObject(data: FlattenedObjectData): Id {
   if (!(data.id instanceof Id)) {
     throw new Error('Cannot store an object without an Id');
   }
@@ -168,7 +180,11 @@ function destroyMutationStack(target: Id) {
  * Returns the latest object state and an array of keys that changed, or null
  * in the case of a Destroy
  */
-function resolveMutation(target: Id, payloadId: number, delta: Delta): { id: Id; latest: any; fields?: Array<string> } {
+function resolveMutation(
+  target: Id,
+  payloadId: number,
+  delta: Delta
+): ObjectChangeDescriptor {
   var stack = pendingMutations[target];
   var i;
   for (i = 0; i < stack.length; i++) {
@@ -219,8 +235,7 @@ function resolveMutation(target: Id, payloadId: number, delta: Delta): { id: Id;
  * Returns the latest object state and an array of keys that changed, or null
  * in the case of a Destroy
  */
-function commitDelta(delta: Delta):
-    { id: Id; latest: any; fields?: Array<string> } {
+function commitDelta(delta: Delta): ObjectChangeDescriptor {
   var id = delta.id;
   if (delta.destroy) {
     if (store[id]) {
@@ -274,8 +289,10 @@ function commitDelta(delta: Delta):
  * Returns an array of object Ids, or an array of maps containing Ids and query-
  * specific ordering information.
  */
-function storeQueryResults(results: Array<ParseObject> | ParseObject, query: ParseQuery):
-    Array<Id | { id: Id; ordering: any }> {
+function storeQueryResults(
+  results: Array<ParseObject> | ParseObject,
+  query: ParseQuery
+): Array<Id | IdWithOrderingInfo> {
   var hash = queryHash(query);
   if (!Array.isArray(results)) {
     results = [results];
@@ -336,7 +353,7 @@ function storeQueryResults(results: Array<ParseObject> | ParseObject, query: Par
  * Given a list of object Ids, fetches the latest data for each object
  * and returns the results as an array of shallow copies.
  */
-function getDataForIds(ids: Id | Array<Id>): Array<any> {
+function getDataForIds(ids: Id | Array<Id>): Array<FlattenedObjectData> {
   if (!Array.isArray(ids)) {
     ids = [ids];
   }
@@ -356,7 +373,7 @@ function getDataForIds(ids: Id | Array<Id>): Array<any> {
 /**
  * Fetch objects from the store, converting pointers to objects where possible
  */
-function deepFetch(id: Id, seen?: Array<string>) {
+function deepFetch(id: Id, seen?: Array<string>): ?FlattenedObjectData {
   if (!store[id]) {
     return null;
   }
@@ -368,7 +385,7 @@ function deepFetch(id: Id, seen?: Array<string>) {
   var seenChildren = [];
   for (var attr in source) {
     var sourceVal = source[attr];
-    if ( sourceVal && typeof sourceVal === 'object' && sourceVal.__type === 'Pointer') {
+    if (sourceVal && typeof sourceVal === 'object' && sourceVal.__type === 'Pointer') {
       var childId = new Id(sourceVal.className, sourceVal.objectId);
       if (seen.indexOf(childId.toString()) < 0 && store[childId]) {
         seenChildren = seenChildren.concat([childId.toString()]);
@@ -383,7 +400,7 @@ function deepFetch(id: Id, seen?: Array<string>) {
 /**
  * Calculate the result of applying all Mutations to an object.
  */
-function getLatest(id: Id) {
+function getLatest(id: Id): ?FlattenedObjectData {
   if (pendingMutations[id] && pendingMutations[id].length > 0) {
     var base = {};
     var mutation;
@@ -422,26 +439,22 @@ function getLatest(id: Id) {
   return store[id] ? deepFetch(id) : null;
 }
 
-var ObjectStore: { [key: string]: any } = {
-  storeObject: storeObject,
-  removeObject: removeObject,
-  addSubscriber: addSubscriber,
-  removeSubscriber: removeSubscriber,
-  fetchSubscribers: fetchSubscribers,
-  stackMutation: stackMutation,
-  destroyMutationStack: destroyMutationStack,
-  resolveMutation: resolveMutation,
-  commitDelta: commitDelta,
-  storeQueryResults: storeQueryResults,
-  getDataForIds: getDataForIds,
-  deepFetch: deepFetch,
-  getLatest: getLatest
-};
+module.exports.storeObject = storeObject;
+module.exports.removeObject = removeObject;
+module.exports.addSubscriber = addSubscriber;
+module.exports.removeSubscriber = removeSubscriber;
+module.exports.fetchSubscribers = fetchSubscribers;
+module.exports.stackMutation = stackMutation;
+module.exports.destroyMutationStack = destroyMutationStack;
+module.exports.resolveMutation = resolveMutation;
+module.exports.commitDelta = commitDelta;
+module.exports.storeQueryResults = storeQueryResults;
+module.exports.getDataForIds = getDataForIds;
+module.exports.deepFetch = deepFetch;
+module.exports.getLatest = getLatest;
 
 if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
   // Expose the raw storage
-  ObjectStore._rawStore = store;
-  ObjectStore._rawMutations = pendingMutations;
+  module.exports._rawStore = store;
+  module.exports._rawMutations = pendingMutations;
 }
-
-module.exports = ObjectStore;

src/QueryTools.js

@@ -27,6 +27,8 @@ var equalObjects = require('./equalObjects');
 var Id = require('./Id');
 var Parse = require('./StubParse');
 
+import type { FlattenedObjectData } from './ObjectStore';
+
 /**
  * Query Hashes are deterministic hashes for Parse Queries.
  * Any two queries that have the same set of constraints will produce the same
@@ -145,8 +147,9 @@ function keysFromHash(hash: string):
  * queries, we can avoid building a full-blown query tool.
  */
 function matchesQuery(
-    object: { [key: string]: any },
-    query: ParseQuery | { [key: string]: any }): boolean {
+  object: FlattenedObjectData,
+  query: ParseQuery | { [key: string]: any }
+): boolean {
   if (query instanceof Parse.Query) {
     var className =
       (object.id instanceof Id) ? object.id.className : object.className;

src/Subscription.js

@@ -26,6 +26,11 @@
 var Id = require('./Id');
 var ObjectStore = require('./ObjectStore');
 
+import type {
+  IdWithOrderingInfo,
+  OrderingInfo,
+} from './ObjectStore';
+
 type ParseObject = {
   id: Id
 };
@@ -48,8 +53,8 @@ export type Subscriber = {
  * When we store ordering information alongside Ids, this method can map over
  * the array to extract each Id.
  */
-function extractId(result) {
-  return result.id;
+function extractId(result: Id | IdWithOrderingInfo): Id {
+  return result instanceof Id ? result : result.id;
 }
 
 /**
@@ -58,7 +63,11 @@ function extractId(result) {
  * it should come after, return 1. If the two are equivalent in ordering, the
  * function returns 0.
  */
-function compareObjectOrder(queryOrder, object, orderInfo) {
+function compareObjectOrder(
+  queryOrder: Array<string>,
+  object: ParseObject,
+  orderInfo: OrderingInfo
+): number {
   for (var i = 0; i < queryOrder.length; i++) {
     var column = queryOrder[i];
     var multiplier = 1;
@@ -81,7 +90,7 @@ class Subscription {
   originalQuery: ParseQuery;
   pending: boolean;
   subscribers: { [key: string]: Subscriber };
-  resultSet: Array<any>;
+  resultSet: Array<Id | IdWithOrderingInfo>;
   observationCount: number;
 
   constructor(query: ParseQuery) {
@@ -109,10 +118,7 @@ class Subscription {
     var oid = 'o' + this.observationCount++;
     this.subscribers[oid] = callbacks;
 
-    var resultSet = this.resultSet;
-    if (resultSet[0] && !(resultSet[0] instanceof Id)) {
-      resultSet = resultSet.map(extractId);
-    }
+    var resultSet = this.resultSet.map(extractId);
     var data = resultSet.length ? ObjectStore.getDataForIds(resultSet) : [];
     callbacks.onNext(this.originalQuery._observeOne ? data[0] : data);
 
@@ -168,16 +174,21 @@ class Subscription {
       var index = 0;
       var orderColumns = this.originalQuery._order;
       while (index < this.resultSet.length) {
+        // Satisfy Flow by ensuring that the current result is indeed of the
+        // IdWithOrderingInfo type, and not a plain Id.
+        var result = this.resultSet[index];
+        if (result instanceof Id) {
+          throw new Error('Encountered result without ordering info.');
+        }
         var compare = compareObjectOrder(
           orderColumns,
           object,
-          this.resultSet[index].ordering
+          result.ordering
         );
-        if (compare > 0) {
-          index++;
-        } else {
+        if (compare <= 0) {
           break;
         }
+        index++;
       }
       var ordering = {};
       for (var i = 0; i < orderColumns.length; i++) {
@@ -224,13 +235,7 @@ class Subscription {
     if (this.originalQuery._limit > -1) {
       results = results.slice(0, this.originalQuery._limit);
     }
-    if (results[0] && !(results[0] instanceof Id)) {
-      results = results.map(extractId);
-    }
-    var resultSet = results;
-    if (resultSet[0] && !(resultSet[0] instanceof Id)) {
-      resultSet = resultSet.map(extractId);
-    }
+    var resultSet = results.map(extractId);
     var data = ObjectStore.getDataForIds(resultSet);
     if (this.originalQuery._observeOne) {
       data = data[0];