@angular/fire
Version:
The official library for Firebase and Angular
182 lines • 17.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { from } from 'rxjs';
import { fromCollectionRef } from '../observable/fromRef';
import { filter, map, observeOn, scan } from 'rxjs/operators';
import { docChanges, sortedChanges } from './changes';
import { AngularFirestoreDocument } from '../document/document';
/**
* @param {?=} events
* @return {?}
*/
export function validateEventsArray(events) {
if (!events || events.length === 0) {
events = ['added', 'removed', 'modified'];
}
return events;
}
/**
* AngularFirestoreCollection service
*
* This class creates a reference to a Firestore Collection. A reference and a query are provided in
* in the constructor. The query can be the unqueried reference if no query is desired.The class
* is generic which gives you type safety for data update methods and data streaming.
*
* This class uses Symbol.observable to transform into Observable using Observable.from().
*
* This class is rarely used directly and should be created from the AngularFirestore service.
*
* Example:
*
* const collectionRef = firebase.firestore.collection('stocks');
* const query = collectionRef.where('price', '>', '0.01');
* const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);
*
* // NOTE!: the updates are performed on the reference not the query
* await fakeStock.add({ name: 'FAKE', price: 0.01 });
*
* // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.
* fakeStock.valueChanges().subscribe(value => console.log(value));
* @template T
*/
export class AngularFirestoreCollection {
/**
* The constructor takes in a CollectionReference and Query to provide wrapper methods
* for data operations and data streaming.
*
* Note: Data operation methods are done on the reference not the query. This means
* when you update data it is not updating data to the window of your query unless
* the data fits the criteria of the query. See the AssociatedRefence type for details
* on this implication.
* @param {?} ref
* @param {?} query
* @param {?} afs
*/
constructor(ref, query, afs) {
this.ref = ref;
this.query = query;
this.afs = afs;
}
/**
* Listen to the latest change in the stream. This method returns changes
* as they occur and they are not sorted by query order. This allows you to construct
* your own data structure.
* @param {?=} events
* @return {?}
*/
stateChanges(events) {
if (!events || events.length === 0) {
return docChanges(this.query, this.afs.schedulers.outsideAngular).pipe(this.afs.keepUnstableUntilFirst);
}
return docChanges(this.query, this.afs.schedulers.outsideAngular).pipe(map((/**
* @param {?} actions
* @return {?}
*/
actions => actions.filter((/**
* @param {?} change
* @return {?}
*/
change => events.indexOf(change.type) > -1)))), filter((/**
* @param {?} changes
* @return {?}
*/
changes => changes.length > 0)), this.afs.keepUnstableUntilFirst);
}
/**
* 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
* @return {?}
*/
auditTrail(events) {
return this.stateChanges(events).pipe(scan((/**
* @param {?} current
* @param {?} action
* @return {?}
*/
(current, action) => [...current, ...action]), []));
}
/**
* Create a stream of synchronized changes. This method keeps the local array in sorted
* query order.
* @param {?=} events
* @return {?}
*/
snapshotChanges(events) {
/** @type {?} */
const validatedEvents = validateEventsArray(events);
/** @type {?} */
const scheduledSortedChanges$ = sortedChanges(this.query, validatedEvents, this.afs.schedulers.outsideAngular);
return scheduledSortedChanges$.pipe(this.afs.keepUnstableUntilFirst);
}
/**
* @template K
* @param {?=} options
* @return {?}
*/
valueChanges(options = {}) {
return fromCollectionRef(this.query, this.afs.schedulers.outsideAngular)
.pipe(map((/**
* @param {?} actions
* @return {?}
*/
actions => actions.payload.docs.map((/**
* @param {?} a
* @return {?}
*/
a => {
if (options.idField) {
return (/** @type {?} */ (Object.assign(Object.assign({}, (/** @type {?} */ (a.data()))), { [options.idField]: a.id })));
}
else {
return a.data();
}
})))), this.afs.keepUnstableUntilFirst);
}
/**
* Retrieve the results of the query once.
* @param {?=} options
* @return {?}
*/
get(options) {
return from(this.query.get(options)).pipe(observeOn(this.afs.schedulers.insideAngular));
}
/**
* Add data to a collection reference.
*
* Note: Data operation methods are done on the reference not the query. This means
* when you update data it is not updating data to the window of your query unless
* the data fits the criteria of the query.
* @param {?} data
* @return {?}
*/
add(data) {
return this.ref.add(data);
}
/**
* Create a reference to a single document in a collection.
* @template T
* @param {?=} path
* @return {?}
*/
doc(path) {
return new AngularFirestoreDocument(this.ref.doc(path), this.afs);
}
}
if (false) {
/** @type {?} */
AngularFirestoreCollection.prototype.ref;
/**
* @type {?}
* @private
*/
AngularFirestoreCollection.prototype.query;
/**
* @type {?}
* @private
*/
AngularFirestoreCollection.prototype.afs;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../../../src/firestore/collection/collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { from, Observable } from 'rxjs';\nimport { fromCollectionRef } from '../observable/fromRef';\nimport { filter, map, observeOn, scan } from 'rxjs/operators';\nimport { firestore } from 'firebase/app';\n\nimport { CollectionReference, DocumentChangeAction, DocumentChangeType, DocumentData, DocumentReference, Query } from '../interfaces';\nimport { docChanges, sortedChanges } from './changes';\nimport { AngularFirestoreDocument } from '../document/document';\nimport { AngularFirestore } from '../firestore';\n\nexport function validateEventsArray(events?: DocumentChangeType[]) {\n  if (!events || events.length === 0) {\n    events = ['added', 'removed', 'modified'];\n  }\n  return events;\n}\n\n/**\n * AngularFirestoreCollection service\n *\n * This class creates a reference to a Firestore Collection. A reference and a query are provided in\n * in the constructor. The query can be the unqueried reference if no query is desired.The class\n * is generic which gives you type safety for data update methods and data streaming.\n *\n * This class uses Symbol.observable to transform into Observable using Observable.from().\n *\n * This class is rarely used directly and should be created from the AngularFirestore service.\n *\n * Example:\n *\n * const collectionRef = firebase.firestore.collection('stocks');\n * const query = collectionRef.where('price', '>', '0.01');\n * const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);\n *\n * // NOTE!: the updates are performed on the reference not the query\n * await fakeStock.add({ name: 'FAKE', price: 0.01 });\n *\n * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.\n * fakeStock.valueChanges().subscribe(value => console.log(value));\n */\nexport class AngularFirestoreCollection<T= DocumentData> {\n  /**\n   * The constructor takes in a CollectionReference and Query to provide wrapper methods\n   * for data operations and data streaming.\n   *\n   * Note: Data operation methods are done on the reference not the query. This means\n   * when you update data it is not updating data to the window of your query unless\n   * the data fits the criteria of the query. See the AssociatedRefence type for details\n   * on this implication.\n   */\n  constructor(\n    public readonly ref: CollectionReference,\n    private readonly query: Query,\n    private readonly afs: AngularFirestore) { }\n\n  /**\n   * Listen to the latest change in the stream. This method returns changes\n   * as they occur and they are not sorted by query order. This allows you to construct\n   * your own data structure.\n   */\n  stateChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    if (!events || events.length === 0) {\n      return docChanges<T>(this.query, this.afs.schedulers.outsideAngular).pipe(\n        this.afs.keepUnstableUntilFirst\n      );\n    }\n    return docChanges<T>(this.query, this.afs.schedulers.outsideAngular).pipe(\n      map(actions => actions.filter(change => events.indexOf(change.type) > -1)),\n      filter(changes =>  changes.length > 0),\n      this.afs.keepUnstableUntilFirst\n    );\n  }\n\n  /**\n   * Create a stream of changes as they occur it time. This method is similar to stateChanges()\n   * but it collects each event in an array over time.\n   */\n  auditTrail(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    return this.stateChanges(events).pipe(scan((current, action) => [...current, ...action], []));\n  }\n\n  /**\n   * Create a stream of synchronized changes. This method keeps the local array in sorted\n   * query order.\n   */\n  snapshotChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    const validatedEvents = validateEventsArray(events);\n    const scheduledSortedChanges$ = sortedChanges<T>(this.query, validatedEvents, this.afs.schedulers.outsideAngular);\n    return scheduledSortedChanges$.pipe(\n      this.afs.keepUnstableUntilFirst\n    );\n  }\n\n  /**\n   * Listen to all documents in the collection and its possible query as an Observable.\n   *\n   * If the `idField` option is provided, document IDs are included and mapped to the\n   * provided `idField` property name.\n   */\n  valueChanges(): Observable<T[]>;\n  // tslint:disable-next-line:unified-signatures\n  valueChanges({}): Observable<T[]>;\n  valueChanges<K extends string>(options: {idField: K}): Observable<(T & { [T in K]: string })[]>;\n  valueChanges<K extends string>(options: {idField?: K} = {}): Observable<T[]> {\n    return fromCollectionRef<T>(this.query, this.afs.schedulers.outsideAngular)\n      .pipe(\n        map(actions => actions.payload.docs.map(a => {\n          if (options.idField) {\n            return {\n              ...a.data() as {},\n              ...{ [options.idField]: a.id }\n            } as T & { [T in K]: string };\n          } else {\n            return a.data();\n          }\n        })),\n        this.afs.keepUnstableUntilFirst\n      );\n  }\n\n  /**\n   * Retrieve the results of the query once.\n   */\n  get(options?: firestore.GetOptions) {\n    return from(this.query.get(options)).pipe(\n      observeOn(this.afs.schedulers.insideAngular),\n    );\n  }\n\n  /**\n   * Add data to a collection reference.\n   *\n   * Note: Data operation methods are done on the reference not the query. This means\n   * when you update data it is not updating data to the window of your query unless\n   * the data fits the criteria of the query.\n   */\n  add(data: T): Promise<DocumentReference> {\n    return this.ref.add(data);\n  }\n\n  /**\n   * Create a reference to a single document in a collection.\n   */\n  doc<T>(path?: string): AngularFirestoreDocument<T> {\n    return new AngularFirestoreDocument<T>(this.ref.doc(path), this.afs);\n  }\n}\n"]}