Compat class for QuerySnapshot (#4058)

Author: schmidt-sebastian

packages/firestore/exp/src/api/snapshot.ts

@@ -29,15 +29,14 @@ import {
   queryEqual,
   SetOptions
 } from '../../../lite/src/api/reference';
-import {
-  changesFromSnapshot,
-  SnapshotMetadata
-} from '../../../src/api/database';
+import { SnapshotMetadata } from '../../../src/api/database';
 import { Code, FirestoreError } from '../../../src/util/error';
-import { ViewSnapshot } from '../../../src/core/view_snapshot';
+import { ChangeType, ViewSnapshot } from '../../../src/core/view_snapshot';
 import { FieldPath } from '../../../lite/src/api/field_path';
 import { SnapshotListenOptions } from './reference';
 import { UntypedFirestoreDataConverter } from '../../../src/api/user_data_reader';
+import { debugAssert, fail } from '../../../src/util/assert';
+import { newQueryComparator } from '../../../src/core/query';
 
 /**
  * Converter used by `withConverter()` to transform user objects of type `T`
@@ -370,10 +369,16 @@ export class QuerySnapshot<T = DocumentData> {
     this._snapshot.docs.forEach(doc => {
       callback.call(
         thisArg,
-        this._convertToDocumentSnapshot(
+        new QueryDocumentSnapshot<T>(
+          this._firestore,
+          this._userDataWriter,
+          doc.key,
           doc,
-          this._snapshot.fromCache,
-          this._snapshot.mutatedKeys.has(doc.key)
+          new SnapshotMetadata(
+            this._snapshot.mutatedKeys.has(doc.key),
+            this._snapshot.fromCache
+          ),
+          this.query._converter
         )
       );
     });
@@ -403,30 +408,108 @@ export class QuerySnapshot<T = DocumentData> {
       !this._cachedChanges ||
       this._cachedChangesIncludeMetadataChanges !== includeMetadataChanges
     ) {
-      this._cachedChanges = changesFromSnapshot<QueryDocumentSnapshot<T>>(
-        this._snapshot,
-        includeMetadataChanges,
-        this._convertToDocumentSnapshot.bind(this)
-      );
+      this._cachedChanges = changesFromSnapshot(this, includeMetadataChanges);
       this._cachedChangesIncludeMetadataChanges = includeMetadataChanges;
     }
 
     return this._cachedChanges;
   }
+}
 
-  private _convertToDocumentSnapshot(
-    doc: Document,
-    fromCache: boolean,
-    hasPendingWrites: boolean
-  ): QueryDocumentSnapshot<T> {
-    return new QueryDocumentSnapshot<T>(
-      this._firestore,
-      this._userDataWriter,
-      doc.key,
-      doc,
-      new SnapshotMetadata(hasPendingWrites, fromCache),
-      this.query._converter
-    );
+/** Calculates the array of DocumentChanges for a given ViewSnapshot. */
+export function changesFromSnapshot<T>(
+  querySnapshot: QuerySnapshot<T>,
+  includeMetadataChanges: boolean
+): Array<DocumentChange<T>> {
+  if (querySnapshot._snapshot.oldDocs.isEmpty()) {
+    // Special case the first snapshot because index calculation is easy and
+    // fast
+    let lastDoc: Document;
+    let index = 0;
+    return querySnapshot._snapshot.docChanges.map(change => {
+      debugAssert(
+        change.type === ChangeType.Added,
+        'Invalid event type for first snapshot'
+      );
+      debugAssert(
+        !lastDoc ||
+          newQueryComparator(querySnapshot._snapshot.query)(
+            lastDoc,
+            change.doc
+          ) < 0,
+        'Got added events in wrong order'
+      );
+      const doc = new QueryDocumentSnapshot<T>(
+        querySnapshot._firestore,
+        querySnapshot._userDataWriter,
+        change.doc.key,
+        change.doc,
+        new SnapshotMetadata(
+          querySnapshot._snapshot.mutatedKeys.has(change.doc.key),
+          querySnapshot._snapshot.fromCache
+        ),
+        querySnapshot.query._converter
+      );
+      lastDoc = change.doc;
+      return {
+        type: 'added' as DocumentChangeType,
+        doc,
+        oldIndex: -1,
+        newIndex: index++
+      };
+    });
+  } else {
+    // A DocumentSet that is updated incrementally as changes are applied to use
+    // to lookup the index of a document.
+    let indexTracker = querySnapshot._snapshot.oldDocs;
+    return querySnapshot._snapshot.docChanges
+      .filter(
+        change => includeMetadataChanges || change.type !== ChangeType.Metadata
+      )
+      .map(change => {
+        const doc = new QueryDocumentSnapshot<T>(
+          querySnapshot._firestore,
+          querySnapshot._userDataWriter,
+          change.doc.key,
+          change.doc,
+          new SnapshotMetadata(
+            querySnapshot._snapshot.mutatedKeys.has(change.doc.key),
+            querySnapshot._snapshot.fromCache
+          ),
+          querySnapshot.query._converter
+        );
+        let oldIndex = -1;
+        let newIndex = -1;
+        if (change.type !== ChangeType.Added) {
+          oldIndex = indexTracker.indexOf(change.doc.key);
+          debugAssert(oldIndex >= 0, 'Index for document not found');
+          indexTracker = indexTracker.delete(change.doc.key);
+        }
+        if (change.type !== ChangeType.Removed) {
+          indexTracker = indexTracker.add(change.doc);
+          newIndex = indexTracker.indexOf(change.doc.key);
+        }
+        return {
+          type: resultChangeType(change.type),
+          doc,
+          oldIndex,
+          newIndex
+        };
+      });
+  }
+}
+
+export function resultChangeType(type: ChangeType): DocumentChangeType {
+  switch (type) {
+    case ChangeType.Added:
+      return 'added';
+    case ChangeType.Modified:
+    case ChangeType.Metadata:
+      return 'modified';
+    case ChangeType.Removed:
+      return 'removed';
+    default:
+      return fail('Unknown change type: ' + type);
   }
 }
 

packages/firestore/exp/test/shim.ts

@@ -29,7 +29,6 @@ import {
   query,
   queryEqual,
   refEqual,
-  snapshotEqual,
   endAt,
   endBefore,
   startAfter,
@@ -50,7 +49,7 @@ import {
   Firestore,
   DocumentReference,
   DocumentSnapshot,
-  QueryDocumentSnapshot,
+  QuerySnapshot,
   wrapObserver,
   extractSnapshotOptions
 } from '../../src/api/database';
@@ -309,62 +308,6 @@ export class Query<T = legacy.DocumentData>
   }
 }
 
-export class QuerySnapshot<T = legacy.DocumentData>
-  implements legacy.QuerySnapshot<T> {
-  constructor(
-    readonly _firestore: Firestore,
-    readonly _delegate: exp.QuerySnapshot<T>
-  ) {}
-
-  readonly query = new Query(this._firestore, this._delegate.query);
-  readonly metadata = this._delegate.metadata;
-  readonly size = this._delegate.size;
-  readonly empty = this._delegate.empty;
-
-  get docs(): Array<QueryDocumentSnapshot<T>> {
-    return this._delegate.docs.map(
-      doc => new QueryDocumentSnapshot<T>(this._firestore, doc)
-    );
-  }
-
-  docChanges(options?: legacy.SnapshotListenOptions): Array<DocumentChange<T>> {
-    return this._delegate
-      .docChanges(options)
-      .map(docChange => new DocumentChange<T>(this._firestore, docChange));
-  }
-
-  forEach(
-    callback: (result: QueryDocumentSnapshot<T>) => void,
-    thisArg?: any
-  ): void {
-    this._delegate.forEach(snapshot => {
-      callback.call(
-        thisArg,
-        new QueryDocumentSnapshot(this._firestore, snapshot)
-      );
-    });
-  }
-
-  isEqual(other: QuerySnapshot<T>): boolean {
-    return snapshotEqual(this._delegate, other._delegate);
-  }
-}
-
-export class DocumentChange<T = legacy.DocumentData>
-  implements legacy.DocumentChange<T> {
-  constructor(
-    private readonly _firestore: Firestore,
-    private readonly _delegate: exp.DocumentChange<T>
-  ) {}
-  readonly type = this._delegate.type;
-  readonly doc = new QueryDocumentSnapshot<T>(
-    this._firestore,
-    this._delegate.doc
-  );
-  readonly oldIndex = this._delegate.oldIndex;
-  readonly newIndex = this._delegate.oldIndex;
-}
-
 export class CollectionReference<T = legacy.DocumentData>
   extends Query<T>
   implements legacy.CollectionReference<T> {