[Multi-Tab] Supporting non-initial initial queries (#990)

Author: schmidt-sebastian

packages/firestore/src/core/event_manager.ts

@@ -19,7 +19,6 @@ import { SyncEngine } from './sync_engine';
 import { OnlineState, TargetId } from './types';
 import { DocumentViewChange } from './view_snapshot';
 import { ChangeType, ViewSnapshot } from './view_snapshot';
-import { DocumentSet } from '../model/document_set';
 import { assert } from '../util/assert';
 import { EventHandler } from '../util/misc';
 import { ObjectMap } from '../util/obj_map';
@@ -289,28 +288,13 @@ export class QueryListener {
       !this.raisedInitialEvent,
       'Trying to raise initial events for second time'
     );
-    snap = new ViewSnapshot(
+    snap = ViewSnapshot.fromInitialDocuments(
       snap.query,
       snap.docs,
-      DocumentSet.emptySet(snap.docs),
-      QueryListener.getInitialViewChanges(snap),
       snap.fromCache,
-      snap.hasPendingWrites,
-      /* syncChangesState= */ true,
-      /* excludesMetadataChanges= */ false
+      snap.hasPendingWrites
     );
     this.raisedInitialEvent = true;
     this.queryObserver.next(snap);
   }
-
-  /** Returns changes as if all documents in the snap were added. */
-  private static getInitialViewChanges(
-    snap: ViewSnapshot
-  ): DocumentViewChange[] {
-    const result: DocumentViewChange[] = [];
-    snap.docs.forEach(doc => {
-      result.push({ type: ChangeType.Added, doc });
-    });
-    return result;
-  }
 }

packages/firestore/src/core/sync_engine.ts

@@ -177,28 +177,40 @@ export class SyncEngine implements RemoteSyncer, SharedClientStateSyncer {
    * server. All the subsequent view snapshots or errors are sent to the
    * subscribed handlers. Returns the targetId of the query.
    */
-  listen(query: Query): Promise<TargetId> {
+  async listen(query: Query): Promise<TargetId> {
     this.assertSubscribed('listen()');
-    assert(
-      !this.queryViewsByQuery.has(query),
-      'We already listen to the query: ' + query
-    );
 
-    return this.localStore.allocateQuery(query).then(queryData => {
+    let targetId;
+    let viewSnapshot;
+
+    const queryView = this.queryViewsByQuery.get(query);
+    if (queryView) {
+      // PORTING NOTE: With Mult-Tab Web, it is possible that a query view
+      // already exists when EventManager calls us for the first time. This
+      // happens when the primary tab is already listening to this query on
+      // behalf of another tab and the user of the primary also starts listening
+      // to the query. EventManager will not have an assigned target ID in this
+      // case and calls `listen` to obtain this ID.
+      targetId = queryView.targetId;
+      this.sharedClientState.addLocalQueryTarget(targetId);
+      viewSnapshot = queryView.view.computeInitialSnapshot();
+    } else {
+      const queryData = await this.localStore.allocateQuery(query);
       const status = this.sharedClientState.addLocalQueryTarget(
         queryData.targetId
       );
-      return this.initializeViewAndComputeInitialSnapshot(
+      targetId = queryData.targetId;
+      viewSnapshot = await this.initializeViewAndComputeInitialSnapshot(
         queryData,
         status === 'current'
-      ).then(viewSnapshot => {
-        if (this.isPrimary) {
-          this.remoteStore.listen(queryData);
-        }
-        this.viewHandler!([viewSnapshot]);
-        return queryData.targetId;
-      });
-    });
+      );
+      if (this.isPrimary) {
+        this.remoteStore.listen(queryData);
+      }
+    }
+
+    this.viewHandler!([viewSnapshot]);
+    return targetId;
   }
 
   private initializeViewAndComputeInitialSnapshot(

packages/firestore/src/core/view.ts

@@ -383,9 +383,25 @@ export class View {
     return changes;
   }
 
+  // PORTING NOTE: Multi-tab only.
   synchronizeWithRemoteKeys(remoteKeys: DocumentKeySet): void {
     this._syncedDocuments = remoteKeys;
   }
+
+  /**
+   * Returns a view snapshot as if this query was just listened to. Contains
+   * a document add for every existing document and the `fromCache` and
+   * `hasPendingWrites` status of the already established view.
+   */
+  // PORTING NOTE: Multi-tab only.
+  computeInitialSnapshot(): ViewSnapshot {
+    return ViewSnapshot.fromInitialDocuments(
+      this.query,
+      this.documentSet,
+      this.syncState === SyncState.Local,
+      !this.mutatedKeys.isEmpty()
+    );
+  }
 }
 
 function compareChangeType(c1: ChangeType, c2: ChangeType): number {

packages/firestore/src/core/view_snapshot.ts

@@ -149,6 +149,30 @@ export class ViewSnapshot {
     readonly excludesMetadataChanges: boolean
   ) {}
 
+  /** Returns a view snapshot as if all documents in the snapshot were added. */
+  static fromInitialDocuments(
+    query: Query,
+    documents: DocumentSet,
+    fromCache: boolean,
+    hasPendingWrites: boolean
+  ): ViewSnapshot {
+    const changeSet = new DocumentChangeSet();
+    documents.forEach(doc => {
+      changeSet.track({ type: ChangeType.Added, doc });
+    });
+
+    return new ViewSnapshot(
+      query,
+      documents,
+      DocumentSet.emptySet(documents),
+      changeSet.getChanges(),
+      fromCache,
+      hasPendingWrites,
+      /* syncStateChanged */ true,
+      /* excludesMetadataChanges= */ false
+    );
+  }
+
   isEqual(other: ViewSnapshot): boolean {
     if (
       this.fromCache !== other.fromCache ||

packages/firestore/test/unit/specs/listen_spec.test.ts

@@ -514,6 +514,35 @@ describeSpec('Listens:', [], () => {
     }
   );
 
+  specTest('Query is joined by primary client', ['multi-client'], () => {
+    const query = Query.atPath(path('collection'));
+    const docA = doc('collection/a', 1000, { key: 'a' });
+    const docB = doc('collection/b', 2000, { key: 'b' });
+    const docC = doc('collection/c', 3000, { key: 'c' });
+
+    return client(0)
+      .expectPrimaryState(true)
+      .client(1)
+      .userListens(query)
+      .expectEvents(query, { fromCache: true })
+      .client(0)
+      .expectListen(query)
+      .watchAcksFull(query, 100, docA)
+      .client(1)
+      .expectEvents(query, { added: [docA] })
+      .client(0)
+      .watchSends({ affects: [query] }, docB)
+      .watchSnapshots(2000)
+      .userListens(query)
+      .expectEvents(query, { added: [docA, docB] })
+      .watchSends({ affects: [query] }, docC)
+      .watchSnapshots(3000)
+      .expectEvents(query, { added: [docC] })
+      .client(1)
+      .expectEvents(query, { added: [docB] })
+      .expectEvents(query, { added: [docC] });
+  });
+
   specTest(
     'Query only raises events in participating clients',
     ['multi-client'],