includeMetadataChanges!

Author: jamesdaniels

src/firestore/collection/changes.ts

@@ -1,6 +1,7 @@
 import { fromCollectionRef } from '../observable/fromRef';
 import { Observable } from 'rxjs';
 import { map, filter, scan } from 'rxjs/operators';
+import { firestore } from 'firebase/app';
 
 import { Query, DocumentChangeType, DocumentChange, DocumentChangeAction, Action } from '../interfaces';
 
@@ -9,22 +10,22 @@ import { Query, DocumentChangeType, DocumentChange, DocumentChangeAction, Action
  * order of occurence.
  * @param query
  */
-export function docChanges<T>(query: Query): Observable<DocumentChangeAction<T>[]> {
-  return fromCollectionRef(query)
+export function docChanges<T>(query: Query, options?: firestore.SnapshotListenOptions): Observable<DocumentChangeAction<T>[]> {
+  return fromCollectionRef(query, options)
     .pipe(
       map(action =>
-        action.payload.docChanges()
+        action.payload.docChanges(options)
           .map(change => ({ type: change.type, payload: change } as DocumentChangeAction<T>))));
 }
 
 /**
  * Return a stream of document changes on a query. These results are in sort order.
  * @param query
  */
-export function sortedChanges<T>(query: Query, events: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {
-  return fromCollectionRef(query)
+export function sortedChanges<T>(query: Query, events: DocumentChangeType[], options?: firestore.SnapshotListenOptions): Observable<DocumentChangeAction<T>[]> {
+  return fromCollectionRef(query, options)
     .pipe(
-      map(changes => changes.payload.docChanges()),
+      map(changes => changes.payload.docChanges(options)),
       scan((current, changes) => combineChanges(current, changes, events), []),
       map(changes => changes.map(c => ({ type: c.type, payload: c } as DocumentChangeAction<T>))));
 }

src/firestore/collection/collection.spec.ts

@@ -49,7 +49,7 @@ describe('AngularFirestoreCollection', () => {
       const ITEMS = 4;
       const { randomCollectionName, ref, stocks, names } = await collectionHarness(afs, ITEMS);
 
-      const sub = stocks.valueChanges().subscribe(data => {
+      const sub = stocks.valueChanges({idField: 'id', metadataField: 'meta'}).subscribe(data => {
         // unsub immediately as we will be deleting data at the bottom
         // and that will trigger another subscribe callback and fail
         // the test
@@ -59,6 +59,8 @@ describe('AngularFirestoreCollection', () => {
         // if the collection state is altered during a test run
         expect(data.length).toEqual(ITEMS);
         data.forEach(stock => {
+          console.log(stock.id);
+          console.log(stock.meta);
           // We used the same piece of data so they should all equal
           expect(stock).toEqual(FAKE_STOCK_DATA);
         });

src/firestore/collection/collection.ts

@@ -16,6 +16,9 @@ export function validateEventsArray(events?: DocumentChangeType[]) {
   return events;
 }
 
+export type ChangeOptions = firestore.SnapshotListenOptions & { events?: DocumentChangeType[] };
+
+// SEMVER @ v6 only allow options
 /**
  * AngularFirestoreCollection service
  *
@@ -61,42 +64,39 @@ export class AngularFirestoreCollection<T=DocumentData> {
    * your own data structure.
    * @param events
    */
-  stateChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {
-    if(!events || events.length === 0) {
-      return this.afs.scheduler.keepUnstableUntilFirst(
-        this.afs.scheduler.runOutsideAngular(
-          docChanges<T>(this.query)
-        )
-      );
-    }
-    return this.afs.scheduler.keepUnstableUntilFirst(
-        this.afs.scheduler.runOutsideAngular(
-          docChanges<T>(this.query)
-        )
+  stateChanges(eventsOrOptions?: DocumentChangeType[]|ChangeOptions): Observable<DocumentChangeAction<T>[]> {
+    const events = eventsOrOptions && (Array.isArray(eventsOrOptions) ? eventsOrOptions : eventsOrOptions.events) || [];
+    const options = eventsOrOptions && !Array.isArray(eventsOrOptions) ? eventsOrOptions : {};
+    const ret = this.afs.scheduler.keepUnstableUntilFirst(
+      this.afs.scheduler.runOutsideAngular(
+        docChanges<T>(this.query, options)
       )
-      .pipe(
-        map(actions => actions.filter(change => events.indexOf(change.type) > -1)),
-        filter(changes =>  changes.length > 0)
-      );
+    );
+    return events.length === 0 ? ret : ret.pipe(
+      map(actions => actions.filter(change => events.indexOf(change.type) > -1)),
+      filter(changes =>  changes.length > 0)
+    );
   }
 
   /**
    * Create a stream of changes as they occur it time. This method is similar to stateChanges()
    * but it collects each event in an array over time.
    * @param events
    */
-  auditTrail(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {
-    return this.stateChanges(events).pipe(scan((current, action) => [...current, ...action], []));
+  auditTrail(eventsOrOptions?: DocumentChangeType[]|ChangeOptions): Observable<DocumentChangeAction<T>[]> {
+    return this.stateChanges(eventsOrOptions).pipe(scan((current, action) => [...current, ...action], []));
   }
 
   /**
    * Create a stream of synchronized changes. This method keeps the local array in sorted
    * query order.
    * @param events
    */
-  snapshotChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {
+  snapshotChanges(eventsOrOptions?: DocumentChangeType[]|ChangeOptions): Observable<DocumentChangeAction<T>[]> {
+    const events = eventsOrOptions && (Array.isArray(eventsOrOptions) ? eventsOrOptions : eventsOrOptions.events) || [];
+    const options = eventsOrOptions && !Array.isArray(eventsOrOptions) ? eventsOrOptions : {};
     const validatedEvents = validateEventsArray(events);
-    const sortedChanges$ = sortedChanges<T>(this.query, validatedEvents);
+    const sortedChanges$ = sortedChanges<T>(this.query, validatedEvents, options);
     const scheduledSortedChanges$ = this.afs.scheduler.runOutsideAngular(sortedChanges$);
     return this.afs.scheduler.keepUnstableUntilFirst(scheduledSortedChanges$);
   }
@@ -110,22 +110,19 @@ export class AngularFirestoreCollection<T=DocumentData> {
    */
   valueChanges(): Observable<T[]>
   valueChanges({}): Observable<T[]>
-  valueChanges<K extends string>(options: {idField: K}): Observable<(T & { [T in K]: string })[]>
-  valueChanges<K extends string>(options: {idField?: K} = {}): Observable<T[]> {
-    const fromCollectionRef$ = fromCollectionRef<T>(this.query);
+  valueChanges<K extends string, L extends string>(options: { idField: K, metadataField: L }): Observable<(T & { [T in L]: firestore.SnapshotMetadata } & { [T in K]: string })[]>
+  valueChanges<L extends string>(options: { metadataField: L }): Observable<(T & { [T in L]: firestore.SnapshotMetadata })[]>
+  valueChanges<K extends string>(options: { idField: K}): Observable<(T & { [T in K]: string })[]>
+  valueChanges(options: {idField?: string, metadataField?: string} = {}): Observable<T[]> {
+    const fromCollectionRef$ = fromCollectionRef<T>(this.query, options.metadataField ? { includeMetadataChanges: true } : {});
     const scheduled$ = this.afs.scheduler.runOutsideAngular(fromCollectionRef$);
     return this.afs.scheduler.keepUnstableUntilFirst(scheduled$)
       .pipe(
-        map(actions => actions.payload.docs.map(a => {
-          if (options.idField) {
-            return { 
-              ...a.data() as Object, 
-              ...{ [options.idField]: a.id } 
-            } as T & { [T in K]: string };
-          } else {
-            return a.data()
-          }
-        }))
+        map(actions => actions.payload.docs.map(a => ({ 
+          ...(a.data() as Object),
+          ...(options.metadataField ? { [options.metadataField]: a.metadata } : {}),
+          ...(options.idField ? { [options.idField]: a.id } : {})
+        } as T)))
       );
   }
 

src/firestore/interfaces.ts

@@ -49,7 +49,7 @@ export interface Action<T> {
 };
 
 export interface Reference<T> {
-  onSnapshot: (sub: Subscriber<any>) => any;
+  onSnapshot: (options: firestore.SnapshotListenOptions, sub: Subscriber<any>) => any;
 }
 
 // A convience type for making a query.

src/firestore/observable/fromRef.ts

@@ -1,25 +1,26 @@
 import { Observable, Subscriber } from 'rxjs';
 import { DocumentReference, Query, Action, Reference, DocumentSnapshot, QuerySnapshot } from '../interfaces';
 import { map, share } from 'rxjs/operators';
+import { firestore } from 'firebase';
 
-function _fromRef<T, R>(ref: Reference<T>): Observable<R> {
+function _fromRef<T, R>(ref: Reference<T>, options?: firestore.SnapshotListenOptions): Observable<R> {
   return new Observable(subscriber => {
-    const unsubscribe = ref.onSnapshot(subscriber);
+    const unsubscribe = ref.onSnapshot(options || {}, subscriber);
     return { unsubscribe };
   });
 }
 
-export function fromRef<R>(ref: DocumentReference | Query) {
-  return _fromRef<typeof ref, R>(ref).pipe(share());
+export function fromRef<R>(ref: DocumentReference | Query, options?: firestore.SnapshotListenOptions) {
+  return _fromRef<typeof ref, R>(ref, options).pipe(share());
 }
 
-export function fromDocRef<T>(ref: DocumentReference): Observable<Action<DocumentSnapshot<T>>>{
-  return fromRef<DocumentSnapshot<T>>(ref)
+export function fromDocRef<T>(ref: DocumentReference, options?: firestore.SnapshotListenOptions): Observable<Action<DocumentSnapshot<T>>>{
+  return fromRef<DocumentSnapshot<T>>(ref, options)
     .pipe(
       map(payload => ({ payload, type: 'value' }))
     );
 }
 
-export function fromCollectionRef<T>(ref: Query): Observable<Action<QuerySnapshot<T>>> {
-  return fromRef<QuerySnapshot<T>>(ref).pipe(map(payload => ({ payload, type: 'query' })));
+export function fromCollectionRef<T>(ref: Query, options?: firestore.SnapshotListenOptions): Observable<Action<QuerySnapshot<T>>> {
+  return fromRef<QuerySnapshot<T>>(ref, options).pipe(map(payload => ({ payload, type: 'query' })));
 }