Compat class for QuerySnapshot

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`
@@ -403,17 +402,108 @@ export class QuerySnapshot<T = DocumentData> {
       !this._cachedChanges ||
       this._cachedChangesIncludeMetadataChanges !== includeMetadataChanges
     ) {
-      this._cachedChanges = changesFromSnapshot<QueryDocumentSnapshot<T>>(
+      this._cachedChanges = this.changesFromSnapshot(
         this._snapshot,
-        includeMetadataChanges,
-        this._convertToDocumentSnapshot.bind(this)
+        includeMetadataChanges
       );
       this._cachedChangesIncludeMetadataChanges = includeMetadataChanges;
     }
 
     return this._cachedChanges;
   }
 
+  /**
+   * Calculates the array of DocumentChanges for a given ViewSnapshot.
+   *
+   * Exported for testing.
+   *
+   * @param snapshot The ViewSnapshot that represents the expected state.
+   * @param includeMetadataChanges Whether to include metadata changes.
+   * @param converter A factory function that returns a QueryDocumentSnapshot.
+   * @return An object that matches the DocumentChange API.
+   */
+  changesFromSnapshot(
+    snapshot: ViewSnapshot,
+    includeMetadataChanges: boolean
+  ): Array<DocumentChange<T>> {
+    if (snapshot.oldDocs.isEmpty()) {
+      // Special case the first snapshot because index calculation is easy and
+      // fast
+      let lastDoc: Document;
+      let index = 0;
+      return snapshot.docChanges.map(change => {
+        const doc = this._convertToDocumentSnapshot(
+          change.doc,
+          snapshot.fromCache,
+          snapshot.mutatedKeys.has(change.doc.key)
+        );
+        debugAssert(
+          change.type === ChangeType.Added,
+          'Invalid event type for first snapshot'
+        );
+        debugAssert(
+          !lastDoc ||
+            newQueryComparator(snapshot.query)(lastDoc, change.doc) < 0,
+          'Got added events in wrong order'
+        );
+        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 = snapshot.oldDocs;
+      return snapshot.docChanges
+        .filter(
+          change =>
+            includeMetadataChanges || change.type !== ChangeType.Metadata
+        )
+        .map(change => {
+          const doc = this._convertToDocumentSnapshot(
+            change.doc,
+            snapshot.fromCache,
+            snapshot.mutatedKeys.has(change.doc.key)
+          );
+          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: this.resultChangeType(change.type),
+            doc,
+            oldIndex,
+            newIndex
+          };
+        });
+    }
+  }
+
+  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);
+    }
+  }
+
   private _convertToDocumentSnapshot(
     doc: Document,
     fromCache: boolean,

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> {