Tree-Shake EventQueue (#4462)

schmidt-sebastian · web-flow · commit 47e035fe0068 · 2021-02-12T11:18:35.000-07:00
diff --git a/packages/database/src/core/Repo.ts b/packages/database/src/core/Repo.ts
@@ -26,27 +26,32 @@ import { SparseSnapshotTree } from './SparseSnapshotTree';
 import { SyncTree } from './SyncTree';
 import { SnapshotHolder } from './SnapshotHolder';
 import {
-  stringify,
-  map,
-  isEmpty,
   assert,
   contains,
-  safeGet
+  isEmpty,
+  map,
+  safeGet,
+  stringify
 } from '@firebase/util';
 import {
   beingCrawled,
   each,
   exceptionGuard,
-  warn,
   log,
-  LUIDGenerator
+  LUIDGenerator,
+  warn
 } from './util/util';
 
 import { AuthTokenProvider } from './AuthTokenProvider';
 import { StatsManager } from './stats/StatsManager';
 import { StatsReporter } from './stats/StatsReporter';
 import { StatsListener } from './stats/StatsListener';
-import { EventQueue } from './view/EventQueue';
+import {
+  EventQueue,
+  eventQueueQueueEvents,
+  eventQueueRaiseEventsAtPath,
+  eventQueueRaiseEventsForChangedPath
+} from './view/EventQueue';
 import { PersistentConnection } from './PersistentConnection';
 import { ReadonlyRestClient } from './ReadonlyRestClient';
 import { RepoInfo } from './RepoInfo';
@@ -234,7 +239,11 @@ export class Repo {
       startListening: (query, tag, currentHashFn, onComplete) => {
         this.server_.listen(query, currentHashFn, tag, (status, data) => {
           const events = onComplete(status, data);
-          this.eventQueue_.raiseEventsForChangedPath(query.path, events);
+          eventQueueRaiseEventsForChangedPath(
+            this.eventQueue_,
+            query.path,
+            events
+          );
         });
         // No synchronous events for network-backed sync trees
         return [];
@@ -332,7 +341,7 @@ export class Repo {
       // is a proxy for some change having occurred.
       affectedPath = this.rerunTransactions_(path);
     }
-    this.eventQueue_.raiseEventsForChangedPath(affectedPath, events);
+    eventQueueRaiseEventsForChangedPath(this.eventQueue_, affectedPath, events);
   }
 
   // TODO: This should be @private but it's used by test_access.js and internal.js
@@ -358,7 +367,7 @@ export class Repo {
     const newNode = nodeFromJSON(value);
     this.infoData_.updateSnapshot(path, newNode);
     const events = this.infoSyncTree_.applyServerOverwrite(path, newNode);
-    this.eventQueue_.raiseEventsForChangedPath(path, events);
+    eventQueueRaiseEventsForChangedPath(this.eventQueue_, path, events);
   }
 
   private getNextWriteId_(): number {
@@ -399,7 +408,7 @@ export class Repo {
           query.path,
           node
         );
-        this.eventQueue_.raiseEventsAtPath(query.path, events);
+        eventQueueRaiseEventsAtPath(this.eventQueue_, query.path, events);
         return Promise.resolve(
           new DataSnapshot(
             node,
@@ -445,7 +454,7 @@ export class Repo {
       writeId,
       true
     );
-    this.eventQueue_.queueEvents(events);
+    eventQueueQueueEvents(this.eventQueue_, events);
     this.server_.put(
       path.toString(),
       newNodeUnresolved.val(/*export=*/ true),
@@ -459,14 +468,18 @@ export class Repo {
           writeId,
           !success
         );
-        this.eventQueue_.raiseEventsForChangedPath(path, clearEvents);
+        eventQueueRaiseEventsForChangedPath(
+          this.eventQueue_,
+          path,
+          clearEvents
+        );
         this.callOnCompleteCallback(onComplete, status, errorReason);
       }
     );
     const affectedPath = this.abortTransactions_(path);
     this.rerunTransactions_(affectedPath);
     // We queued the events above, so just flush the queue here
-    this.eventQueue_.raiseEventsForChangedPath(affectedPath, []);
+    eventQueueRaiseEventsForChangedPath(this.eventQueue_, affectedPath, []);
   }
 
   update(
@@ -497,7 +510,7 @@ export class Repo {
         changedChildren,
         writeId
       );
-      this.eventQueue_.queueEvents(events);
+      eventQueueQueueEvents(this.eventQueue_, events);
       this.server_.merge(
         path.toString(),
         childrenToMerge,
@@ -513,7 +526,11 @@ export class Repo {
           );
           const affectedPath =
             clearEvents.length > 0 ? this.rerunTransactions_(path) : path;
-          this.eventQueue_.raiseEventsForChangedPath(affectedPath, clearEvents);
+          eventQueueRaiseEventsForChangedPath(
+            this.eventQueue_,
+            affectedPath,
+            clearEvents
+          );
           this.callOnCompleteCallback(onComplete, status, errorReason);
         }
       );
@@ -524,7 +541,7 @@ export class Repo {
       });
 
       // We queued the events above, so just flush the queue here
-      this.eventQueue_.raiseEventsForChangedPath(path, []);
+      eventQueueRaiseEventsForChangedPath(this.eventQueue_, path, []);
     } else {
       log("update() called with empty data.  Don't do anything.");
       this.callOnCompleteCallback(onComplete, 'ok');
@@ -559,7 +576,7 @@ export class Repo {
     });
 
     this.onDisconnect_ = new SparseSnapshotTree();
-    this.eventQueue_.raiseEventsForChangedPath(Path.Empty, events);
+    eventQueueRaiseEventsForChangedPath(this.eventQueue_, Path.Empty, events);
   }
 
   onDisconnectCancel(
@@ -652,7 +669,7 @@ export class Repo {
         eventRegistration
       );
     }
-    this.eventQueue_.raiseEventsAtPath(query.path, events);
+    eventQueueRaiseEventsAtPath(this.eventQueue_, query.path, events);
   }
 
   removeEventCallbackForQuery(
@@ -673,7 +690,7 @@ export class Repo {
         eventRegistration
       );
     }
-    this.eventQueue_.raiseEventsAtPath(query.path, events);
+    eventQueueRaiseEventsAtPath(this.eventQueue_, query.path, events);
   }
 
   interrupt() {
@@ -885,7 +902,7 @@ export class Repo {
         transaction.currentWriteId,
         transaction.applyLocally
       );
-      this.eventQueue_.raiseEventsForChangedPath(path, events);
+      eventQueueRaiseEventsForChangedPath(this.eventQueue_, path, events);
 
       this.sendReadyTransactions_();
     }
@@ -1013,7 +1030,7 @@ export class Repo {
           // There may be pending transactions that we can now send.
           this.sendReadyTransactions_();
 
-          this.eventQueue_.raiseEventsForChangedPath(path, events);
+          eventQueueRaiseEventsForChangedPath(this.eventQueue_, path, events);
 
           // Finally, trigger onComplete callbacks.
           for (let i = 0; i < callbacks.length; i++) {
@@ -1178,7 +1195,7 @@ export class Repo {
           }
         }
       }
-      this.eventQueue_.raiseEventsForChangedPath(path, events);
+      eventQueueRaiseEventsForChangedPath(this.eventQueue_, path, events);
       events = [];
       if (abortTransaction) {
         // Abort.
@@ -1392,7 +1409,11 @@ export class Repo {
       }
 
       // Now fire the callbacks.
-      this.eventQueue_.raiseEventsForChangedPath(node.path(), events);
+      eventQueueRaiseEventsForChangedPath(
+        this.eventQueue_,
+        node.path(),
+        events
+      );
       for (let i = 0; i < callbacks.length; i++) {
         exceptionGuard(callbacks[i]);
       }
diff --git a/packages/database/src/core/view/EventQueue.ts b/packages/database/src/core/view/EventQueue.ts
@@ -33,96 +33,109 @@ import { Event } from './Event';
  *
  */
 export class EventQueue {
-  private eventLists_: EventList[] = [];
+  eventLists_: EventList[] = [];
 
   /**
    * Tracks recursion depth of raiseQueuedEvents_, for debugging purposes.
    */
-  private recursionDepth_ = 0;
-
-  /**
-   * @param eventDataList The new events to queue.
-   */
-  queueEvents(eventDataList: Event[]) {
-    // We group events by path, storing them in a single EventList, to make it easier to skip over them quickly.
-    let currList: EventList | null = null;
-    for (let i = 0; i < eventDataList.length; i++) {
-      const data = eventDataList[i];
-      const path = data.getPath();
-      if (currList !== null && !path.equals(currList.path)) {
-        this.eventLists_.push(currList);
-        currList = null;
-      }
-
-      if (currList === null) {
-        currList = { events: [], path };
-      }
+  recursionDepth_ = 0;
+}
 
-      currList.events.push(data);
+/**
+ * @param eventDataList The new events to queue.
+ */
+export function eventQueueQueueEvents(
+  eventQueue: EventQueue,
+  eventDataList: Event[]
+) {
+  // We group events by path, storing them in a single EventList, to make it easier to skip over them quickly.
+  let currList: EventList | null = null;
+  for (let i = 0; i < eventDataList.length; i++) {
+    const data = eventDataList[i];
+    const path = data.getPath();
+    if (currList !== null && !path.equals(currList.path)) {
+      eventQueue.eventLists_.push(currList);
+      currList = null;
     }
-    if (currList) {
-      this.eventLists_.push(currList);
+
+    if (currList === null) {
+      currList = { events: [], path };
     }
-  }
 
-  /**
-   * Queues the specified events and synchronously raises all events (including previously queued ones)
-   * for the specified path.
-   *
-   * It is assumed that the new events are all for the specified path.
-   *
-   * @param path The path to raise events for.
-   * @param eventDataList The new events to raise.
-   */
-  raiseEventsAtPath(path: Path, eventDataList: Event[]) {
-    this.queueEvents(eventDataList);
-    this.raiseQueuedEventsMatchingPredicate_((eventPath: Path) =>
-      eventPath.equals(path)
-    );
+    currList.events.push(data);
+  }
+  if (currList) {
+    eventQueue.eventLists_.push(currList);
   }
+}
 
-  /**
-   * Queues the specified events and synchronously raises all events (including previously queued ones) for
-   * locations related to the specified change path (i.e. all ancestors and descendants).
-   *
-   * It is assumed that the new events are all related (ancestor or descendant) to the specified path.
-   *
-   * @param changedPath The path to raise events for.
-   * @param eventDataList The events to raise
-   */
-  raiseEventsForChangedPath(changedPath: Path, eventDataList: Event[]) {
-    this.queueEvents(eventDataList);
+/**
+ * Queues the specified events and synchronously raises all events (including previously queued ones)
+ * for the specified path.
+ *
+ * It is assumed that the new events are all for the specified path.
+ *
+ * @param path The path to raise events for.
+ * @param eventDataList The new events to raise.
+ */
+export function eventQueueRaiseEventsAtPath(
+  eventQueue: EventQueue,
+  path: Path,
+  eventDataList: Event[]
+) {
+  eventQueueQueueEvents(eventQueue, eventDataList);
+  eventQueueRaiseQueuedEventsMatchingPredicate(eventQueue, eventPath =>
+    eventPath.equals(path)
+  );
+}
 
-    this.raiseQueuedEventsMatchingPredicate_((eventPath: Path) => {
-      return eventPath.contains(changedPath) || changedPath.contains(eventPath);
-    });
-  }
+/**
+ * Queues the specified events and synchronously raises all events (including previously queued ones) for
+ * locations related to the specified change path (i.e. all ancestors and descendants).
+ *
+ * It is assumed that the new events are all related (ancestor or descendant) to the specified path.
+ *
+ * @param changedPath The path to raise events for.
+ * @param eventDataList The events to raise
+ */
+export function eventQueueRaiseEventsForChangedPath(
+  eventQueue: EventQueue,
+  changedPath: Path,
+  eventDataList: Event[]
+) {
+  eventQueueQueueEvents(eventQueue, eventDataList);
+  eventQueueRaiseQueuedEventsMatchingPredicate(
+    eventQueue,
+    eventPath =>
+      eventPath.contains(changedPath) || changedPath.contains(eventPath)
+  );
+}
 
-  private raiseQueuedEventsMatchingPredicate_(
-    predicate: (path: Path) => boolean
-  ) {
-    this.recursionDepth_++;
+function eventQueueRaiseQueuedEventsMatchingPredicate(
+  eventQueue: EventQueue,
+  predicate: (path: Path) => boolean
+) {
+  eventQueue.recursionDepth_++;
 
-    let sentAll = true;
-    for (let i = 0; i < this.eventLists_.length; i++) {
-      const eventList = this.eventLists_[i];
-      if (eventList) {
-        const eventPath = eventList.path;
-        if (predicate(eventPath)) {
-          eventListRaise(this.eventLists_[i]);
-          this.eventLists_[i] = null;
-        } else {
-          sentAll = false;
-        }
+  let sentAll = true;
+  for (let i = 0; i < eventQueue.eventLists_.length; i++) {
+    const eventList = eventQueue.eventLists_[i];
+    if (eventList) {
+      const eventPath = eventList.path;
+      if (predicate(eventPath)) {
+        eventListRaise(eventQueue.eventLists_[i]);
+        eventQueue.eventLists_[i] = null;
+      } else {
+        sentAll = false;
       }
     }
+  }
 
-    if (sentAll) {
-      this.eventLists_ = [];
-    }
-
-    this.recursionDepth_--;
+  if (sentAll) {
+    eventQueue.eventLists_ = [];
   }
+
+  eventQueue.recursionDepth_--;
 }
 
 interface EventList {
