@data-weave/backend-firestore 0.4.27 → 0.6.0

package/dist/FirestoreAdminAdapter.d.ts

@@ -0,0 +1,31 @@
+import { type AggregateResult, type AggregateSpec, FieldValues, Firestore, FirestoreApp, FirestoreTypes } from './firestoreTypes';
+export declare class FirestoreAdminAdapter extends Firestore {
+    readonly firestore: FirestoreApp;
+    readonly fieldValues: FieldValues;
+    app: FirestoreApp;
+    constructor(firestore: FirestoreApp, fieldValues: FieldValues);
+    collection(reference: any, path: string): any;
+    getDocs(reference: any): any;
+    getAggregateFromServer<Spec extends AggregateSpec>(query: any, spec: Spec): Promise<AggregateResult<Spec>>;
+    getDoc(reference: any, path?: string): any;
+    serverTimestamp(): FirestoreTypes.FieldValue;
+    increment(n: number): FirestoreTypes.FieldValue;
+    query(reference: any, filter: any): any;
+    where(field: string | FirestoreTypes.FieldPath, op: string, value: unknown): any;
+    limit(limit: number): {
+        type: string;
+        limit: number;
+    };
+    orderBy(orderBy: string, direction: FirestoreTypes.OrderByDirection): {
+        type: string;
+        field: string;
+        direction: FirestoreTypes.OrderByDirection;
+    };
+    setDoc(reference: any, data: any, options?: FirestoreTypes.SetOptions): any;
+    updateDoc(reference: any, data: any): any;
+    deleteDoc(reference: any): any;
+    doc(reference: any, path?: string): any;
+    onSnapshot(reference: any, onNext: (snapshot: any) => void, onError?: (error: Error) => void): any;
+    runTransaction<T>(firestore: FirestoreApp, transaction: (transaction: FirestoreTypes.Transaction) => Promise<T>, options?: FirestoreTypes.TransactionOptions): Promise<T>;
+}
+//# sourceMappingURL=FirestoreAdminAdapter.d.ts.map

package/dist/FirestoreAdminAdapter.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreAdminAdapter = void 0;
+const firestore_1 = require("firebase-admin/firestore");
+const firestoreTypes_1 = require("./firestoreTypes");
+/*
+ *  FirestoreAdminAdapter creates an interface between modular and namespaced
+ *  firestore libraries.
+ *   - admin sdk doesn't support modular imports
+ */
+// TODO: add types
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class FirestoreAdminAdapter extends firestoreTypes_1.Firestore {
+    firestore;
+    fieldValues;
+    app;
+    constructor(firestore, fieldValues) {
+        super();
+        this.firestore = firestore;
+        this.fieldValues = fieldValues;
+        this.app = firestore;
+        this.fieldValues = fieldValues;
+    }
+    collection(reference, path) {
+        return reference.collection(path);
+    }
+    getDocs(reference) {
+        return reference.get();
+    }
+    async getAggregateFromServer(query, spec) {
+        const adminSpec = Object.fromEntries(Object.keys(spec).map(alias => {
+            const fieldSpec = spec[alias];
+            if (fieldSpec.type === 'count') {
+                return [alias, firestore_1.AggregateField.count()];
+            }
+            return [alias, firestore_1.AggregateField[fieldSpec.type](fieldSpec.field)];
+        }));
+        const snapshot = await query.aggregate(adminSpec).get();
+        return snapshot.data();
+    }
+    getDoc(reference, path) {
+        return reference.get(path);
+    }
+    serverTimestamp() {
+        return this.fieldValues.serverTimestamp();
+    }
+    increment(n) {
+        return this.fieldValues.increment(n);
+    }
+    query(reference, filter) {
+        if (filter.type === 'where') {
+            return reference.where(filter.field, filter.op, filter.value);
+        }
+        if (filter.type === 'orderBy') {
+            return reference.orderBy(filter.field, filter.direction);
+        }
+        if (filter.type === 'limit') {
+            return reference.limit(filter.limit);
+        }
+    }
+    where(field, op, value) {
+        return {
+            type: 'where',
+            field,
+            op,
+            value,
+        };
+    }
+    limit(limit) {
+        return {
+            type: 'limit',
+            limit,
+        };
+    }
+    orderBy(orderBy, direction) {
+        return {
+            type: 'orderBy',
+            field: orderBy,
+            direction,
+        };
+    }
+    setDoc(reference, data, options) {
+        return reference.set(data, options);
+    }
+    updateDoc(reference, data) {
+        return reference.update(data);
+    }
+    deleteDoc(reference) {
+        return reference.delete();
+    }
+    doc(reference, path) {
+        if (!path)
+            return reference.doc();
+        return reference.doc(path);
+    }
+    onSnapshot(reference, onNext, onError) {
+        return reference.onSnapshot(onNext, onError);
+    }
+    runTransaction(firestore, transaction, options) {
+        // firestore.runTransaction is Admin SDK specific
+        return firestore.runTransaction(transaction, options);
+    }
+}
+exports.FirestoreAdminAdapter = FirestoreAdminAdapter;
+/* eslint-enable @typescript-eslint/no-explicit-any */
+//# sourceMappingURL=FirestoreAdminAdapter.js.map

package/dist/FirestoreDataManager.d.ts

@@ -0,0 +1,76 @@
+import { Cache, DataManager, IdentifiableReference, List, ListPaginationParams, LiveList, LiveReference, NumericKeys, WithMetadata, WithoutId } from '@data-weave/datamanager';
+import { FirestoreSerializedMetadata } from './FirestoreMetadata';
+import { FilterBy, FirebaseCreateOptions, Firestore, FirestoreDataConverter, FirestoreReadMode, FirestoreReadOptions, FirestoreTypes, FirestoreWriteOptions, OrderBy, WithFieldValue } from './firestoreTypes';
+export type FirebaseDataManagerDeleteMode = 'soft' | 'hard';
+export interface FirebaseDataManagerOptions {
+    readonly idResolver?: () => string;
+    readonly deleteMode: FirebaseDataManagerDeleteMode;
+    readonly readMode: FirestoreReadMode;
+    readonly preventOverwriteOnCreate: boolean;
+    readonly snapshotOptions?: FirestoreTypes.SnapshotOptions;
+    readonly listCache?: Cache;
+    readonly refCache?: Cache;
+    readonly disableCache?: boolean;
+    readonly ReferenceProxy?: <T>(reference: LiveReference<T>) => LiveReference<T>;
+    readonly ListProxy?: <T>(list: LiveList<T>) => LiveList<T>;
+}
+export interface QueryParams<T> {
+    readonly filters?: Array<FilterBy<T & FirestoreSerializedMetadata>>;
+    readonly orderBy?: Array<OrderBy<T & FirestoreSerializedMetadata>>;
+}
+export declare class FirestoreDataManager<T extends FirestoreTypes.DocumentData, SerializedT extends FirestoreTypes.DocumentData = T> implements DataManager<T> {
+    private readonly firestore;
+    private readonly collectionPath;
+    private readonly converter;
+    private readonly opts?;
+    private mergedConverter;
+    private collection;
+    private collectionQuery;
+    private managerOptions;
+    private refCache;
+    private listCache;
+    private referenceOptions;
+    constructor(firestore: Firestore, collectionPath: string, converter: FirestoreDataConverter<T, SerializedT>, opts?: Partial<FirebaseDataManagerOptions> | undefined);
+    private validateOptions;
+    read(id: string, options?: FirestoreReadOptions): Promise<WithMetadata<T> | undefined>;
+    create(data: WithFieldValue<WithoutId<T>>, options?: FirebaseCreateOptions): Promise<IdentifiableReference<WithMetadata<T>>>;
+    private _update;
+    update(id: string, data: WithoutId<Partial<WithFieldValue<T>>>, options?: FirestoreWriteOptions): Promise<void>;
+    upsert(id: string, data: WithFieldValue<WithoutId<T>>, options?: FirestoreWriteOptions): Promise<void>;
+    count(params?: QueryParams<SerializedT>): Promise<number>;
+    /**
+     * Sum the values of a field in the collection
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    sum(field: NumericKeys<T>, params?: QueryParams<SerializedT>): Promise<number>;
+    /**
+     * Calculate the average value of a field in the collection.
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    average(field: NumericKeys<T>, params?: QueryParams<SerializedT>): Promise<number | null>;
+    /**
+     * Read the minimum value for a field in the collection.
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    min<K extends string & keyof T>(field: K, params?: QueryParams<SerializedT>): Promise<T[K] | null>;
+    /**
+     * Read the maximum value for a field in the collection.
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    max<K extends string & keyof T>(field: K, params?: QueryParams<SerializedT>): Promise<T[K] | null>;
+    exists(id: string): Promise<boolean>;
+    delete(id: string, options?: FirestoreWriteOptions): Promise<void>;
+    getRef(id: string): IdentifiableReference<WithMetadata<T>>;
+    private _getFilteredQuery;
+    getList(params?: QueryParams<SerializedT> & ListPaginationParams): List<WithMetadata<T>>;
+    private preventOverwriteOnCreate;
+}
+//# sourceMappingURL=FirestoreDataManager.d.ts.map

package/dist/FirestoreDataManager.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreDataManager = void 0;
+const datamanager_1 = require("@data-weave/datamanager");
+const errors_1 = require("./errors");
+const FirestoreList_1 = require("./FirestoreList");
+const FirestoreMetadata_1 = require("./FirestoreMetadata");
+const FirestoreReference_1 = require("./FirestoreReference");
+const utils_1 = require("./utils");
+const defaultFirebaseDataManagerOptions = {
+    deleteMode: 'soft',
+    preventOverwriteOnCreate: true,
+    readMode: 'static',
+};
+class FirestoreDataManager {
+    firestore;
+    collectionPath;
+    converter;
+    opts;
+    mergedConverter;
+    collection;
+    collectionQuery;
+    managerOptions;
+    refCache;
+    listCache;
+    referenceOptions;
+    constructor(firestore, collectionPath, converter, opts) {
+        this.firestore = firestore;
+        this.collectionPath = collectionPath;
+        this.converter = converter;
+        this.opts = opts;
+        // @ts-expect-error - Force merge FirestoreDataConverter and InternalFirestoreDataConverter
+        this.mergedConverter = new utils_1.MergeConverters(this.converter, new FirestoreMetadata_1.FirestoreMetadataConverter());
+        this.managerOptions = this.validateOptions({ ...defaultFirebaseDataManagerOptions, ...this.opts });
+        this.refCache = this.managerOptions.refCache || new datamanager_1.MapCache(100);
+        this.listCache = this.managerOptions.listCache || new datamanager_1.MapCache(100);
+        this.collection = this.firestore
+            .collection(this.firestore.app, this.collectionPath)
+            .withConverter(this.mergedConverter);
+        this.collectionQuery =
+            this.managerOptions.deleteMode === 'soft'
+                ? (0, FirestoreMetadata_1.queryNotDeleted)(this.collection, this.firestore.query, this.firestore.where)
+                : this.collection;
+        this.referenceOptions = {
+            readMode: this.managerOptions.readMode,
+            snapshotOptions: this.managerOptions.snapshotOptions,
+        };
+    }
+    validateOptions(options) {
+        return options;
+    }
+    async read(id, options) {
+        const ref = this.getRef(id);
+        if (options?.transaction) {
+            const snapshot = await options.transaction.get(this.firestore.doc(this.collection, id));
+            if (!(0, utils_1.checkIfReferenceExists)(snapshot))
+                return undefined;
+            return snapshot.data(this.referenceOptions.snapshotOptions);
+        }
+        return await ref.resolve();
+    }
+    async create(data, options) {
+        let id = undefined;
+        if (options?.id) {
+            id = options?.id;
+        }
+        else if (this.managerOptions?.idResolver) {
+            id = this.managerOptions.idResolver();
+        }
+        let docRef;
+        let docExists = false;
+        if (id) {
+            docRef = this.firestore.doc(this.collection, id);
+            docExists = await this.preventOverwriteOnCreate(docRef, options);
+        }
+        else {
+            docRef = this.firestore.doc(this.collection);
+        }
+        const docDataWithMetadata = {
+            ...data,
+            [FirestoreMetadata_1.FIRESTORE_KEYS.CREATED_AT]: docExists ? undefined : this.firestore.serverTimestamp(),
+            [FirestoreMetadata_1.FIRESTORE_KEYS.UPDATED_AT]: this.firestore.serverTimestamp(),
+            [FirestoreMetadata_1.FIRESTORE_KEYS.DELETED]: false,
+        };
+        const firebaseOptions = { merge: options?.merge };
+        if (options?.transaction) {
+            options?.transaction.set(docRef, docDataWithMetadata, firebaseOptions);
+        }
+        else {
+            await this.firestore.setDoc(docRef, docDataWithMetadata, firebaseOptions);
+        }
+        return this.getRef(docRef.id);
+    }
+    async _update(id, data, options) {
+        const extendedData = {
+            ...data,
+            [FirestoreMetadata_1.FIRESTORE_KEYS.UPDATED_AT]: this.firestore.serverTimestamp(),
+        };
+        // Firestore update method doesn't call converter like setDoc does, so we need to serialize the data manually.
+        const serializedData = this.mergedConverter.toFirestore(extendedData);
+        const ref = this.firestore.doc(this.collection, id);
+        if (options?.transaction) {
+            return options.transaction.update(ref, serializedData);
+        }
+        return this.firestore.updateDoc(ref, serializedData);
+    }
+    async update(id, data, options) {
+        await this._update(id, data, options);
+    }
+    async upsert(id, data, options) {
+        await this.create(data, { ...options, id, merge: true });
+    }
+    async count(params) {
+        const compoundQuery = this._getFilteredQuery(params);
+        const result = await this.firestore.getAggregateFromServer(compoundQuery, {
+            result: { type: 'count' },
+        });
+        return result.result ?? 0;
+    }
+    /**
+     * Sum the values of a field in the collection
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    async sum(field, params) {
+        const compoundQuery = this._getFilteredQuery(params);
+        const result = await this.firestore.getAggregateFromServer(compoundQuery, {
+            result: { type: 'sum', field },
+        });
+        return result.result ?? 0;
+    }
+    /**
+     * Calculate the average value of a field in the collection.
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    async average(field, params) {
+        const compoundQuery = this._getFilteredQuery(params);
+        const result = await this.firestore.getAggregateFromServer(compoundQuery, {
+            result: { type: 'average', field },
+        });
+        return result.result ?? null;
+    }
+    /**
+     * Read the minimum value for a field in the collection.
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    async min(field, params) {
+        const compoundQuery = this._getFilteredQuery(params);
+        const limitedQuery = this.firestore.query(this.firestore.query(compoundQuery, this.firestore.orderBy(field, 'asc')), this.firestore.limit(1));
+        const snapshot = await this.firestore.getDocs(limitedQuery);
+        if (snapshot.empty)
+            return null;
+        return snapshot.docs[0].get(field) ?? null;
+    }
+    /**
+     * Read the maximum value for a field in the collection.
+     *
+     * NOTE: `field` is resolved against Firestore (serialized) field names.
+     * If user model fields differ from serialized fields, this can target a different field than expected.
+     */
+    async max(field, params) {
+        const compoundQuery = this._getFilteredQuery(params);
+        const limitedQuery = this.firestore.query(this.firestore.query(compoundQuery, this.firestore.orderBy(field, 'desc')), this.firestore.limit(1));
+        const snapshot = await this.firestore.getDocs(limitedQuery);
+        if (snapshot.empty)
+            return null;
+        return snapshot.docs[0].get(field) ?? null;
+    }
+    async exists(id) {
+        const ref = this.firestore.doc(this.collection, id);
+        const snapshot = await this.firestore.getDoc(ref);
+        return (0, utils_1.checkIfReferenceExists)(snapshot);
+    }
+    async delete(id, options) {
+        if (this.managerOptions.deleteMode === 'soft') {
+            await this._update(id, {
+                ...{},
+                [FirestoreMetadata_1.FIRESTORE_KEYS.DELETED]: true,
+            }, options);
+            return;
+        }
+        if (options?.transaction) {
+            options.transaction.delete(this.firestore.doc(this.collection, id));
+        }
+        else {
+            await this.firestore.deleteDoc(this.firestore.doc(this.collection, id));
+        }
+    }
+    getRef(id) {
+        if (this.refCache.has(id) && !this.managerOptions.disableCache) {
+            return this.refCache.get(id);
+        }
+        const newRef = new FirestoreReference_1.FirestoreReference(this.firestore, this.firestore.doc(this.collection, id), this.referenceOptions);
+        const ref = this.managerOptions.ReferenceProxy ? this.managerOptions.ReferenceProxy(newRef) : newRef;
+        if (!this.managerOptions.disableCache) {
+            this.refCache.set(id, ref);
+        }
+        return ref;
+    }
+    _getFilteredQuery(params) {
+        let compoundQuery = this.collectionQuery;
+        params?.filters?.forEach(filter => {
+            compoundQuery = this.firestore.query(compoundQuery, this.firestore.where(filter[0], filter[1], filter[2]));
+        });
+        params?.orderBy?.forEach(orderBy => {
+            compoundQuery = this.firestore.query(compoundQuery, this.firestore.orderBy(orderBy[0], orderBy[1]));
+        });
+        return compoundQuery;
+    }
+    getList(params) {
+        const compoundQuery = this._getFilteredQuery(params);
+        const key = JSON.stringify(params || {});
+        if (this.listCache.has(key) && !this.managerOptions.disableCache) {
+            return this.listCache.get(key);
+        }
+        const newList = new FirestoreList_1.FirestoreList(this.firestore, compoundQuery, {
+            readMode: this.managerOptions.readMode,
+            ...params,
+        });
+        const list = this.managerOptions.ListProxy ? this.managerOptions.ListProxy(newList) : newList;
+        if (!this.managerOptions.disableCache) {
+            this.listCache.set(key, list);
+        }
+        return list;
+    }
+    async preventOverwriteOnCreate(docRef, createOptions) {
+        if (!this.managerOptions.preventOverwriteOnCreate)
+            return false;
+        const doc = await this.firestore.getDoc(docRef);
+        const docExists = (0, utils_1.checkIfReferenceExists)(doc);
+        if (docExists && createOptions?.merge !== true) {
+            throw new errors_1.FirestoreDataManagerError(`Cannot create document at "${doc.ref.path}": document already exists. Use 'merge: true' or disable 'preventOverwriteOnCreate' to allow overwriting.`);
+        }
+        return docExists;
+    }
+}
+exports.FirestoreDataManager = FirestoreDataManager;
+//# sourceMappingURL=FirestoreDataManager.js.map

package/{lib → dist}/FirestoreList.d.ts

@@ -1,13 +1,8 @@
 import { ListPaginationParams, LiveList, LiveListOptions } from '@data-weave/datamanager';
 import { DocumentData, Firestore, FirestoreReadMode, FirestoreTypes } from './firestoreTypes';
-export interface FirestoreListContext {
-    query: FirestoreTypes.Query<unknown>;
-    readMode?: FirestoreReadMode;
-    type: 'list';
-}
+export type { FirestoreListContext } from './errors';
 export interface FirestoreListOptions<T> extends LiveListOptions<T> {
     readMode?: FirestoreReadMode;
-    errorInterceptor?: (error: unknown, ctx: FirestoreListContext) => void;
 }
 export declare class FirestoreList<T extends DocumentData, S extends DocumentData> extends LiveList<T> {
     private readonly firestore;
@@ -18,6 +13,7 @@ export declare class FirestoreList<T extends DocumentData, S extends DocumentDat
     resolve(): Promise<T[]>;
     protected handleInitialDataChange(values: FirestoreTypes.QueryDocumentSnapshot<T, S>[]): void;
     protected handleSubsequentDataChanges(changes: FirestoreTypes.DocumentChange<T, S>[]): void;
-    unSubscribe(): void;
+    unsubscribe(): void;
     protected onError(error: unknown): void;
 }
+//# sourceMappingURL=FirestoreList.d.ts.map

package/dist/FirestoreList.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreList = void 0;
+const datamanager_1 = require("@data-weave/datamanager");
+const errors_1 = require("./errors");
+class FirestoreList extends datamanager_1.LiveList {
+    firestore;
+    query;
+    options;
+    unsubscribeFromSnapshot;
+    constructor(firestore, query, options) {
+        super(options);
+        this.firestore = firestore;
+        this.query = query;
+        this.options = options;
+    }
+    async resolve() {
+        if (this.options?.readMode === 'realtime') {
+            let initialLoad = true;
+            return new Promise(resolve => {
+                // Unsubscribe from any existing snapshot listener
+                if (this.unsubscribeFromSnapshot) {
+                    this.unsubscribeFromSnapshot();
+                }
+                this.unsubscribeFromSnapshot = this.firestore.onSnapshot(this.query, querySnapshot => {
+                    try {
+                        if (initialLoad) {
+                            initialLoad = false;
+                            this.handleInitialDataChange(querySnapshot.docs);
+                        }
+                        else {
+                            // handle every change as inital dataload
+                            this.handleInitialDataChange(querySnapshot.docs);
+                            // this.handleSubsequentDataChanges(querySnapshot.docChanges())
+                        }
+                        // TODO: When calling ".resolve()" with realtime listener,
+                        // the snapshot data might be stale from cache.
+                        resolve(this.values);
+                    }
+                    catch (error) {
+                        this.onError(error);
+                        resolve(this.values);
+                    }
+                }, error => {
+                    this.onError(error);
+                    resolve(this.values);
+                });
+            });
+        }
+        else {
+            try {
+                const snapshot = await this.firestore.getDocs(this.query);
+                this.handleInitialDataChange(snapshot.docs);
+                return this.values;
+            }
+            catch (error) {
+                this.onError(error);
+            }
+        }
+        return this.values;
+    }
+    handleInitialDataChange(values) {
+        const newValues = values.map(v => v.data());
+        this.onUpdateAll(newValues);
+    }
+    handleSubsequentDataChanges(changes) {
+        changes.forEach(change => {
+            if (change.type === 'added') {
+                this.onAddAtIndex(change.newIndex, change.doc.data());
+            }
+            else if (change.type === 'modified') {
+                this.onUpdateAtIndex(change.newIndex, change.doc.data());
+            }
+            else if (change.type === 'removed') {
+                this.onRemoveAtIndex(change.oldIndex);
+            }
+        });
+        // TODO: handle onUpdate in the parent class - make sure it's only called once after all changes are processed
+        this.onUpdate();
+    }
+    unsubscribe() {
+        this.unsubscribeFromSnapshot?.();
+        this.setStale();
+    }
+    onError(error) {
+        const wrapped = new errors_1.FirestoreListError(error, {
+            query: this.query,
+            readMode: this.options?.readMode,
+            type: 'list',
+        });
+        super.onError(wrapped);
+    }
+}
+exports.FirestoreList = FirestoreList;
+//# sourceMappingURL=FirestoreList.js.map

package/{lib → dist}/FirestoreMetadata.d.ts

@@ -30,3 +30,4 @@ export declare class FirestoreMetadataConverter implements InternalFirestoreData
 }
 export declare const queryNotDeleted: <T extends DocumentData, SerializedT extends DocumentData>(query: FirestoreTypes.Query<T, SerializedT>, firestoreQuery: FirestoreQuery<T, SerializedT>, firestoreWhere: FirestoreWhere) => FirestoreTypes.Query<T, SerializedT>;
 export {};
+//# sourceMappingURL=FirestoreMetadata.d.ts.map

package/{lib → dist}/FirestoreMetadata.js

@@ -23,13 +23,12 @@ class FirestoreMetadataConverter {
         };
     }
     fromFirestore(snapshot, options) {
-        var _a, _b, _c, _d;
         const data = snapshot.data(options);
         return {
             id: snapshot.ref.id,
             // TODO: add warning in case data type is not as expected
-            createdAt: (_b = (_a = data[FIRESTORE_INTERAL_KEYS.CREATED_AT]) === null || _a === void 0 ? void 0 : _a.toDate()) !== null && _b !== void 0 ? _b : new Date(),
-            updatedAt: (_d = (_c = data[FIRESTORE_INTERAL_KEYS.UPDATED_AT]) === null || _c === void 0 ? void 0 : _c.toDate()) !== null && _d !== void 0 ? _d : new Date(),
+            createdAt: data[FIRESTORE_INTERAL_KEYS.CREATED_AT]?.toDate() ?? new Date(),
+            updatedAt: data[FIRESTORE_INTERAL_KEYS.UPDATED_AT]?.toDate() ?? new Date(),
             deleted: data[FIRESTORE_INTERAL_KEYS.DELETED],
         };
     }
@@ -37,3 +36,4 @@ class FirestoreMetadataConverter {
 exports.FirestoreMetadataConverter = FirestoreMetadataConverter;
 const queryNotDeleted = (query, firestoreQuery, firestoreWhere) => firestoreQuery(query, firestoreWhere(FIRESTORE_INTERAL_KEYS.DELETED, '==', false));
 exports.queryNotDeleted = queryNotDeleted;
+//# sourceMappingURL=FirestoreMetadata.js.map

package/{lib → dist}/FirestoreReference.d.ts

@@ -1,16 +1,9 @@
 import { LiveReference, LiveReferenceOptions } from '@data-weave/datamanager';
 import { DocumentData, Firestore, FirestoreReadMode, FirestoreTypes } from './firestoreTypes';
-export interface FirestoreReferenceContext {
-    path: string;
-    id: string;
-    readMode?: FirestoreReadMode;
-    snapshotOptions?: FirestoreTypes.SnapshotOptions;
-    type: 'reference';
-}
+export type { FirestoreReferenceContext } from './errors';
 export interface FirestoreReferenceOptions<T> extends LiveReferenceOptions<T> {
     readMode?: FirestoreReadMode;
     snapshotOptions?: FirestoreTypes.SnapshotOptions;
-    errorInterceptor?: (error: unknown, ctx: FirestoreReferenceContext) => void;
 }
 export declare class FirestoreReference<T extends DocumentData, S extends DocumentData> extends LiveReference<T> {
     private readonly firestore;
@@ -19,9 +12,9 @@ export declare class FirestoreReference<T extends DocumentData, S extends Docume
     private unsubscribeFromSnapshot;
     constructor(firestore: Firestore, docRef: FirestoreTypes.DocumentReference<T, S>, options: FirestoreReferenceOptions<T>);
     resolve(): Promise<T | undefined>;
-    get id(): string;
     get path(): string;
     protected onError(error: unknown): void;
-    unSubscribe(): void;
+    unsubscribe(): void;
     private parseDocumentSnapshot;
 }
+//# sourceMappingURL=FirestoreReference.d.ts.map