@data-weave/backend-firestore 0.4.2 → 0.4.3

package/lib/FirestoreDataManager.d.ts

@@ -0,0 +1,48 @@
+import { Cache } from '@data-weave/datamanager/lib/Cache';
+import { DataManager, WithMetadata } from '@data-weave/datamanager/lib/DataManager';
+import { List, ListPaginationParams } from '@data-weave/datamanager/lib/List';
+import { IdentifiableReference, WithoutId } from '@data-weave/datamanager/lib/Reference';
+import { FirestoreList, FirestoreListContext } from './FirestoreList';
+import { FirestoreSerializedMetadata } from './FirestoreMetadata';
+import { FirestoreReference, FirestoreReferenceContext } from './FirestoreReference';
+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 errorInterceptor?: (error: unknown, ctx: FirestoreReferenceContext | FirestoreListContext) => void;
+    readonly snapshotOptions?: FirestoreTypes.SnapshotOptions;
+    readonly Reference?: typeof FirestoreReference;
+    readonly List?: typeof FirestoreList;
+    readonly listCache?: Cache;
+    readonly refCache?: Cache;
+}
+export interface QueryParams<T extends FirestoreTypes.DocumentData> {
+    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;
+    constructor(firestore: Firestore, collectionPath: string, converter: FirestoreDataConverter<T, SerializedT>, opts?: FirebaseDataManagerOptions | undefined);
+    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>;
+    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;
+}

package/lib/FirestoreDataManager.js

@@ -0,0 +1,223 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreDataManager = void 0;
+const inversify_1 = require("inversify");
+const Cache_1 = require("@data-weave/datamanager/lib/Cache");
+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',
+    Reference: FirestoreReference_1.FirestoreReference,
+    List: FirestoreList_1.FirestoreList,
+};
+let FirestoreDataManager = (() => {
+    let _classDecorators = [(0, inversify_1.injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var FirestoreDataManager = _classThis = class {
+        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 = Object.assign(defaultFirebaseDataManagerOptions, this.opts);
+            this.refCache = this.managerOptions.refCache || new Cache_1.MapCache(100);
+            this.listCache = this.managerOptions.listCache || new Cache_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;
+        }
+        read(id, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (!((_a = this.managerOptions) === null || _a === void 0 ? void 0 : _a.Reference))
+                    throw new Error('ReferenceClass not defined');
+                const ref = this.getRef(id);
+                if (options === null || options === void 0 ? void 0 : options.transaction) {
+                    const snapshot = yield options.transaction.get(this.firestore.doc(this.collection, id));
+                    if (!(0, utils_1.checkIfReferenceExists)(snapshot))
+                        return undefined;
+                    return snapshot.data();
+                }
+                return yield ref.resolve();
+            });
+        }
+        create(data, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                let id = undefined;
+                if (options === null || options === void 0 ? void 0 : options.id) {
+                    id = options === null || options === void 0 ? void 0 : options.id;
+                }
+                else if ((_a = this.managerOptions) === null || _a === void 0 ? void 0 : _a.idResolver) {
+                    id = this.managerOptions.idResolver();
+                }
+                let docRef;
+                let docExists = false;
+                if (id) {
+                    docRef = this.firestore.doc(this.collection, id);
+                    docExists = yield this.preventOverwriteOnCreate(docRef, options);
+                }
+                else {
+                    docRef = this.firestore.doc(this.collection);
+                }
+                const docDataWithMetadata = Object.assign(Object.assign({}, 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 === null || options === void 0 ? void 0 : options.merge };
+                if (options === null || options === void 0 ? void 0 : options.transaction) {
+                    options === null || options === void 0 ? void 0 : options.transaction.set(docRef, docDataWithMetadata, firebaseOptions);
+                }
+                else {
+                    yield this.firestore.setDoc(docRef, docDataWithMetadata, firebaseOptions);
+                }
+                return this.getRef(docRef.id);
+            });
+        }
+        _update(id, data, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const extendedData = Object.assign(Object.assign({}, 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 === null || options === void 0 ? void 0 : options.transaction) {
+                    return options.transaction.update(ref, serializedData);
+                }
+                return this.firestore.updateDoc(ref, serializedData);
+            });
+        }
+        update(id, data, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this._update(id, data, options);
+            });
+        }
+        upsert(id, data, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.create(data, Object.assign(Object.assign({}, options), { id, merge: true }));
+            });
+        }
+        delete(id, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.managerOptions.deleteMode === 'soft') {
+                    yield this._update(id, Object.assign(Object.assign({}, {}), { [FirestoreMetadata_1.FIRESTORE_KEYS.DELETED]: true }), options);
+                    return;
+                }
+                return this.firestore.deleteDoc(this.firestore.doc(this.collection, id));
+            });
+        }
+        getRef(id) {
+            var _a;
+            if (!((_a = this.managerOptions) === null || _a === void 0 ? void 0 : _a.Reference))
+                throw new Error('ReferenceClass not defined');
+            if (this.refCache.has(id)) {
+                return this.refCache.get(id);
+            }
+            const newRef = new this.managerOptions.Reference(this.firestore, this.firestore.doc(this.collection, id), {
+                readMode: this.managerOptions.readMode,
+                errorInterceptor: this.managerOptions.errorInterceptor,
+                snapshotOptions: this.managerOptions.snapshotOptions,
+            });
+            this.refCache.set(id, newRef);
+            return newRef;
+        }
+        _getFilteredQuery(params) {
+            var _a, _b;
+            let compoundQuery = this.collectionQuery;
+            (_a = params === null || params === void 0 ? void 0 : params.filters) === null || _a === void 0 ? void 0 : _a.forEach(filter => {
+                compoundQuery = this.firestore.query(compoundQuery, this.firestore.where(filter[0], filter[1], filter[2]));
+            });
+            (_b = params === null || params === void 0 ? void 0 : params.orderBy) === null || _b === void 0 ? void 0 : _b.forEach(orderBy => {
+                compoundQuery = this.firestore.query(compoundQuery, this.firestore.orderBy(orderBy[0], orderBy[1]));
+            });
+            return compoundQuery;
+        }
+        getList(params) {
+            if (!this.managerOptions.List)
+                throw new Error('ListClass not defined');
+            const compoundQuery = this._getFilteredQuery(params);
+            const key = JSON.stringify(params || {});
+            if (this.listCache.has(key)) {
+                return this.listCache.get(key);
+            }
+            const newList = new this.managerOptions.List(this.firestore, compoundQuery, Object.assign({ readMode: this.managerOptions.readMode, errorInterceptor: this.managerOptions.errorInterceptor }, params));
+            this.listCache.set(key, newList);
+            return newList;
+        }
+        preventOverwriteOnCreate(docRef, createOptions) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const doc = yield this.firestore.getDoc(docRef);
+                const docExists = (0, utils_1.checkIfReferenceExists)(doc);
+                if (docExists && this.managerOptions.preventOverwriteOnCreate && (createOptions === null || createOptions === void 0 ? void 0 : createOptions.merge) !== true) {
+                    throw new Error(`Document already exists - ${doc.ref.path}`);
+                }
+                return docExists;
+            });
+        }
+    };
+    __setFunctionName(_classThis, "FirestoreDataManager");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        FirestoreDataManager = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return FirestoreDataManager = _classThis;
+})();
+exports.FirestoreDataManager = FirestoreDataManager;

package/lib/FirestoreList.d.ts

@@ -0,0 +1,23 @@
+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 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;
+    private readonly query;
+    private readonly options;
+    private unsubscribeFromSnapshot;
+    constructor(firestore: Firestore, query: FirestoreTypes.Query<T, S>, options: FirestoreListOptions<T> & ListPaginationParams);
+    resolve(): Promise<T[]>;
+    protected handleInitialDataChange(values: FirestoreTypes.QueryDocumentSnapshot<T, S>[]): void;
+    protected handleSubsequentDataChanges(changes: FirestoreTypes.DocumentChange<T, S>[]): void;
+    unSubscribe(): void;
+    protected onError(error: unknown): void;
+}

package/lib/FirestoreList.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreList = void 0;
+const datamanager_1 = require("@data-weave/datamanager");
+class FirestoreList extends datamanager_1.LiveList {
+    constructor(firestore, query, options) {
+        super(options);
+        this.firestore = firestore;
+        this.query = query;
+        this.options = options;
+    }
+    resolve() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.readMode) === 'realtime') {
+                let initialLoad = true;
+                return new Promise((resolve, reject) => {
+                    this.unsubscribeFromSnapshot = this.firestore.onSnapshot(this.query, querySnapshot => {
+                        try {
+                            if (initialLoad) {
+                                initialLoad = false;
+                                this.handleInitialDataChange(querySnapshot.docs);
+                            }
+                            else {
+                                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);
+                            reject(error);
+                        }
+                    }, error => {
+                        this.onError(error);
+                        reject(error);
+                    });
+                });
+            }
+            else {
+                const snapshot = yield this.firestore.getDocs(this.query);
+                this.handleInitialDataChange(snapshot.docs);
+                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() {
+        var _a;
+        (_a = this.unsubscribeFromSnapshot) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.setStale();
+    }
+    onError(error) {
+        var _a, _b, _c, _d, _e;
+        // Try to provide useful collection details using internal properties
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        console.error(`FirestoreList Collection: ${(_b = (_a = this.query) === null || _a === void 0 ? void 0 : _a._collectionPath) === null || _b === void 0 ? void 0 : _b.id} error`, error);
+        (_d = (_c = this.options) === null || _c === void 0 ? void 0 : _c.errorInterceptor) === null || _d === void 0 ? void 0 : _d.call(_c, error, {
+            query: this.query,
+            readMode: (_e = this.options) === null || _e === void 0 ? void 0 : _e.readMode,
+            type: 'list',
+        });
+        super.onError(error);
+    }
+}
+exports.FirestoreList = FirestoreList;

package/lib/FirestoreMetadata.d.ts

@@ -0,0 +1,32 @@
+import { Metadata, WithoutId } from '@data-weave/datamanager';
+import { DocumentData, FirestoreQuery, FirestoreTypes, FirestoreWhere, InternalFirestoreDataConverter, WithFieldValue } from './firestoreTypes';
+declare enum FIRESTORE_INTERAL_KEYS {
+    DELETED = "__deleted",
+    CREATED_AT = "__createdAt",
+    UPDATED_AT = "__updatedAt"
+}
+export declare enum FIRESTORE_KEYS {
+    DELETED = "deleted",
+    CREATED_AT = "createdAt",
+    UPDATED_AT = "updatedAt"
+}
+export type FirestoreSerializedMetadata = {
+    [FIRESTORE_INTERAL_KEYS.DELETED]: boolean;
+    [FIRESTORE_INTERAL_KEYS.CREATED_AT]: FirestoreTypes.Timestamp;
+    [FIRESTORE_INTERAL_KEYS.UPDATED_AT]: FirestoreTypes.Timestamp;
+};
+export declare class FirestoreMetadataConverter implements InternalFirestoreDataConverter<Metadata, FirestoreSerializedMetadata> {
+    toFirestore(data: WithFieldValue<WithoutId<Metadata>>): {
+        __deleted: FirestoreTypes.FieldValue | FirestoreTypes.WithFieldValue<boolean>;
+        __createdAt: FirestoreTypes.Timestamp;
+        __updatedAt: FirestoreTypes.Timestamp;
+    };
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<DocumentData, DocumentData>, options: FirestoreTypes.SnapshotOptions): {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        deleted: boolean;
+    };
+}
+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 {};

package/lib/FirestoreMetadata.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryNotDeleted = exports.FirestoreMetadataConverter = exports.FIRESTORE_KEYS = void 0;
+var FIRESTORE_INTERAL_KEYS;
+(function (FIRESTORE_INTERAL_KEYS) {
+    FIRESTORE_INTERAL_KEYS["DELETED"] = "__deleted";
+    FIRESTORE_INTERAL_KEYS["CREATED_AT"] = "__createdAt";
+    FIRESTORE_INTERAL_KEYS["UPDATED_AT"] = "__updatedAt";
+})(FIRESTORE_INTERAL_KEYS || (FIRESTORE_INTERAL_KEYS = {}));
+var FIRESTORE_KEYS;
+(function (FIRESTORE_KEYS) {
+    FIRESTORE_KEYS["DELETED"] = "deleted";
+    FIRESTORE_KEYS["CREATED_AT"] = "createdAt";
+    FIRESTORE_KEYS["UPDATED_AT"] = "updatedAt";
+})(FIRESTORE_KEYS || (exports.FIRESTORE_KEYS = FIRESTORE_KEYS = {}));
+class FirestoreMetadataConverter {
+    toFirestore(data) {
+        return {
+            [FIRESTORE_INTERAL_KEYS.DELETED]: data[FIRESTORE_KEYS.DELETED],
+            // Cast: Firestore handles conversion from Date to Timestamp internally
+            [FIRESTORE_INTERAL_KEYS.CREATED_AT]: data[FIRESTORE_KEYS.CREATED_AT],
+            [FIRESTORE_INTERAL_KEYS.UPDATED_AT]: data[FIRESTORE_KEYS.UPDATED_AT],
+        };
+    }
+    fromFirestore(snapshot, options) {
+        var _a, _b;
+        const data = snapshot.data(options);
+        return {
+            id: snapshot.ref.id,
+            // TODO: add warning in case data type is not as expected
+            createdAt: (_a = data[FIRESTORE_INTERAL_KEYS.CREATED_AT]) === null || _a === void 0 ? void 0 : _a.toDate(),
+            updatedAt: (_b = data[FIRESTORE_INTERAL_KEYS.UPDATED_AT]) === null || _b === void 0 ? void 0 : _b.toDate(),
+            deleted: data[FIRESTORE_INTERAL_KEYS.DELETED],
+        };
+    }
+}
+exports.FirestoreMetadataConverter = FirestoreMetadataConverter;
+const queryNotDeleted = (query, firestoreQuery, firestoreWhere) => firestoreQuery(query, firestoreWhere(FIRESTORE_INTERAL_KEYS.DELETED, '==', false));
+exports.queryNotDeleted = queryNotDeleted;

package/lib/FirestoreReference.d.ts

@@ -0,0 +1,27 @@
+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 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;
+    private readonly docRef;
+    readonly options: FirestoreReferenceOptions<T>;
+    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;
+    private parseDocumentSnapshot;
+}

package/lib/FirestoreReference.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreReference = void 0;
+const datamanager_1 = require("@data-weave/datamanager");
+const utils_1 = require("./utils");
+class FirestoreReference extends datamanager_1.LiveReference {
+    constructor(firestore, docRef, options) {
+        super(options);
+        this.firestore = firestore;
+        this.docRef = docRef;
+        this.options = options;
+    }
+    resolve() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.readMode) === 'realtime') {
+                return new Promise((res, reject) => {
+                    this.unsubscribeFromSnapshot = this.firestore.onSnapshot(this.docRef, documentSnapshot => {
+                        try {
+                            this.onUpdate(this.parseDocumentSnapshot(documentSnapshot));
+                            // TODO: When calling ".resolve()" with realtime listener,
+                            // the snapshot data might be stale from cache.
+                            res(this.value);
+                        }
+                        catch (error) {
+                            this.onError(error);
+                            reject(error);
+                        }
+                    }, error => {
+                        this.onError(error);
+                        reject(error);
+                    });
+                });
+            }
+            try {
+                const doc = yield this.firestore.getDoc(this.docRef);
+                this.onUpdate(this.parseDocumentSnapshot(doc));
+            }
+            catch (error) {
+                this.onError(error);
+                throw error;
+            }
+            return this.value;
+        });
+    }
+    get id() {
+        return this.docRef.id;
+    }
+    get path() {
+        return this.docRef.path;
+    }
+    onError(error) {
+        var _a, _b, _c, _d;
+        console.error(`FirestoreReference error ${this.docRef.path}`, error);
+        (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.errorInterceptor) === null || _b === void 0 ? void 0 : _b.call(_a, error, {
+            path: this.docRef.path,
+            id: this.docRef.id,
+            readMode: (_c = this.options) === null || _c === void 0 ? void 0 : _c.readMode,
+            snapshotOptions: (_d = this.options) === null || _d === void 0 ? void 0 : _d.snapshotOptions,
+            type: 'reference',
+        });
+        super.onError(error);
+    }
+    unSubscribe() {
+        var _a;
+        (_a = this.unsubscribeFromSnapshot) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.setStale();
+    }
+    parseDocumentSnapshot(docSnapshot) {
+        var _a;
+        if (!(0, utils_1.checkIfReferenceExists)(docSnapshot))
+            throw new Error(`Document does not exist ${this.docRef.path}`);
+        return docSnapshot.data((_a = this.options) === null || _a === void 0 ? void 0 : _a.snapshotOptions);
+    }
+}
+exports.FirestoreReference = FirestoreReference;