Tree-shake ViewCache

Author: schmidt-sebastian

packages/database/src/core/SyncPoint.ts

@@ -18,7 +18,7 @@
 import { CacheNode } from './view/CacheNode';
 import { ChildrenNode } from './snap/ChildrenNode';
 import { assert } from '@firebase/util';
-import { ViewCache } from './view/ViewCache';
+import { newViewCache } from './view/ViewCache';
 import {
   View,
   viewAddEventRegistration,
@@ -140,7 +140,7 @@ export function syncPointGetView(
       eventCache = ChildrenNode.EMPTY_NODE;
       eventCacheComplete = false;
     }
-    const viewCache = new ViewCache(
+    const viewCache = newViewCache(
       new CacheNode(eventCache, eventCacheComplete, false),
       new CacheNode(serverCache, serverCacheComplete, false)
     );

packages/database/src/core/view/CompleteChildSource.ts

@@ -19,7 +19,7 @@ import { CacheNode } from './CacheNode';
 import { NamedNode, Node } from '../snap/Node';
 import { Index } from '../snap/indexes/Index';
 import { WriteTreeRef } from '../WriteTree';
-import { ViewCache } from './ViewCache';
+import { ViewCache, viewCacheGetCompleteServerSnap } from './ViewCache';
 
 /**
  * Since updates to filtered nodes might require nodes to be pulled in from "outside" the node, this interface
@@ -83,14 +83,14 @@ export class WriteTreeCompleteChildSource implements CompleteChildSource {
    * @inheritDoc
    */
   getCompleteChild(childKey: string): Node | null {
-    const node = this.viewCache_.getEventCache();
+    const node = this.viewCache_.eventCache;
     if (node.isCompleteForChild(childKey)) {
       return node.getNode().getImmediateChild(childKey);
     } else {
       const serverNode =
         this.optCompleteServerCache_ != null
           ? new CacheNode(this.optCompleteServerCache_, true, false)
-          : this.viewCache_.getServerCache();
+          : this.viewCache_.serverCache;
       return this.writes_.calcCompleteChild(childKey, serverNode);
     }
   }
@@ -106,7 +106,7 @@ export class WriteTreeCompleteChildSource implements CompleteChildSource {
     const completeServerData =
       this.optCompleteServerCache_ != null
         ? this.optCompleteServerCache_
-        : this.viewCache_.getCompleteServerSnap();
+        : viewCacheGetCompleteServerSnap(this.viewCache_);
     const nodes = this.writes_.calcIndexedSlice(
       completeServerData,
       child,

packages/database/src/core/view/View.ts

@@ -19,7 +19,12 @@ import { IndexedFilter } from './filter/IndexedFilter';
 import { ViewProcessor } from './ViewProcessor';
 import { ChildrenNode } from '../snap/ChildrenNode';
 import { CacheNode } from './CacheNode';
-import { ViewCache } from './ViewCache';
+import {
+  newViewCache,
+  ViewCache,
+  viewCacheGetCompleteEventSnap,
+  viewCacheGetCompleteServerSnap
+} from './ViewCache';
 import {
   EventGenerator,
   eventGeneratorGenerateEventsForChanges
@@ -59,8 +64,8 @@ export class View {
 
     this.processor_ = new ViewProcessor(filter);
 
-    const initialServerCache = initialViewCache.getServerCache();
-    const initialEventCache = initialViewCache.getEventCache();
+    const initialServerCache = initialViewCache.serverCache;
+    const initialEventCache = initialViewCache.eventCache;
 
     // Don't filter server node with other filter than index, wait for tagged listen
     const serverSnap = indexFilter.updateFullNode(
@@ -84,7 +89,7 @@ export class View {
       filter.filtersNodes()
     );
 
-    this.viewCache_ = new ViewCache(newEventCache, newServerCache);
+    this.viewCache_ = newViewCache(newEventCache, newServerCache);
     this.eventGenerator_ = new EventGenerator(this.query_);
   }
 
@@ -94,18 +99,18 @@ export class View {
 }
 
 export function viewGetServerCache(view: View): Node | null {
-  return view.viewCache_.getServerCache().getNode();
+  return view.viewCache_.serverCache.getNode();
 }
 
 export function viewGetCompleteNode(view: View): Node | null {
-  return view.viewCache_.getCompleteEventSnap();
+  return viewCacheGetCompleteEventSnap(view.viewCache_);
 }
 
 export function viewGetCompleteServerCache(
   view: View,
   path: Path
 ): Node | null {
-  const cache = view.viewCache_.getCompleteServerSnap();
+  const cache = viewCacheGetCompleteServerSnap(view.viewCache_);
   if (cache) {
     // If this isn't a "loadsAllData" view, then cache isn't actually a complete cache and
     // we need to see if it contains the child we're interested in.
@@ -189,11 +194,11 @@ export function viewApplyOperation(
     operation.source.queryId !== null
   ) {
     assert(
-      view.viewCache_.getCompleteServerSnap(),
+      viewCacheGetCompleteServerSnap(view.viewCache_),
       'We should always have a full cache before handling merges'
     );
     assert(
-      view.viewCache_.getCompleteEventSnap(),
+      viewCacheGetCompleteEventSnap(view.viewCache_),
       'Missing event cache, even though we have a server cache'
     );
   }
@@ -208,8 +213,8 @@ export function viewApplyOperation(
   view.processor_.assertIndexed(result.viewCache);
 
   assert(
-    result.viewCache.getServerCache().isFullyInitialized() ||
-      !oldViewCache.getServerCache().isFullyInitialized(),
+    result.viewCache.serverCache.isFullyInitialized() ||
+      !oldViewCache.serverCache.isFullyInitialized(),
     'Once a server snap is complete, it should never go back'
   );
 
@@ -218,7 +223,7 @@ export function viewApplyOperation(
   return viewGenerateEventsForChanges_(
     view,
     result.changes,
-    result.viewCache.getEventCache().getNode(),
+    result.viewCache.eventCache.getNode(),
     null
   );
 }
@@ -227,7 +232,7 @@ export function viewGetInitialEvents(
   view: View,
   registration: EventRegistration
 ): Event[] {
-  const eventSnap = view.viewCache_.getEventCache();
+  const eventSnap = view.viewCache_.eventCache;
   const initialChanges: Change[] = [];
   if (!eventSnap.getNode().isLeafNode()) {
     const eventNode = eventSnap.getNode() as ChildrenNode;

packages/database/src/core/view/ViewCache.ts

@@ -23,51 +23,54 @@ import { Node } from '../snap/Node';
  *
  * serverSnap is the cached server data, eventSnap is the cached event data (server data plus any local writes).
  */
-export class ViewCache {
-  constructor(
-    private readonly eventCache_: CacheNode,
-    private readonly serverCache_: CacheNode
-  ) {}
-
-  updateEventSnap(
-    eventSnap: Node,
-    complete: boolean,
-    filtered: boolean
-  ): ViewCache {
-    return new ViewCache(
-      new CacheNode(eventSnap, complete, filtered),
-      this.serverCache_
-    );
-  }
+export interface ViewCache {
+  readonly eventCache: CacheNode;
+  readonly serverCache: CacheNode;
+}
 
-  updateServerSnap(
-    serverSnap: Node,
-    complete: boolean,
-    filtered: boolean
-  ): ViewCache {
-    return new ViewCache(
-      this.eventCache_,
-      new CacheNode(serverSnap, complete, filtered)
-    );
-  }
+export function newViewCache(
+  eventCache: CacheNode,
+  serverCache: CacheNode
+): ViewCache {
+  return { eventCache, serverCache };
+}
 
-  getEventCache(): CacheNode {
-    return this.eventCache_;
-  }
+export function viewCacheUpdateEventSnap(
+  viewCache: ViewCache,
+  eventSnap: Node,
+  complete: boolean,
+  filtered: boolean
+): ViewCache {
+  return newViewCache(
+    new CacheNode(eventSnap, complete, filtered),
+    viewCache.serverCache
+  );
+}
 
-  getCompleteEventSnap(): Node | null {
-    return this.eventCache_.isFullyInitialized()
-      ? this.eventCache_.getNode()
-      : null;
-  }
+export function viewCacheUpdateServerSnap(
+  viewCache: ViewCache,
+  serverSnap: Node,
+  complete: boolean,
+  filtered: boolean
+): ViewCache {
+  return newViewCache(
+    viewCache.eventCache,
+    new CacheNode(serverSnap, complete, filtered)
+  );
+}
 
-  getServerCache(): CacheNode {
-    return this.serverCache_;
-  }
+export function viewCacheGetCompleteEventSnap(
+  viewCache: ViewCache
+): Node | null {
+  return viewCache.eventCache.isFullyInitialized()
+    ? viewCache.eventCache.getNode()
+    : null;
+}
 
-  getCompleteServerSnap(): Node | null {
-    return this.serverCache_.isFullyInitialized()
-      ? this.serverCache_.getNode()
-      : null;
-  }
+export function viewCacheGetCompleteServerSnap(
+  viewCache: ViewCache
+): Node | null {
+  return viewCache.serverCache.isFullyInitialized()
+    ? viewCache.serverCache.getNode()
+    : null;
 }