feat(rtdb): types for collection, audit trail, snapshot, and state changes (angular#1643)

Author: jamesdaniels

src/database/interfaces.ts

@@ -6,9 +6,9 @@ export type FirebaseOperation = string | Reference | DataSnapshot;
 export interface AngularFireList<T> {
   query: DatabaseQuery;
   valueChanges(events?: ChildEvent[]): Observable<T[]>;
-  snapshotChanges(events?: ChildEvent[]): Observable<SnapshotAction[]>;
-  stateChanges(events?: ChildEvent[]): Observable<SnapshotAction>;
-  auditTrail(events?: ChildEvent[]): Observable<SnapshotAction[]>;
+  snapshotChanges(events?: ChildEvent[]): Observable<SnapshotAction<T>[]>;
+  stateChanges(events?: ChildEvent[]): Observable<SnapshotAction<T>>;
+  auditTrail(events?: ChildEvent[]): Observable<SnapshotAction<T>[]>;
   update(item: FirebaseOperation, data: T): Promise<void>;
   set(item: FirebaseOperation, data: T): Promise<void>;
   push(data: T): ThenableReference;
@@ -18,7 +18,7 @@ export interface AngularFireList<T> {
 export interface AngularFireObject<T> {
   query: DatabaseQuery;
   valueChanges(): Observable<T | null>;
-  snapshotChanges(): Observable<SnapshotAction>;
+  snapshotChanges(): Observable<SnapshotAction<T>>;
   update(data: Partial<T>): Promise<void>;
   set(data: T): Promise<void>;
   remove(): Promise<void>;
@@ -45,11 +45,24 @@ export interface AngularFireAction<T> extends Action<T> {
   key: string | null;
 }
 
-export type SnapshotAction = AngularFireAction<DatabaseSnapshot>;
+export type SnapshotAction<T> = AngularFireAction<DatabaseSnapshot<T>>;
 
 export type Primitive = number | string | boolean;
 
-export type DatabaseSnapshot = DataSnapshot;
+export interface DatabaseSnapshotExists<T> extends DataSnapshot {
+  exists(): true;
+  val(): T;
+  forEach(action: (a: DatabaseSnapshot<T>) => boolean): boolean;
+}
+
+export interface DatabaseSnapshotDoesNotExist<T> extends DataSnapshot {
+  exists(): false;
+  val(): null;
+  forEach(action: (a: DatabaseSnapshot<T>) => boolean): boolean;
+}
+
+export type DatabaseSnapshot<T> = DatabaseSnapshotExists<T> | DatabaseSnapshotDoesNotExist<T>;
+
 export type DatabaseReference = Reference;
 export type DatabaseQuery = Query;
 export type QueryReference = DatabaseReference | DatabaseQuery;

src/database/list/audit-trail.spec.ts

@@ -1,5 +1,5 @@
 import { Reference } from '@firebase/database-types';
-import { FirebaseApp, FirebaseAppConfig, AngularFireModule } from 'angularfire2';
+import { FirebaseApp, AngularFireModule } from 'angularfire2';
 import { AngularFireDatabase, AngularFireDatabaseModule, auditTrail, ChildEvent } from 'angularfire2/database';
 import { TestBed, inject } from '@angular/core/testing';
 import { COMMON_CONFIG } from '../test-config';

src/database/list/audit-trail.ts

@@ -7,32 +7,24 @@ import { AngularFireDatabase } from '../database';
 
 import { skipWhile, withLatestFrom, map, scan } from 'rxjs/operators';
 
-export function createAuditTrail(query: DatabaseQuery, afDatabase: AngularFireDatabase) {
-  return (events?: ChildEvent[]) => afDatabase.scheduler.keepUnstableUntilFirst(
-    afDatabase.scheduler.runOutsideAngular(
-      auditTrail(query, events)
-    )
-  );
-}
-
-export function auditTrail(query: DatabaseQuery, events?: ChildEvent[]): Observable<SnapshotAction[]> {
-  const auditTrail$ = stateChanges(query, events)
+export function auditTrail<T>(query: DatabaseQuery, events?: ChildEvent[]): Observable<SnapshotAction<T>[]> {
+  const auditTrail$ = stateChanges<T>(query, events)
     .pipe(
-      scan<SnapshotAction>((current, action) => [...current, action], [])
+      scan<SnapshotAction<T>>((current, action) => [...current, action], [])
     );
-  return waitForLoaded(query, auditTrail$);
+  return waitForLoaded<T>(query, auditTrail$);
 }
 
 interface LoadedMetadata {
   data: AngularFireAction<DataSnapshot>;
   lastKeyToLoad: any;
 }
 
-function loadedData(query: DatabaseQuery): Observable<LoadedMetadata> {
+function loadedData<T>(query: DatabaseQuery): Observable<LoadedMetadata> {
   // Create an observable of loaded values to retrieve the
   // known dataset. This will allow us to know what key to
   // emit the "whole" array at when listening for child events.
-  return fromRef(query, 'value')
+  return fromRef<T>(query, 'value')
   .pipe(
     map(data => {
       // Store the last key in the data set
@@ -47,8 +39,8 @@ function loadedData(query: DatabaseQuery): Observable<LoadedMetadata> {
   );
 }
 
-function waitForLoaded(query: DatabaseQuery, action$: Observable<SnapshotAction[]>) {
-  const loaded$ = loadedData(query);
+function waitForLoaded<T>(query: DatabaseQuery, action$: Observable<SnapshotAction<T>[]>) {
+  const loaded$ = loadedData<T>(query);
   return loaded$
     .pipe(
       withLatestFrom(action$),

src/database/list/changes.ts

@@ -6,7 +6,7 @@ import { isNil } from '../utils';
 
 import { switchMap, distinctUntilChanged, scan } from 'rxjs/operators';
 
-export function listChanges<T>(ref: DatabaseQuery, events: ChildEvent[]): Observable<SnapshotAction[]> {
+export function listChanges<T=any>(ref: DatabaseQuery, events: ChildEvent[]): Observable<SnapshotAction<T>[]> {
   return fromRef(ref, 'value', 'once').pipe(
     switchMap(snapshotAction => {
       const childEvent$ = [of(snapshotAction)];
@@ -17,7 +17,7 @@ export function listChanges<T>(ref: DatabaseQuery, events: ChildEvent[]): Observ
   );
 }
 
-function positionFor(changes: SnapshotAction[], key) {
+function positionFor<T>(changes: SnapshotAction<T>[], key) {
   const len = changes.length;
   for(let i=0; i<len; i++) {
     if(changes[i].payload.key === key) {
@@ -27,7 +27,7 @@ function positionFor(changes: SnapshotAction[], key) {
   return -1;
 }
 
-function positionAfter(changes: SnapshotAction[], prevKey?: string) {
+function positionAfter<T>(changes: SnapshotAction<T>[], prevKey?: string) {
   if(isNil(prevKey)) { 
     return 0; 
   } else {

src/database/list/create-reference.ts

@@ -1,37 +1,51 @@
 import { DatabaseQuery, AngularFireList, ChildEvent } from '../interfaces';
 import { snapshotChanges } from './snapshot-changes';
-import { createStateChanges } from './state-changes';
-import { createAuditTrail } from './audit-trail';
+import { stateChanges } from './state-changes';
+import { auditTrail } from './audit-trail';
 import { createDataOperationMethod } from './data-operation';
 import { createRemoveMethod } from './remove';
 import { AngularFireDatabase } from '../database';
 import { map } from 'rxjs/operators';
 
-export function createListReference<T>(query: DatabaseQuery, afDatabase: AngularFireDatabase): AngularFireList<T> {
+export function createListReference<T=any>(query: DatabaseQuery, afDatabase: AngularFireDatabase): AngularFireList<T> {
   return {
     query,
     update: createDataOperationMethod<Partial<T>>(query.ref, 'update'),
     set: createDataOperationMethod<T>(query.ref, 'set'),
     push: (data: T) => query.ref.push(data),
     remove: createRemoveMethod(query.ref),
     snapshotChanges(events?: ChildEvent[]) {
-      const snapshotChanges$ = snapshotChanges(query, events);
+      const snapshotChanges$ = snapshotChanges<T>(query, events);
       return afDatabase.scheduler.keepUnstableUntilFirst(
         afDatabase.scheduler.runOutsideAngular(
           snapshotChanges$
         )
       );
     },
-    stateChanges: createStateChanges(query, afDatabase),
-    auditTrail: createAuditTrail(query, afDatabase),
-    valueChanges<T>(events?: ChildEvent[]) { 
-      const snapshotChanges$ = snapshotChanges(query, events);
+    stateChanges(events?: ChildEvent[]) {
+      const stateChanges$ = stateChanges<T>(query, events);
+      return afDatabase.scheduler.keepUnstableUntilFirst(
+        afDatabase.scheduler.runOutsideAngular(
+          stateChanges$
+        )
+      );
+    },
+    auditTrail(events?: ChildEvent[]) {
+      const auditTrail$ = auditTrail<T>(query, events)
+      return afDatabase.scheduler.keepUnstableUntilFirst(
+        afDatabase.scheduler.runOutsideAngular(
+          auditTrail$
+        )
+      );
+    },
+    valueChanges(events?: ChildEvent[]) {
+      const snapshotChanges$ = snapshotChanges<T>(query, events);
       return afDatabase.scheduler.keepUnstableUntilFirst(
         afDatabase.scheduler.runOutsideAngular(
           snapshotChanges$
         )
       ).pipe(
-        map(actions => actions.map(a => a.payload.val()))
+        map(actions => actions.map(a => a.payload.val() as T))
       );
     }
   }

src/database/list/data-operation.ts

@@ -7,7 +7,7 @@ export function createDataOperationMethod<T>(ref: DatabaseReference, operation:
     return checkOperationCases(item, {
       stringCase: () => ref.child(<string>item)[operation](value),
       firebaseCase: () => (<DatabaseReference>item)[operation](value),
-      snapshotCase: () => (<DatabaseSnapshot>item).ref[operation](value)
+      snapshotCase: () => (<DatabaseSnapshot<T>>item).ref[operation](value)
     });
   }
 }

src/database/list/remove.ts

@@ -5,13 +5,13 @@ import { DataSnapshot, Reference } from '@firebase/database-types';
 
 // TODO(davideast): Find out why TS thinks this returns firebase.Primise
 // instead of Promise.
-export function createRemoveMethod(ref: DatabaseReference) {
+export function createRemoveMethod<T>(ref: DatabaseReference) {
   return function remove(item?: FirebaseOperation): any {
     if(!item) { return ref.remove(); }
     return checkOperationCases(item, {
       stringCase: () => ref.child(<string>item).remove(),
       firebaseCase: () => (<DatabaseReference>item).remove(),
-      snapshotCase: () => (<DatabaseSnapshot>item).ref.remove()
+      snapshotCase: () => (<DatabaseSnapshot<T>>item).ref.remove()
     });
   }
 }

src/database/list/snapshot-changes.ts

@@ -3,7 +3,7 @@ import { listChanges } from './changes';
 import { DatabaseQuery, ChildEvent, SnapshotAction } from '../interfaces';
 import { validateEventsArray } from './utils';
 
-export function snapshotChanges(query: DatabaseQuery, events?: ChildEvent[]): Observable<SnapshotAction[]> {
+export function snapshotChanges<T>(query: DatabaseQuery, events?: ChildEvent[]): Observable<SnapshotAction<T>[]> {
   events = validateEventsArray(events);
-  return listChanges(query, events!);
+  return listChanges<T>(query, events!);
 }

src/database/list/state-changes.ts

@@ -3,19 +3,11 @@ import { fromRef } from '../observable/fromRef';
 import { validateEventsArray } from './utils';
 import { Observable, merge } from 'rxjs';
 
-import { DataSnapshot } from '@firebase/database-types';
+import { DatabaseSnapshot } from '../interfaces';
 import { AngularFireDatabase } from '../database';
 
-export function createStateChanges(query: DatabaseQuery, afDatabase: AngularFireDatabase) {
-  return (events?: ChildEvent[]) => afDatabase.scheduler.keepUnstableUntilFirst(
-    afDatabase.scheduler.runOutsideAngular(
-      stateChanges(query, events)
-    )
-  );
-}
-
-export function stateChanges(query: DatabaseQuery, events?: ChildEvent[]) {
+export function stateChanges<T>(query: DatabaseQuery, events?: ChildEvent[]) {
   events = validateEventsArray(events)!;
-  const childEvent$ = events.map(event => fromRef(query, event));
+  const childEvent$ = events.map(event => fromRef<T>(query, event));
   return merge(...childEvent$);
 }

src/database/object/create-reference.ts

@@ -3,11 +3,11 @@ import { DatabaseQuery, AngularFireObject } from '../interfaces';
 import { createObjectSnapshotChanges } from './snapshot-changes';
 import { AngularFireDatabase } from '../database';
 
-export function createObjectReference<T>(query: DatabaseQuery, afDatabase: AngularFireDatabase): AngularFireObject<T> {
+export function createObjectReference<T=any>(query: DatabaseQuery, afDatabase: AngularFireDatabase): AngularFireObject<T> {
   return {
     query,
     snapshotChanges<T>() {
-      const snapshotChanges$ = createObjectSnapshotChanges(query)();
+      const snapshotChanges$ = createObjectSnapshotChanges<T>(query)();
       return afDatabase.scheduler.keepUnstableUntilFirst(
         afDatabase.scheduler.runOutsideAngular(
           snapshotChanges$