(rxfire): unwrap operator (#982)

* (rxfire): unwrap operator
added a custom rxjs operator to map collections/docs to their data payload

* (rxfire): rm unused lines from spec

* (rxfire) data mapping functions
refactored unwrap operator in favor of pure data mapping functions

Author: codediodeio

packages/rxfire/firestore/collection/index.ts

@@ -18,6 +18,7 @@ import { firestore } from 'firebase/app';
 import { fromCollectionRef } from '../fromRef';
 import { Observable } from 'rxjs';
 import { map, filter, scan } from 'rxjs/operators';
+import { snapToData } from '../document';
 
 const ALL_EVENTS: firestore.DocumentChangeType[] = [
   'added',
@@ -166,3 +167,18 @@ export function auditTrail(
     scan((current, action) => [...current, ...action], [])
   );
 }
+
+/**
+ * Returns a stream of documents mapped to their data payload, and optionally the document ID
+ * @param query
+ */
+export function collectionData<T>(
+  query: firestore.Query,
+  idField?: string
+): Observable<T[]> {
+  return collection(query).pipe(
+    map(arr => {
+      return arr.map(snap => snapToData(snap, idField) as T);
+    })
+  );
+}

packages/rxfire/firestore/document/index.ts

@@ -16,8 +16,30 @@
 
 import { firestore } from 'firebase/app';
 import { fromDocRef } from '../fromRef';
+import { map } from 'rxjs/operators';
 import { Observable } from 'rxjs';
 
 export function doc(ref: firestore.DocumentReference) {
   return fromDocRef(ref);
 }
+
+/**
+ * Returns a stream of a document, mapped to its data payload and optionally the docuument ID
+ * @param query
+ */
+export function docData<T>(
+  ref: firestore.DocumentReference,
+  idField?: string
+): Observable<T> {
+  return doc(ref).pipe(map(snap => snapToData(snap, idField) as T));
+}
+
+export function snapToData(
+  snapshot: firestore.QueryDocumentSnapshot,
+  idField?: string
+) {
+  return {
+    ...snapshot.data(),
+    ...(idField ? { [idField]: snapshot.id } : null)
+  };
+}

packages/rxfire/test/firestore.test.ts

@@ -13,15 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 import { expect } from 'chai';
 import { initializeApp, firestore, app } from 'firebase/app';
 import 'firebase/firestore';
 import {
   collection,
   docChanges,
   sortedChanges,
-  auditTrail
+  auditTrail,
+  docData,
+  collectionData
 } from '../firestore';
 import { map, take, skip } from 'rxjs/operators';
 
@@ -253,4 +254,88 @@ describe('RxFire Firestore', () => {
       davidDoc.update({ name: 'David!' });
     });
   });
+
+  describe('auditTrail', () => {
+    /**
+     * The `auditTrail()` method returns an array of every change that has
+     * occured in the application. This test seeds two "people" into the
+     * collection and checks that the two added events are there. It then
+     * modifies a "person" and makes sure that event is on the array as well.
+     */
+    it('should keep create a list of all changes', (done: MochaDone) => {
+      const { colRef, expectedEvents, davidDoc } = seedTest(firestore);
+
+      const firstAudit = auditTrail(colRef).pipe(unwrapChange, take(1));
+      const secondAudit = auditTrail(colRef).pipe(unwrapChange, skip(1));
+
+      firstAudit.subscribe(list => {
+        expect(list).to.eql(expectedEvents);
+        davidDoc.update({ name: 'David!' });
+      });
+
+      secondAudit.subscribe(list => {
+        const modifiedList = [
+          ...expectedEvents,
+          { name: 'David!', type: 'modified' }
+        ];
+        expect(list).to.eql(modifiedList);
+        done();
+      });
+    });
+
+    /**
+     * This test seeds two "people" into the collection. The wrap operator then converts
+     */
+    it('should filter the trail of events by event type', (done: MochaDone) => {
+      const { colRef, davidDoc } = seedTest(firestore);
+
+      const modifiedAudit = auditTrail(colRef, ['modified']).pipe(unwrapChange);
+
+      modifiedAudit.subscribe(updateList => {
+        const expectedEvents = [{ type: 'modified', name: 'David!' }];
+        expect(updateList).to.eql(expectedEvents);
+        done();
+      });
+
+      davidDoc.update({ name: 'David!' });
+    });
+  });
+
+  describe('Data Mapping Functions', () => {
+    /**
+     * The `unwrap(id)` method will map a collection to its data payload and map the doc ID to a the specificed key.
+     */
+    it('collectionData should map a QueryDocumentSnapshot[] to an array of plain objects', (done: MochaDone) => {
+      const { colRef } = seedTest(firestore);
+
+      // const unwrapped = collection(colRef).pipe(unwrap('userId'));
+      const unwrapped = collectionData(colRef, 'userId');
+
+      unwrapped.subscribe(val => {
+        const expectedDoc = {
+          name: 'David',
+          userId: 'david'
+        };
+        expect(val).to.be.instanceof(Array);
+        expect(val[0]).to.eql(expectedDoc);
+        done();
+      });
+    });
+
+    it('docData should map a QueryDocumentSnapshot to a plain object', (done: MochaDone) => {
+      const { davidDoc } = seedTest(firestore);
+
+      // const unwrapped = doc(davidDoc).pipe(unwrap('UID'));
+      const unwrapped = docData(davidDoc, 'UID');
+
+      unwrapped.subscribe(val => {
+        const expectedDoc = {
+          name: 'David',
+          UID: 'david'
+        };
+        expect(val).to.eql(expectedDoc);
+        done();
+      });
+    });
+  });
 });