WIP: refactor index code

Author: jshcrowthe

src/database/api/DataSnapshot.ts

@@ -2,7 +2,7 @@ import { validateArgCount, validateCallback } from "../../utils/validation";
 import { validatePathString } from "../core/util/validation";
 import { Path } from "../core/util/Path";
 import { exportPropGetter } from "../core/util/util";
-import { PriorityIndex } from "../core/snap/IndexFactory";
+import { PRIORITY_INDEX } from "../core/snap/indexes/PriorityIndex";
 
 /**
  * Class representing a firebase data snapshot.  It wraps a SnapshotNode and
@@ -90,7 +90,7 @@ DataSnapshot.prototype.child = function(childPathString) {
 
   var childPath = new Path(childPathString);
   var childRef = this.query_.child(childPath);
-  return new DataSnapshot(this.node_.getChild(childPath), childRef, PriorityIndex);
+  return new DataSnapshot(this.node_.getChild(childPath), childRef, PRIORITY_INDEX);
 };
 
 /**
@@ -138,7 +138,7 @@ DataSnapshot.prototype.forEach = function(action) {
   var self = this;
   // Sanitize the return value to a boolean. ChildrenNode.forEachChild has a weird return type...
   return !!childrenNode.forEachChild(this.index_, function(key, node) {
-    return action(new DataSnapshot(node, self.query_.child(key), PriorityIndex));
+    return action(new DataSnapshot(node, self.query_.child(key), PRIORITY_INDEX));
   });
 };
 

src/database/api/Query.ts

@@ -1,5 +1,7 @@
 import { assert } from '../../utils/assert';
-import { KeyIndex, PriorityIndex, ValueIndex } from "../core/snap/IndexFactory";
+import { KEY_INDEX } from "../core/snap/indexes/KeyIndex";
+import { PRIORITY_INDEX } from "../core/snap/indexes/PriorityIndex";
+import { VALUE_INDEX } from "../core/snap/indexes/ValueIndex";
 import { PathIndex } from "../core/snap/indexes/PathIndex";
 import { MIN_NAME,MAX_NAME,ObjectToUniqueKey } from "../core/util/util";
 import { Path } from "../core/util/Path";
@@ -15,6 +17,7 @@ import { ValueEventRegistration, ChildEventRegistration } from "../core/view/Eve
 import { Deferred, attachDummyErrorHandler } from "../../utils/promise";
 import { Reference } from "./Reference";
 import { Repo } from "../core/Repo";
+import { QueryParams } from "../core/view/QueryParams";
 
 /**
  * A Query represents a filter to be applied to a firebase location.  This object purely represents the
@@ -23,23 +26,8 @@ import { Repo } from "../core/Repo";
  * Since every Firebase reference is a query, Firebase inherits from this object.
  */
 export class Query {
-  repo: Repo;
-  path;
-  queryParams_;
-  orderByCalled_;
 
-  /**
-   * @param {!Repo} repo
-   * @param {!Path} path
-   * @param {!QueryParams} queryParams
-   * @param {!boolean} orderByCalled
-   */
-  constructor(repo, path, queryParams, orderByCalled) {
-    this.repo = repo;
-    this.path = path;
-    this.queryParams_ = queryParams;
-    this.orderByCalled_ = orderByCalled;
-  }
+  constructor(public repo: Repo, public path: Path, private queryParams_: QueryParams, private orderByCalled_: boolean) {}
 
   /**
    * Validates start/end values for queries.
@@ -56,7 +44,7 @@ export class Query {
       endNode = params.getIndexEndValue();
     }
 
-    if (params.getIndex() === KeyIndex) {
+    if (params.getIndex() === KEY_INDEX) {
       var tooManyArgsError = 'Query: When ordering by key, you may only pass one argument to ' +
           'startAt(), endAt(), or equalTo().';
       var wrongArgTypeError = 'Query: When ordering by key, the argument passed to startAt(), endAt(),' +
@@ -78,15 +66,15 @@ export class Query {
         }
       }
     }
-    else if (params.getIndex() === PriorityIndex) {
+    else if (params.getIndex() === PRIORITY_INDEX) {
       if ((startNode != null && !isValidPriority(startNode)) ||
           (endNode != null && !isValidPriority(endNode))) {
         throw new Error('Query: When ordering by priority, the first argument passed to startAt(), ' +
             'endAt(), or equalTo() must be a valid priority value (null, a number, or a string).');
       }
     } else {
       assert((params.getIndex() instanceof PathIndex) ||
-                          (params.getIndex() === ValueIndex), 'unknown index type.');
+                          (params.getIndex() === VALUE_INDEX), 'unknown index type.');
       if ((startNode != null && typeof startNode === 'object') ||
           (endNode != null && typeof endNode === 'object')) {
         throw new Error('Query: First argument passed to startAt(), endAt(), or equalTo() cannot be ' +
@@ -324,7 +312,7 @@ export class Query {
   orderByKey() {
     validateArgCount('Query.orderByKey', 0, 0, arguments.length);
     this.validateNoPreviousOrderByCall_('Query.orderByKey');
-    var newParams = this.queryParams_.orderBy(KeyIndex);
+    var newParams = this.queryParams_.orderBy(KEY_INDEX);
     this.validateQueryEndpoints_(newParams);
     return new Query(this.repo, this.path, newParams, /*orderByCalled=*/true);
   }
@@ -336,7 +324,7 @@ export class Query {
   orderByPriority() {
     validateArgCount('Query.orderByPriority', 0, 0, arguments.length);
     this.validateNoPreviousOrderByCall_('Query.orderByPriority');
-    var newParams = this.queryParams_.orderBy(PriorityIndex);
+    var newParams = this.queryParams_.orderBy(PRIORITY_INDEX);
     this.validateQueryEndpoints_(newParams);
     return new Query(this.repo, this.path, newParams, /*orderByCalled=*/true);
   }
@@ -348,7 +336,7 @@ export class Query {
   orderByValue() {
     validateArgCount('Query.orderByValue', 0, 0, arguments.length);
     this.validateNoPreviousOrderByCall_('Query.orderByValue');
-    var newParams = this.queryParams_.orderBy(ValueIndex);
+    var newParams = this.queryParams_.orderBy(VALUE_INDEX);
     this.validateQueryEndpoints_(newParams);
     return new Query(this.repo, this.path, newParams, /*orderByCalled=*/true);
   }

src/database/api/Reference.ts

@@ -22,7 +22,8 @@ import {
 import { Deferred, attachDummyErrorHandler, PromiseImpl } from "../../utils/promise";
 
 export class Reference extends Query {
-  then;
+  public then;
+  public catch;
   /**
    * Call options:
    *   new Reference(Repo, Path) or
@@ -34,23 +35,13 @@ export class Reference extends Query {
    * @param {(!Path)} path
    * @extends {Query}
    */
-  constructor(repo, path) {
+  constructor(repo: Repo, path: Path) {
     if (!(repo instanceof Repo)) {
       throw new Error("new Reference() no longer supported - use app.database().");
     }
 
     // call Query's constructor, passing in the repo and path.
-    super(repo, path, QueryParams.DEFAULT, /*orderByCalled=*/false);
-
-    /**
-     * When defined is the then function for the promise + Firebase hybrid
-     * returned by push() When then is defined, catch will be as well, though
-     * it's created using some hackery to get around conflicting ES3 and Closure
-     * Compiler limitations.
-     * @type {Function|undefined}
-     */
-    this.then = void 0;
-    /** @type {letMeUseMapAccessors} */ (this)['catch'] = void 0;
+    super(repo, path, QueryParams.DEFAULT, false);
   }
 
   /** @return {?string} */

src/database/core/CompoundWrite.ts

@@ -2,7 +2,7 @@ import { ImmutableTree } from "./util/ImmutableTree";
 import { Path } from "./util/Path";
 import { forEach } from "../../utils/obj";
 import { NamedNode } from "./snap/Node";
-import { PriorityIndex } from "./snap/IndexFactory";
+import { PRIORITY_INDEX } from "./snap/indexes/PriorityIndex";
 import { assert } from "../../utils/assert";
 
 /**
@@ -121,7 +121,7 @@ export class CompoundWrite {
       // If it's a leaf node, it has no children; so nothing to do.
       if (!node.isLeafNode()) {
         node = /** @type {!ChildrenNode} */ (node);
-        node.forEachChild(PriorityIndex, function(childName, childNode) {
+        node.forEachChild(PRIORITY_INDEX, function(childName, childNode) {
           children.push(new NamedNode(childName, childNode));
         });
       }

src/database/core/Repo_transaction.ts

@@ -3,7 +3,7 @@ import { Reference } from "../api/Reference";
 import { DataSnapshot } from "../api/DataSnapshot";
 import { Path } from "./util/Path";
 import { Tree } from "./util/Tree";
-import { PriorityIndex } from "./snap/IndexFactory";
+import { PRIORITY_INDEX } from "./snap/indexes/PriorityIndex";
 import { 
   LUIDGenerator,
   warn,
@@ -157,7 +157,7 @@ declare module './Repo' {
     if (transaction.onComplete) {
       // We just set the input snapshot, so this cast should be safe
       var snapshot = new DataSnapshot(/** @type {!Node} */ (transaction.currentInputSnapshot),
-        new Reference(this, transaction.path), PriorityIndex);
+        new Reference(this, transaction.path), PRIORITY_INDEX);
       transaction.onComplete(/*error=*/null, /*committed=*/false, snapshot);
     }
   } else {
@@ -294,7 +294,7 @@ declare module './Repo' {
           // We never unset the output snapshot, and given that this transaction is complete, it should be set
           var node = /** @type {!Node} */ (queue[i].currentOutputSnapshotResolved);
           var ref = new Reference(self, queue[i].path);
-          var snapshot = new DataSnapshot(node, ref, PriorityIndex);
+          var snapshot = new DataSnapshot(node, ref, PRIORITY_INDEX);
           callbacks.push(queue[i].onComplete.bind(null, null, true, snapshot));
         }
         queue[i].unwatcher();
@@ -443,7 +443,7 @@ declare module './Repo' {
           var ref = new Reference(this, queue[i].path);
           // We set this field immediately, so it's safe to cast to an actual snapshot
           var lastInput = /** @type {!Node} */ (queue[i].currentInputSnapshot);
-          var snapshot = new DataSnapshot(lastInput, ref, PriorityIndex);
+          var snapshot = new DataSnapshot(lastInput, ref, PRIORITY_INDEX);
           callbacks.push(queue[i].onComplete.bind(null, null, false, snapshot));
         } else {
           callbacks.push(queue[i].onComplete.bind(null, new Error(abortReason), false, null));

src/database/core/SparseSnapshotTree.ts

@@ -1,5 +1,5 @@
 import { Path } from "./util/Path";
-import { PriorityIndex } from "./snap/IndexFactory";
+import { PRIORITY_INDEX } from "./snap/indexes/PriorityIndex";
 import { CountedSet } from "./util/CountedSet";
 
 /**
@@ -98,7 +98,7 @@ export class SparseSnapshotTree {
           this.value_ = null;
 
           var self = this;
-          value.forEachChild(PriorityIndex, function(key, tree) {
+          value.forEachChild(PRIORITY_INDEX, function(key, tree) {
             self.remember(new Path(key), tree);
           });
 

src/database/core/WriteTree.ts

@@ -2,7 +2,7 @@ import { findKey, forEach } from "../../utils/obj";
 import { assert, assertionError } from "../../utils/assert";
 import { Path } from "./util/Path";
 import { CompoundWrite } from "./CompoundWrite";
-import { PriorityIndex } from "./snap/IndexFactory";
+import { PRIORITY_INDEX } from "./snap/indexes/PriorityIndex";
 import { ChildrenNode } from "./snap/ChildrenNode";
 
 /**
@@ -247,7 +247,7 @@ export class WriteTree {
     if (topLevelSet) {
       if (!topLevelSet.isLeafNode()) {
         // we're shadowing everything. Return the children.
-        topLevelSet.forEachChild(PriorityIndex, function(childName, childSnap) {
+        topLevelSet.forEachChild(PRIORITY_INDEX, function(childName, childSnap) {
           completeChildren = completeChildren.updateImmediateChild(childName, childSnap);
         });
       }
@@ -256,7 +256,7 @@ export class WriteTree {
       // Layer any children we have on top of this
       // We know we don't have a top-level set, so just enumerate existing children
       var merge = this.visibleWrites_.childCompoundWrite(treePath);
-      completeServerChildren.forEachChild(PriorityIndex, function(childName, childNode) {
+      completeServerChildren.forEachChild(PRIORITY_INDEX, function(childName, childNode) {
         var node = merge.childCompoundWrite(new Path(childName)).apply(childNode);
         completeChildren = completeChildren.updateImmediateChild(childName, node);
       });

src/database/core/snap/ChildrenNode.ts

@@ -10,7 +10,8 @@ import {
   validatePriorityNode, 
   priorityHashText,
 } from "./snap";
-import { PriorityIndex, KeyIndex } from "./IndexFactory";
+import { PRIORITY_INDEX } from "./indexes/PriorityIndex";
+import { KEY_INDEX } from "./indexes/KeyIndex";
 import { IndexMap } from "./IndexMap";
 import { NAME_COMPARATOR } from "./comparators";
 
@@ -185,7 +186,7 @@ export class ChildrenNode implements Node {
 
     var obj = { };
     var numKeys = 0, maxKey = 0, allIntegerKeys = true;
-    this.forEachChild(PriorityIndex, function(key, childNode) {
+    this.forEachChild(PRIORITY_INDEX, function(key, childNode) {
       obj[key] = childNode.val(opt_exportFormat);
 
       numKeys++;
@@ -220,7 +221,7 @@ export class ChildrenNode implements Node {
         toHash += 'priority:' + priorityHashText(
             /**@type {(!string|!number)} */ (this.getPriority().val())) + ':';
 
-      this.forEachChild(PriorityIndex, function(key, childNode) {
+      this.forEachChild(PRIORITY_INDEX, function(key, childNode) {
         var childHash = childNode.hash();
         if (childHash !== '')
           toHash += ':' + key + ':' + childHash;
@@ -394,7 +395,7 @@ export class ChildrenNode implements Node {
    * @inheritDoc
    */
   withIndex(indexDefinition) {
-    if (indexDefinition === KeyIndex || this.indexMap_.hasIndex(indexDefinition)) {
+    if (indexDefinition === KEY_INDEX || this.indexMap_.hasIndex(indexDefinition)) {
       return this;
     } else {
       var newIndexMap = this.indexMap_.addIndex(indexDefinition, this.children_);
@@ -406,7 +407,7 @@ export class ChildrenNode implements Node {
    * @inheritDoc
    */
   isIndexed(index) {
-    return index === KeyIndex || this.indexMap_.hasIndex(index);
+    return index === KEY_INDEX || this.indexMap_.hasIndex(index);
   };
 
   /**
@@ -423,8 +424,8 @@ export class ChildrenNode implements Node {
       if (!this.getPriority().equals(otherChildrenNode.getPriority())) {
         return false;
       } else if (this.children_.count() === otherChildrenNode.children_.count()) {
-        var thisIter = this.getIterator(PriorityIndex);
-        var otherIter = otherChildrenNode.getIterator(PriorityIndex);
+        var thisIter = this.getIterator(PRIORITY_INDEX);
+        var otherIter = otherChildrenNode.getIterator(PRIORITY_INDEX);
         var thisCurrent = thisIter.getNext();
         var otherCurrent = otherIter.getNext();
         while (thisCurrent && otherCurrent) {
@@ -451,7 +452,7 @@ export class ChildrenNode implements Node {
    * @return {?SortedMap.<NamedNode, Node>}
    */
   resolveIndex_(indexDefinition) {
-    if (indexDefinition === KeyIndex) {
+    if (indexDefinition === KEY_INDEX) {
       return null;
     } else {
       return this.indexMap_.get(indexDefinition.toString());
@@ -480,7 +481,7 @@ export class MaxNode extends ChildrenNode {
 
 
   equals(other) {
-    // Not that we every compare it, but MAX_NODE_ is only ever equal to itself
+    // Not that we every compare it, but MAX_NODE is only ever equal to itself
     return other === this;
   };
 
@@ -502,10 +503,26 @@ export class MaxNode extends ChildrenNode {
 
 /**
  * Marker that will sort higher than any other snapshot.
- * @type {!MAX_NODE_}
+ * @type {!MAX_NODE}
  * @const
  */
 export const MAX_NODE = new MaxNode();
 
-(NamedNode as any).MIN = new NamedNode(MIN_NAME, ChildrenNode.EMPTY_NODE);
-(NamedNode as any).MAX = new NamedNode(MAX_NAME, MAX_NODE);
+/**
+ * Document NamedNode extensions
+ */
+declare module './Node' {
+  interface NamedNode {
+    MIN: NamedNode,
+    MAX: NamedNode
+  }
+}
+
+Object.defineProperties(NamedNode, {
+  MIN: {
+    value: new NamedNode(MIN_NAME, ChildrenNode.EMPTY_NODE)
+  },
+  MAX: {
+    value: new NamedNode(MAX_NAME, MAX_NODE)
+  }
+});