refactor(database): several classes and utility methods

Author: jsayol

src/database/api/TransactionResult.ts

@@ -1,19 +1,13 @@
+import { DataSnapshot } from './DataSnapshot';
+
 export class TransactionResult {
   /**
    * A type for the resolve value of Firebase.transaction.
    * @constructor
    * @dict
    * @param {boolean} committed
-   * @param {fb.api.DataSnapshot} snapshot
+   * @param {DataSnapshot} snapshot
    */
-  constructor(committed, snapshot) {
-    /**
-    * @type {boolean}
-    */
-    this['committed'] = committed;
-    /**
-    * @type {fb.api.DataSnapshot}
-    */
-    this['snapshot'] = snapshot;
+  constructor(public committed: boolean, public snapshot: DataSnapshot) {
   }
 }

src/database/api/test_access.ts

@@ -2,22 +2,23 @@ import { RepoInfo } from "../core/RepoInfo";
 import { PersistentConnection } from "../core/PersistentConnection";
 import { RepoManager } from "../core/RepoManager";
 import { Connection } from "../realtime/Connection";
+import { Query } from './Query';
 
 export const DataConnection = PersistentConnection;
 
 /**
  * @param {!string} pathString
  * @param {function(*)} onComplete
  */
-(PersistentConnection.prototype as any).simpleListen = function(pathString, onComplete) {
+(PersistentConnection.prototype as any).simpleListen = function(pathString: string, onComplete: (a: any) => any) {
   this.sendRequest('q', {'p': pathString}, onComplete);
 };
 
 /**
  * @param {*} data
  * @param {function(*)} onEcho
  */
-(PersistentConnection.prototype as any).echo = function(data, onEcho) {
+(PersistentConnection.prototype as any).echo = function(data: any, onEcho: (a: any) => any) {
   this.sendRequest('echo', {'d': data}, onEcho);
 };
 
@@ -28,8 +29,8 @@ export const RealTimeConnection = Connection;
  * @param {function(): string} newHash
  * @return {function()}
  */
-export const hijackHash = function(newHash) {
-  var oldPut = PersistentConnection.prototype.put;
+export const hijackHash = function(newHash: () => string) {
+  const oldPut = PersistentConnection.prototype.put;
   PersistentConnection.prototype.put = function(pathString, data, opt_onComplete, opt_hash) {
     if (opt_hash !== undefined) {
       opt_hash = newHash();
@@ -42,23 +43,23 @@ export const hijackHash = function(newHash) {
 };
 
 /**
- * @type {function(new:fb.core.RepoInfo, !string, boolean, !string, boolean): undefined}
+ * @type {function(new:RepoInfo, !string, boolean, !string, boolean): undefined}
  */
 export const ConnectionTarget = RepoInfo;
 
 /**
- * @param {!fb.api.Query} query
+ * @param {!Query} query
  * @return {!string}
  */
-export const queryIdentifier = function(query) {
+export const queryIdentifier = function(query: Query) {
   return query.queryIdentifier();
 };
 
 /**
- * @param {!fb.api.Query} firebaseRef
+ * @param {!Query} firebaseRef
  * @return {!Object}
  */
-export const listens = function(firebaseRef) {
+export const listens = function(firebaseRef: Query) {
   return firebaseRef.repo.persistentConnection_.listens_;
 };
 
@@ -67,6 +68,6 @@ export const listens = function(firebaseRef) {
  *
  * @param {boolean} forceRestClient
  */
-export const forceRestClient = function(forceRestClient) {
+export const forceRestClient = function(forceRestClient: boolean) {
   RepoManager.getInstance().forceRestClient(forceRestClient);
 };

src/database/core/CompoundWrite.ts

@@ -4,6 +4,7 @@ import { forEach } from "../../utils/obj";
 import { Node, NamedNode } from "./snap/Node";
 import { PRIORITY_INDEX } from "./snap/indexes/PriorityIndex";
 import { assert } from "../../utils/assert";
+import { ChildrenNode } from './snap/ChildrenNode';
 
 /**
  * This class holds a collection of writes that can be applied to nodes in unison. It abstracts away the logic with
@@ -20,7 +21,7 @@ export class CompoundWrite {
    * @type {!CompoundWrite}
    */
   static Empty = new CompoundWrite(new ImmutableTree(null));
-  
+
   /**
    * @param {!Path} path
    * @param {!Node} node
@@ -30,33 +31,33 @@ export class CompoundWrite {
     if (path.isEmpty()) {
       return new CompoundWrite(new ImmutableTree(node));
     } else {
-      var rootmost = this.writeTree_.findRootMostValueAndPath(path);
+      const rootmost = this.writeTree_.findRootMostValueAndPath(path);
       if (rootmost != null) {
-        var rootMostPath = rootmost.path
-        var value = rootmost.value;
-        var relativePath = Path.relativePath(rootMostPath, path);
+        const rootMostPath = rootmost.path;
+        let value = rootmost.value;
+        const relativePath = Path.relativePath(rootMostPath, path);
         value = value.updateChild(relativePath, node);
         return new CompoundWrite(this.writeTree_.set(rootMostPath, value));
       } else {
-        var subtree = new ImmutableTree(node);
-        var newWriteTree = this.writeTree_.setTree(path, subtree);
+        const subtree = new ImmutableTree(node);
+        const newWriteTree = this.writeTree_.setTree(path, subtree);
         return new CompoundWrite(newWriteTree);
       }
     }
-  };
+  }
 
   /**
    * @param {!Path} path
    * @param {!Object.<string, !Node>} updates
    * @return {!CompoundWrite}
    */
   addWrites(path: Path, updates: { [name: string]: Node }): CompoundWrite {
-    var newWrite = <CompoundWrite>this;
+    let newWrite = <CompoundWrite>this;
     forEach(updates, function(childKey, node) {
       newWrite = newWrite.addWrite(path.child(childKey), node);
     });
     return newWrite;
-  };
+  }
 
   /**
    * Will remove a write at the given path and deeper paths. This will <em>not</em> modify a write at a higher
@@ -69,10 +70,10 @@ export class CompoundWrite {
     if (path.isEmpty()) {
       return CompoundWrite.Empty;
     } else {
-      var newWriteTree = this.writeTree_.setTree(path, ImmutableTree.Empty);
+      const newWriteTree = this.writeTree_.setTree(path, ImmutableTree.Empty);
       return new CompoundWrite(newWriteTree);
     }
-  };
+  }
 
   /**
    * Returns whether this CompoundWrite will fully overwrite a node at a given location and can therefore be
@@ -83,7 +84,7 @@ export class CompoundWrite {
    */
   hasCompleteWrite(path: Path): boolean {
     return this.getCompleteNode(path) != null;
-  };
+  }
 
   /**
    * Returns a node for a path if and only if the node is a "complete" overwrite at that path. This will not aggregate
@@ -93,26 +94,26 @@ export class CompoundWrite {
    * @return {?Node} The node if complete at that path, or null otherwise.
    */
   getCompleteNode(path: Path): Node {
-    var rootmost = this.writeTree_.findRootMostValueAndPath(path);
+    const rootmost = this.writeTree_.findRootMostValueAndPath(path);
     if (rootmost != null) {
       return this.writeTree_.get(rootmost.path).getChild(Path.relativePath(rootmost.path, path));
     } else {
       return null;
     }
-  };
+  }
 
   /**
    * Returns all children that are guaranteed to be a complete overwrite.
    *
    * @return {!Array.<NamedNode>} A list of all complete children.
    */
   getCompleteChildren(): Array<NamedNode> {
-    var children = [];
-    var node = this.writeTree_.value;
+    const children = [];
+    let node = this.writeTree_.value;
     if (node != null) {
       // If it's a leaf node, it has no children; so nothing to do.
       if (!node.isLeafNode()) {
-        node = /** @type {!ChildrenNode} */ (node);
+        node = <ChildrenNode>node;
         node.forEachChild(PRIORITY_INDEX, function(childName, childNode) {
           children.push(new NamedNode(childName, childNode));
         });
@@ -125,42 +126,42 @@ export class CompoundWrite {
       });
     }
     return children;
-  };
+  }
 
   /**
    * @param {!Path} path
    * @return {!CompoundWrite}
    */
-  childCompoundWrite(path: Path) {
+  childCompoundWrite(path: Path): CompoundWrite {
     if (path.isEmpty()) {
       return this;
     } else {
-      var shadowingNode = this.getCompleteNode(path);
+      const shadowingNode = this.getCompleteNode(path);
       if (shadowingNode != null) {
         return new CompoundWrite(new ImmutableTree(shadowingNode));
       } else {
         return new CompoundWrite(this.writeTree_.subtree(path));
       }
     }
-  };
+  }
 
   /**
    * Returns true if this CompoundWrite is empty and therefore does not modify any nodes.
    * @return {boolean} Whether this CompoundWrite is empty
    */
-  isEmpty() {
+  isEmpty(): boolean {
     return this.writeTree_.isEmpty();
-  };
+  }
 
   /**
    * Applies this CompoundWrite to a node. The node is returned with all writes from this CompoundWrite applied to the
    * node
    * @param {!Node} node The node to apply this CompoundWrite to
    * @return {!Node} The node with all writes applied
    */
-  apply(node: Node) {
+  apply(node: Node): Node {
     return CompoundWrite.applySubtreeWrite_(Path.Empty, this.writeTree_, node);
-  };
+  }
 
   /**
    * @param {!Path} relativePath
@@ -169,12 +170,12 @@ export class CompoundWrite {
    * @return {!Node}
    * @private
    */
-  static applySubtreeWrite_ = function(relativePath: Path, writeTree: ImmutableTree, node: Node) {
+  private static applySubtreeWrite_ = function(relativePath: Path, writeTree: ImmutableTree, node: Node): Node {
     if (writeTree.value != null) {
       // Since there a write is always a leaf, we're done here
       return node.updateChild(relativePath, writeTree.value);
     } else {
-      var priorityWrite = null;
+      let priorityWrite = null;
       writeTree.children.inorderTraversal(function(childKey, childTree) {
         if (childKey === '.priority') {
           // Apply priorities at the end so we don't update priorities for either empty nodes or forget
@@ -191,6 +192,6 @@ export class CompoundWrite {
       }
       return node;
     }
-  };
+  }
 }