WIP: fix .priority not defined issue

This took way to long to fix.

Author: jshcrowthe

karma.conf.js

@@ -54,6 +54,9 @@ module.exports = {
 
   // karma-typescript config
   karmaTypescriptConfig: {
-    tsconfig: `./tsconfig.test.json`
+    tsconfig: `./tsconfig.test.json`,
+    coverageOptions: {
+      instrumentation: false
+    }
   }
 }

package.json

@@ -40,6 +40,7 @@
     "chai": "^3.5.0",
     "child-process-promise": "^2.2.1",
     "circular-dependency-plugin": "^3.0.0",
+    "cross-env": "^5.0.1",
     "cz-customizable": "^5.0.0",
     "filesize": "^3.5.6",
     "git-rev-sync": "^1.9.0",

src/database/api/Query.ts

@@ -15,18 +15,25 @@ import {
 import { errorPrefix, validateArgCount, validateCallback, validateContextObject } from "../../utils/validation";
 import { ValueEventRegistration, ChildEventRegistration } from "../core/view/EventRegistration";
 import { Deferred, attachDummyErrorHandler } from "../../utils/promise";
-import { Reference } from "./Reference";
 import { Repo } from "../core/Repo";
 import { QueryParams } from "../core/view/QueryParams";
 
+let __referenceConstructor: new(repo: Repo, path: Path) => Query;
+
 /**
  * A Query represents a filter to be applied to a firebase location.  This object purely represents the
  * query expression (and exposes our public API to build the query).  The actual query logic is in ViewBase.js.
  *
  * Since every Firebase reference is a query, Firebase inherits from this object.
  */
 export class Query {
-
+  static set __referenceConstructor(val) {
+    __referenceConstructor = val;
+  }
+  static get __referenceConstructor() {
+    assert(__referenceConstructor, 'Reference.ts has not been loaded');
+    return __referenceConstructor;
+  }
   constructor(public repo: Repo, public path: Path, private queryParams_: QueryParams, private orderByCalled_: boolean) {}
 
   /**
@@ -122,7 +129,7 @@ export class Query {
     // This is a slight hack. We cannot goog.require('fb.api.Firebase'), since Firebase requires fb.api.Query.
     // However, we will always export 'Firebase' to the global namespace, so it's guaranteed to exist by the time this
     // method gets called.
-    return new Reference(this.repo, this.path);
+    return new Query.__referenceConstructor(this.repo, this.path);
   }
 
   /**

src/database/api/Reference.ts

@@ -20,6 +20,7 @@ import {
   validateCallback,
 } from "../../utils/validation";
 import { Deferred, attachDummyErrorHandler, PromiseImpl } from "../../utils/promise";
+import { SyncPoint } from "../core/SyncPoint";
 
 export class Reference extends Query {
   public then;
@@ -294,12 +295,11 @@ export class Reference extends Query {
   }
 }
 
-Object.defineProperty(Query.prototype, 'getRef', {
-  value: function() {
-    validateArgCount('Query.ref', 0, 0, arguments.length);
-    // This is a slight hack. We cannot goog.require('Firebase'), since Firebase requires Query.
-    // However, we will always export 'Firebase' to the global namespace, so it's guaranteed to exist by the time this
-    // method gets called.
-    return new Reference(this.repo, this.path);
-  }
-});
+/**
+ * Define reference constructor in various modules
+ * 
+ * We are doing this here to avoid several circular
+ * dependency issues
+ */
+Query.__referenceConstructor = Reference;
+SyncPoint.__referenceConstructor = Reference;

src/database/core/Repo.ts

@@ -37,7 +37,7 @@ export class Repo {
   statsReporter_;
   transactions_init_;
   infoData_;
-  infoSyncTree_;
+  infoSyncTree_: SyncTree;
   onDisconnect_;
   abortTransactions_;
   rerunTransactions_;
@@ -46,7 +46,7 @@ export class Repo {
   database;
   dataUpdateCount;
   interceptServerDataCallback_;
-  serverSyncTree_;
+  serverSyncTree_: SyncTree;
 
   /**
    * @param {!RepoInfo} repoInfo

src/database/core/SyncPoint.ts

@@ -1,11 +1,12 @@
-import { Reference } from "../api/Reference";
 import { CacheNode } from "./view/CacheNode";
 import { ChildrenNode } from "./snap/ChildrenNode";
 import { assert } from "../../utils/assert";
 import { isEmpty, forEach, findValue } from "../../utils/obj";
 import { ViewCache } from "./view/ViewCache";
 import { View } from "./view/View";
 
+let __referenceConstructor;
+
 /**
  * SyncPoint represents a single location in a SyncTree with 1 or more event registrations, meaning we need to
  * maintain 1 or more Views at this location to cache server data and raise appropriate events for server changes
@@ -15,10 +16,17 @@ import { View } from "./view/View";
  *  - Maintaining the set of 1 or more views necessary at this location (a SyncPoint with 0 views should be removed).
  *  - Proxying user / server operations to the views as appropriate (i.e. applyServerOverwrite,
  *    applyUserOverwrite, etc.)
- *
- * @constructor
  */
 export class SyncPoint {
+  static set __referenceConstructor(val) {
+    assert(!__referenceConstructor, '__referenceConstructor has already been defined');    
+    __referenceConstructor = val;
+  }
+  static get __referenceConstructor() {
+    assert(__referenceConstructor, 'Reference.ts has not been loaded');
+    return __referenceConstructor;
+  }
+
   views_: object;
   constructor() {
     /**
@@ -73,8 +81,7 @@ export class SyncPoint {
    * @param {boolean} serverCacheComplete
    * @return {!Array.<!Event>} Events to raise.
    */
-  addEventRegistration(query, eventRegistration, writesCache, serverCache,
-                                                    serverCacheComplete) {
+  addEventRegistration(query, eventRegistration, writesCache, serverCache, serverCacheComplete) {
     var queryId = query.queryIdentifier();
     var view = this.views_[queryId];
     if (!view) {
@@ -151,7 +158,7 @@ export class SyncPoint {
 
     if (hadCompleteView && !this.hasCompleteView()) {
       // We removed our last complete view.
-      removed.push(new Reference(query.repo, query.path));
+      removed.push(new SyncPoint.__referenceConstructor(query.repo, query.path));
     }
 
     return {removed: removed, events: cancelEvents};

src/database/core/SyncTree.ts

@@ -322,7 +322,7 @@ export class SyncTree {
    * @param {Error=} cancelError If a cancelError is provided, appropriate cancel events will be returned.
    * @return {!Array.<!Event>} Cancel events, if cancelError was provided.
    */
-  removeEventRegistration(query, eventRegistration, cancelError) {
+  removeEventRegistration(query, eventRegistration, cancelError?) {
     // Find the syncPoint first. Then deal with whether or not it has matching listeners
     var path = query.path;
     var maybeSyncPoint = this.syncPointTree_.get(path);

src/database/core/WriteTree.ts

@@ -57,7 +57,7 @@ export class WriteTree {
    * @param {!Path} path
    * @return {!WriteTreeRef}
    */
-  childWrites(path) {
+  childWrites(path): WriteTreeRef {
     return new WriteTreeRef(path, this);
   };
 

src/database/core/snap/ChildrenNode.ts

@@ -9,11 +9,14 @@ import { Node, NamedNode } from "./Node";
 import { 
   validatePriorityNode, 
   priorityHashText,
+  setMaxNode
 } from "./snap";
-import { PRIORITY_INDEX } from "./indexes/PriorityIndex";
-import { KEY_INDEX } from "./indexes/KeyIndex";
+import { PRIORITY_INDEX, setMaxNode as setPriorityMaxNode } from "./indexes/PriorityIndex";
+import { KEY_INDEX, KeyIndex } from "./indexes/KeyIndex";
 import { IndexMap } from "./IndexMap";
+import { LeafNode } from "./LeafNode";
 import { NAME_COMPARATOR } from "./comparators";
+import "./indexes/Index";
 
 // TODO: For memory savings, don't store priorityNode_ if it's empty.
 
@@ -525,4 +528,12 @@ Object.defineProperties(NamedNode, {
   MAX: {
     value: new NamedNode(MAX_NAME, MAX_NODE)
   }
-});
+});
+
+/**
+ * Reference Extensions
+ */
+KeyIndex.__EMPTY_NODE = ChildrenNode.EMPTY_NODE;
+LeafNode.__childrenNodeConstructor = ChildrenNode;
+setMaxNode(MAX_NODE);
+setPriorityMaxNode(MAX_NODE);

src/database/core/snap/IndexMap.ts

@@ -4,7 +4,9 @@ import { contains, clone, map } from "../../../utils/obj";
 import { NamedNode } from "./Node";
 import { PRIORITY_INDEX } from "./indexes/PriorityIndex";
 import { KEY_INDEX } from "./indexes/KeyIndex";
-import { Fallback } from "./indexes/Index";
+let _defaultIndexMap;
+
+const fallbackObject = {};
 
 /**
  *
@@ -21,7 +23,14 @@ export class IndexMap {
    * @type {!IndexMap}
    * @const
    */
-  static Default = new IndexMap(Fallback, PRIORITY_INDEX);
+  static get Default() {
+    assert(fallbackObject && PRIORITY_INDEX, 'ChildrenNode.ts has not been loaded');
+    _defaultIndexMap = _defaultIndexMap || new IndexMap(
+      { '.priority': fallbackObject }, 
+      { '.priority': PRIORITY_INDEX }
+    );
+    return _defaultIndexMap;
+  }
 
   constructor(indexes, indexSet) {
     this.indexes_ = indexes;
@@ -36,7 +45,7 @@ export class IndexMap {
     var sortedMap = this.indexes_[indexKey];
     if (!sortedMap) throw new Error('No index defined for ' + indexKey);
 
-    if (sortedMap === Fallback) {
+    if (sortedMap === fallbackObject) {
       // The index exists, but it falls back to just name comparison. Return null so that the calling code uses the
       // regular child map
       return null;
@@ -74,7 +83,7 @@ export class IndexMap {
     if (sawIndexedValue) {
       newIndex = buildChildSet(childList, indexDefinition.getCompare());
     } else {
-      newIndex = Fallback;
+      newIndex = fallbackObject;
     }
     var indexName = indexDefinition.toString();
     var newIndexSet = clone(this.indexSet_);
@@ -96,7 +105,7 @@ export class IndexMap {
     var newIndexes = map(this.indexes_, function(indexedChildren, indexName) {
       var index = self.indexSet_[indexName];
       assert(index, 'Missing index implementation for ' + indexName);
-      if (indexedChildren === Fallback) {
+      if (indexedChildren === fallbackObject) {
         // Check to see if we need to index everything
         if (index.isDefinedOn(namedNode.node)) {
           // We need to build this index
@@ -113,7 +122,7 @@ export class IndexMap {
           return buildChildSet(childList, index.getCompare());
         } else {
           // No change, this remains a fallback
-          return Fallback;
+          return fallbackObject;
         }
       } else {
         var existingSnap = existingChildren.get(namedNode.name);
@@ -135,7 +144,7 @@ export class IndexMap {
    */
   removeFromIndexes(namedNode, existingChildren) {
     var newIndexes = map(this.indexes_, function(indexedChildren) {
-      if (indexedChildren === Fallback) {
+      if (indexedChildren === fallbackObject) {
         // This is the fallback. Just return it, nothing to do in this case
         return indexedChildren;
       } else {

src/database/core/snap/LeafNode.ts

@@ -7,16 +7,23 @@ import {
   priorityHashText,
   validatePriorityNode
 } from "./snap";
-import { ChildrenNode } from "./ChildrenNode";
 import { Node } from "./Node";
 
+let __childrenNodeConstructor;
 
 /**
  * LeafNode is a class for storing leaf nodes in a DataSnapshot.  It
  * implements Node and stores the value of the node (a string,
  * number, or boolean) accessible via getValue().
  */
 export class LeafNode implements Node {
+  static set __childrenNodeConstructor(val) {
+    __childrenNodeConstructor = val;
+  }
+  static get __childrenNodeConstructor() {
+    return __childrenNodeConstructor;
+  }
+
   value_;
   priorityNode_;
   lazyHash_;
@@ -41,7 +48,7 @@ export class LeafNode implements Node {
      * @const
      * @type {!Node}
      */
-    this.priorityNode_ = opt_priorityNode || ChildrenNode.EMPTY_NODE;
+    this.priorityNode_ = opt_priorityNode || LeafNode.__childrenNodeConstructor.EMPTY_NODE;
     validatePriorityNode(this.priorityNode_);
 
     this.lazyHash_ = null;
@@ -78,7 +85,7 @@ export class LeafNode implements Node {
     if (childName === '.priority') {
       return this.priorityNode_;
     } else {
-      return ChildrenNode.EMPTY_NODE;
+      return LeafNode.__childrenNodeConstructor.EMPTY_NODE;
     }
   }
 
@@ -89,7 +96,7 @@ export class LeafNode implements Node {
     } else if (path.getFront() === '.priority') {
       return this.priorityNode_;
     } else {
-      return ChildrenNode.EMPTY_NODE;
+      return LeafNode.__childrenNodeConstructor.EMPTY_NODE;
     }
   }
 
@@ -112,7 +119,7 @@ export class LeafNode implements Node {
     } else if (newChildNode.isEmpty() && childName !== '.priority') {
       return this;
     } else {
-      return ChildrenNode.EMPTY_NODE
+      return LeafNode.__childrenNodeConstructor.EMPTY_NODE
           .updateImmediateChild(childName, newChildNode)
           .updatePriority(this.priorityNode_);
     }
@@ -129,7 +136,7 @@ export class LeafNode implements Node {
       assert(front !== '.priority' || path.getLength() === 1,
           '.priority must be the last token in a path');
 
-      return this.updateImmediateChild(front, ChildrenNode.EMPTY_NODE.updateChild(path.popFront(), newChildNode));
+      return this.updateImmediateChild(front, LeafNode.__childrenNodeConstructor.EMPTY_NODE.updateChild(path.popFront(), newChildNode));
     }
   }
 
@@ -190,9 +197,9 @@ export class LeafNode implements Node {
    * @inheritDoc
    */
   compareTo(other) {
-    if (other === ChildrenNode.EMPTY_NODE) {
+    if (other === LeafNode.__childrenNodeConstructor.EMPTY_NODE) {
       return 1;
-    } else if (other instanceof ChildrenNode) {
+    } else if (other instanceof LeafNode.__childrenNodeConstructor) {
       return -1;
     } else {
       assert(other.isLeafNode(), 'Unknown node type');

src/database/core/snap/Node.ts

@@ -1,4 +1,4 @@
-import { Path } from "../util/path";
+import { Path } from "../util/Path";
 import { Index } from "./indexes/Index";
 
 /**

src/database/core/snap/indexes/Index.ts

@@ -6,11 +6,6 @@ import { MIN_NAME, MAX_NAME } from "../../util/util";
  * @constructor
  */
 export abstract class Index {
-  /**
-   * @typedef {!Object}
-   */
-  static FallbackType;
-
   /**
    * @param {!NamedNode} a
    * @param {!NamedNode} b
@@ -76,5 +71,3 @@ export abstract class Index {
    */
   abstract toString(): string;
 };
-
-export const Fallback = {};