Remove static member variables (#4433)

schmidt-sebastian · web-flow · commit 39562034a34a · 2021-02-09T12:34:26.000-07:00
diff --git a/packages/database/src/api/Reference.ts b/packages/database/src/api/Reference.ts
@@ -24,15 +24,15 @@ import { Repo } from '../core/Repo';
 import { Path } from '../core/util/Path';
 import { QueryParams } from '../core/view/QueryParams';
 import {
-  validateRootPathString,
-  validatePathString,
-  validateFirebaseMergeDataArg,
   validateBoolean,
-  validatePriority,
   validateFirebaseDataArg,
+  validateFirebaseMergeDataArg,
+  validatePathString,
+  validatePriority,
+  validateRootPathString,
   validateWritablePath
 } from '../core/util/validation';
-import { validateArgCount, validateCallback, Deferred } from '@firebase/util';
+import { Deferred, validateArgCount, validateCallback } from '@firebase/util';
 
 import { SyncPoint } from '../core/SyncPoint';
 import { Database } from './Database';
@@ -61,7 +61,7 @@ export class Reference extends Query {
     }
 
     // call Query's constructor, passing in the repo and path.
-    super(repo, path, QueryParams.DEFAULT, false);
+    super(repo, path, new QueryParams(), false);
   }
 
   /** @return {?string} */
diff --git a/packages/database/src/core/CompoundWrite.ts b/packages/database/src/core/CompoundWrite.ts
@@ -17,7 +17,7 @@
 
 import { ImmutableTree } from './util/ImmutableTree';
 import { Path } from './util/Path';
-import { Node, NamedNode } from './snap/Node';
+import { NamedNode, Node } from './snap/Node';
 import { PRIORITY_INDEX } from './snap/indexes/PriorityIndex';
 import { assert } from '@firebase/util';
 import { ChildrenNode } from './snap/ChildrenNode';
@@ -32,7 +32,9 @@ import { each } from './util/util';
 export class CompoundWrite {
   constructor(private writeTree_: ImmutableTree<Node>) {}
 
-  static Empty = new CompoundWrite(new ImmutableTree(null));
+  static empty(): CompoundWrite {
+    return new CompoundWrite(new ImmutableTree(null));
+  }
 
   addWrite(path: Path, node: Node): CompoundWrite {
     if (path.isEmpty()) {
@@ -70,9 +72,12 @@ export class CompoundWrite {
    */
   removeWrite(path: Path): CompoundWrite {
     if (path.isEmpty()) {
-      return CompoundWrite.Empty;
+      return CompoundWrite.empty();
     } else {
-      const newWriteTree = this.writeTree_.setTree(path, ImmutableTree.Empty);
+      const newWriteTree = this.writeTree_.setTree(
+        path,
+        new ImmutableTree<Node>(null)
+      );
       return new CompoundWrite(newWriteTree);
     }
   }
diff --git a/packages/database/src/core/SyncTree.ts b/packages/database/src/core/SyncTree.ts
@@ -16,7 +16,7 @@
  */
 
 import { assert } from '@firebase/util';
-import { errorForServerCode, each } from './util/util';
+import { each, errorForServerCode } from './util/util';
 import { AckUserWrite } from './operation/AckUserWrite';
 import { ChildrenNode } from './snap/ChildrenNode';
 import { ImmutableTree } from './util/ImmutableTree';
@@ -81,7 +81,9 @@ export class SyncTree {
   /**
    * Tree of SyncPoints.  There's a SyncPoint at any location that has 1 or more views.
    */
-  private syncPointTree_: ImmutableTree<SyncPoint> = ImmutableTree.Empty;
+  private syncPointTree_: ImmutableTree<SyncPoint> = new ImmutableTree<SyncPoint>(
+    null
+  );
 
   /**
    * A tree of all pending user writes (user-initiated set()'s, transaction()'s, update()'s, etc.).
@@ -115,7 +117,7 @@ export class SyncTree {
       return [];
     } else {
       return this.applyOperationToSyncPoints_(
-        new Overwrite(OperationSource.User, path, newData)
+        new Overwrite(OperationSource.user(), path, newData)
       );
     }
   }
@@ -136,7 +138,7 @@ export class SyncTree {
     const changeTree = ImmutableTree.fromObject(changedChildren);
 
     return this.applyOperationToSyncPoints_(
-      new Merge(OperationSource.User, path, changeTree)
+      new Merge(OperationSource.user(), path, changeTree)
     );
   }
 
@@ -152,13 +154,13 @@ export class SyncTree {
     if (!needToReevaluate) {
       return [];
     } else {
-      let affectedTree = ImmutableTree.Empty;
+      let affectedTree = new ImmutableTree<boolean>(null);
       if (write.snap != null) {
         // overwrite
         affectedTree = affectedTree.set(Path.Empty, true);
       } else {
-        each(write.children, (pathString: string, node: Node) => {
-          affectedTree = affectedTree.set(new Path(pathString), node);
+        each(write.children, (pathString: string) => {
+          affectedTree = affectedTree.set(new Path(pathString), true);
         });
       }
       return this.applyOperationToSyncPoints_(
@@ -174,7 +176,7 @@ export class SyncTree {
    */
   applyServerOverwrite(path: Path, newData: Node): Event[] {
     return this.applyOperationToSyncPoints_(
-      new Overwrite(OperationSource.Server, path, newData)
+      new Overwrite(OperationSource.server(), path, newData)
     );
   }
 
@@ -190,7 +192,7 @@ export class SyncTree {
     const changeTree = ImmutableTree.fromObject(changedChildren);
 
     return this.applyOperationToSyncPoints_(
-      new Merge(OperationSource.Server, path, changeTree)
+      new Merge(OperationSource.server(), path, changeTree)
     );
   }
 
@@ -201,7 +203,7 @@ export class SyncTree {
    */
   applyListenComplete(path: Path): Event[] {
     return this.applyOperationToSyncPoints_(
-      new ListenComplete(OperationSource.Server, path)
+      new ListenComplete(OperationSource.server(), path)
     );
   }
 
diff --git a/packages/database/src/core/WriteTree.ts b/packages/database/src/core/WriteTree.ts
@@ -48,7 +48,7 @@ export class WriteTree {
    * A tree tracking the result of applying all visible writes.  This does not include transactions with
    * applyLocally=false or writes that are completely shadowed by other writes.
    */
-  private visibleWrites_: CompoundWrite = CompoundWrite.Empty;
+  private visibleWrites_: CompoundWrite = CompoundWrite.empty();
 
   /**
    * A list of all pending writes, regardless of visibility and shadowed-ness.  Used to calculate arbitrary
@@ -497,7 +497,7 @@ export class WriteTree {
     filter: (w: WriteRecord) => boolean,
     treeRoot: Path
   ): CompoundWrite {
-    let compoundWrite = CompoundWrite.Empty;
+    let compoundWrite = CompoundWrite.empty();
     for (let i = 0; i < writes.length; ++i) {
       const write = writes[i];
       // Theory, a later set will either:
diff --git a/packages/database/src/core/operation/AckUserWrite.ts b/packages/database/src/core/operation/AckUserWrite.ts
@@ -25,7 +25,7 @@ export class AckUserWrite implements Operation {
   type = OperationType.ACK_USER_WRITE;
 
   /** @inheritDoc */
-  source = OperationSource.User;
+  source = OperationSource.user();
 
   /**
    * @param affectedTree A tree containing true for each affected path. Affected paths can't overlap.
diff --git a/packages/database/src/core/operation/Operation.ts b/packages/database/src/core/operation/Operation.ts
@@ -52,19 +52,23 @@ export class OperationSource {
     assert(!tagged || fromServer, 'Tagged queries must be from server.');
   }
 
-  static User = new OperationSource(
-    /*fromUser=*/ true,
-    false,
-    null,
-    /*tagged=*/ false
-  );
+  static user() {
+    return new OperationSource(
+      /*fromUser=*/ true,
+      false,
+      null,
+      /*tagged=*/ false
+    );
+  }
 
-  static Server = new OperationSource(
-    false,
-    /*fromServer=*/ true,
-    null,
-    /*tagged=*/ false
-  );
+  static server() {
+    return new OperationSource(
+      false,
+      /*fromServer=*/ true,
+      null,
+      /*tagged=*/ false
+    );
+  }
 
   static forServerTaggedQuery = function (queryId: string): OperationSource {
     return new OperationSource(
diff --git a/packages/database/src/core/util/ImmutableTree.ts b/packages/database/src/core/util/ImmutableTree.ts
@@ -17,7 +17,7 @@
 
 import { SortedMap } from './SortedMap';
 import { Path } from './Path';
-import { stringCompare, each } from './util';
+import { each, stringCompare } from './util';
 
 let emptyChildrenSingleton: SortedMap<string, ImmutableTree<null>>;
 
@@ -38,11 +38,8 @@ const EmptyChildren = (): SortedMap<string, ImmutableTree<null>> => {
  * A tree with immutable elements.
  */
 export class ImmutableTree<T> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static Empty = new ImmutableTree<any>(null);
-
   static fromObject<T>(obj: { [k: string]: T }): ImmutableTree<T> {
-    let tree: ImmutableTree<T> = ImmutableTree.Empty;
+    let tree: ImmutableTree<T> = new ImmutableTree<T>(null);
     each(obj, (childPath: string, childSnap: T) => {
       tree = tree.set(new Path(childPath), childSnap);
     });
@@ -128,7 +125,7 @@ export class ImmutableTree<T> {
       if (childTree !== null) {
         return childTree.subtree(relativePath.popFront());
       } else {
-        return ImmutableTree.Empty;
+        return new ImmutableTree<T>(null);
       }
     }
   }
@@ -145,7 +142,7 @@ export class ImmutableTree<T> {
       return new ImmutableTree(toSet, this.children);
     } else {
       const front = relativePath.getFront();
-      const child = this.children.get(front) || ImmutableTree.Empty;
+      const child = this.children.get(front) || new ImmutableTree<T>(null);
       const newChild = child.set(relativePath.popFront(), toSet);
       const newChildren = this.children.insert(front, newChild);
       return new ImmutableTree(this.value, newChildren);
@@ -161,7 +158,7 @@ export class ImmutableTree<T> {
   remove(relativePath: Path): ImmutableTree<T> {
     if (relativePath.isEmpty()) {
       if (this.children.isEmpty()) {
-        return ImmutableTree.Empty;
+        return new ImmutableTree<T>(null);
       } else {
         return new ImmutableTree(null, this.children);
       }
@@ -177,7 +174,7 @@ export class ImmutableTree<T> {
           newChildren = this.children.insert(front, newChild);
         }
         if (this.value === null && newChildren.isEmpty()) {
-          return ImmutableTree.Empty;
+          return new ImmutableTree<T>(null);
         } else {
           return new ImmutableTree(this.value, newChildren);
         }
@@ -219,7 +216,7 @@ export class ImmutableTree<T> {
       return newTree;
     } else {
       const front = relativePath.getFront();
-      const child = this.children.get(front) || ImmutableTree.Empty;
+      const child = this.children.get(front) || new ImmutableTree<T>(null);
       const newChild = child.setTree(relativePath.popFront(), newTree);
       let newChildren;
       if (newChild.isEmpty()) {
@@ -317,7 +314,7 @@ export class ImmutableTree<T> {
           f
         );
       } else {
-        return ImmutableTree.Empty;
+        return new ImmutableTree<T>(null);
       }
     }
   }
diff --git a/packages/database/src/core/view/QueryParams.ts b/packages/database/src/core/view/QueryParams.ts
@@ -80,11 +80,6 @@ export class QueryParams {
     LIMIT_TO_LAST: 'limitToLast'
   };
 
-  /**
-   * Default, empty query parameters
-   */
-  static readonly DEFAULT = new QueryParams();
-
   hasStart(): boolean {
     return this.startSet_;
   }
diff --git a/packages/database/src/core/view/ViewCache.ts b/packages/database/src/core/view/ViewCache.ts
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 
-import { ChildrenNode } from '../snap/ChildrenNode';
 import { CacheNode } from './CacheNode';
 import { Node } from '../snap/Node';
 
@@ -30,19 +29,6 @@ export class ViewCache {
     private readonly serverCache_: CacheNode
   ) {}
 
-  static Empty = new ViewCache(
-    new CacheNode(
-      ChildrenNode.EMPTY_NODE,
-      /*fullyInitialized=*/ false,
-      /*filtered=*/ false
-    ),
-    new CacheNode(
-      ChildrenNode.EMPTY_NODE,
-      /*fullyInitialized=*/ false,
-      /*filtered=*/ false
-    )
-  );
-
   updateEventSnap(
     eventSnap: Node,
     complete: boolean,
diff --git a/packages/database/src/core/view/ViewProcessor.ts b/packages/database/src/core/view/ViewProcessor.ts
@@ -551,7 +551,10 @@ export class ViewProcessor {
     if (path.isEmpty()) {
       viewMergeTree = changedChildren;
     } else {
-      viewMergeTree = ImmutableTree.Empty.setTree(path, changedChildren);
+      viewMergeTree = new ImmutableTree<Node>(null).setTree(
+        path,
+        changedChildren
+      );
     }
     const serverNode = viewCache.getServerCache().getNode();
     viewMergeTree.children.inorderTraversal((childKey, childTree) => {
@@ -633,7 +636,7 @@ export class ViewProcessor {
       } else if (ackPath.isEmpty()) {
         // This is a goofy edge case where we are acking data at this location but don't have full data.  We
         // should just re-apply whatever we have in our cache as a merge.
-        let changedChildren = ImmutableTree.Empty;
+        let changedChildren = new ImmutableTree<Node>(null);
         serverCache.getNode().forEachChild(KEY_INDEX, (name, node) => {
           changedChildren = changedChildren.set(new Path(name), node);
         });
@@ -651,7 +654,7 @@ export class ViewProcessor {
       }
     } else {
       // This is a merge.
-      let changedChildren = ImmutableTree.Empty;
+      let changedChildren = new ImmutableTree<Node>(null);
       affectedTree.foreach((mergePath, value) => {
         const serverCachePath = ackPath.child(mergePath);
         if (serverCache.isCompleteForPath(serverCachePath)) {
diff --git a/packages/database/test/compound_write.test.ts b/packages/database/test/compound_write.test.ts
