@data-weave/backend-firestore 0.4.2 → 0.4.5

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/src/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.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 src_1 = require("@data-weave/datamanager/src");
+class FirestoreList extends src_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.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.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 src_1 = require("@data-weave/datamanager/src");
+const utils_1 = require("./utils");
+class FirestoreReference extends src_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;

package/lib/firestoreTypes.js

@@ -0,0 +1,130 @@
+"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 __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.DummyFirestoreFunctions = exports.FirestoreFunctions = exports.FirestoreSettings = exports.Firestore = exports.FirestoreApp = exports.FieldValues = exports.Transaction = exports.FieldValue = void 0;
+const firestore_1 = require("@google-cloud/firestore");
+Object.defineProperty(exports, "FieldValue", { enumerable: true, get: function () { return firestore_1.FieldValue; } });
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return firestore_1.Transaction; } });
+const inversify_1 = require("inversify");
+class FieldValues {
+}
+exports.FieldValues = FieldValues;
+class FirestoreApp {
+}
+exports.FirestoreApp = FirestoreApp;
+let Firestore = (() => {
+    let _classDecorators = [(0, inversify_1.injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Firestore = _classThis = class {
+    };
+    __setFunctionName(_classThis, "Firestore");
+    (() => {
+        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);
+        Firestore = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return Firestore = _classThis;
+})();
+exports.Firestore = Firestore;
+let FirestoreSettings = (() => {
+    let _classDecorators = [(0, inversify_1.injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var FirestoreSettings = _classThis = class {
+    };
+    __setFunctionName(_classThis, "FirestoreSettings");
+    (() => {
+        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);
+        FirestoreSettings = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return FirestoreSettings = _classThis;
+})();
+exports.FirestoreSettings = FirestoreSettings;
+let FirestoreFunctions = (() => {
+    let _classDecorators = [(0, inversify_1.injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var FirestoreFunctions = _classThis = class {
+    };
+    __setFunctionName(_classThis, "FirestoreFunctions");
+    (() => {
+        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);
+        FirestoreFunctions = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return FirestoreFunctions = _classThis;
+})();
+exports.FirestoreFunctions = FirestoreFunctions;
+let DummyFirestoreFunctions = (() => {
+    let _classDecorators = [(0, inversify_1.injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var DummyFirestoreFunctions = _classThis = class {
+        httpsCallable() {
+            return () => {
+                throw new Error('httpsCallable not implemented - DummyFirestoreFunctions');
+            };
+        }
+        useEmulator() { }
+        useFunctionsEmulator() { }
+    };
+    __setFunctionName(_classThis, "DummyFirestoreFunctions");
+    (() => {
+        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);
+        DummyFirestoreFunctions = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return DummyFirestoreFunctions = _classThis;
+})();
+exports.DummyFirestoreFunctions = DummyFirestoreFunctions;

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FirestoreDataManager"), exports);
+__exportStar(require("./FirestoreList"), exports);
+__exportStar(require("./FirestoreMetadata"), exports);
+__exportStar(require("./FirestoreReference"), exports);
+__exportStar(require("./firestoreTypes"), exports);
+__exportStar(require("./utils"), exports);

package/lib/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTransaction = exports.checkIfReferenceExists = exports.isFieldValue = exports.MergeConverters = void 0;
+exports.createModularFirestoreAdapter = createModularFirestoreAdapter;
+const firestore_1 = require("firebase/firestore");
+class MergeConverters {
+    constructor(converter1, converter2) {
+        this.converter1 = converter1;
+        this.converter2 = converter2;
+    }
+    toFirestore(modelObject, options) {
+        if (options) {
+            return Object.assign(Object.assign({}, this.converter1.toFirestore(modelObject, options)), this.converter2.toFirestore(modelObject, options));
+        }
+        else {
+            return Object.assign(Object.assign({}, this.converter1.toFirestore(modelObject)), this.converter2.toFirestore(modelObject));
+        }
+    }
+    fromFirestore(snapshot, options) {
+        return Object.assign(Object.assign({}, this.converter1.fromFirestore(snapshot, options)), this.converter2.fromFirestore(snapshot, options));
+    }
+}
+exports.MergeConverters = MergeConverters;
+function createModularFirestoreAdapter(firestore) {
+    return {
+        app: firestore,
+        collection: firestore_1.collection,
+        getDocs: firestore_1.getDocs,
+        getDoc: firestore_1.getDoc,
+        serverTimestamp: firestore_1.serverTimestamp,
+        query: firestore_1.query,
+        where: firestore_1.where,
+        limit: firestore_1.limit,
+        orderBy: firestore_1.orderBy,
+        setDoc: firestore_1.setDoc,
+        updateDoc: firestore_1.updateDoc,
+        deleteDoc: firestore_1.deleteDoc,
+        doc: firestore_1.doc,
+        onSnapshot: firestore_1.onSnapshot,
+        increment: firestore_1.increment,
+        // TODO: fix this
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        runTransaction: firestore_1.runTransaction,
+    };
+}
+// Value can be anything
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isFieldValue = (value) => {
+    return value !== undefined && typeof value._toFieldTransform === 'function';
+};
+exports.isFieldValue = isFieldValue;
+// Modular firestore uses exists, namespaced uses exists()
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const checkIfReferenceExists = (value) => {
+    if (value == null)
+        return false;
+    if (typeof value.exists === 'function')
+        return value.exists();
+    return value.exists;
+};
+exports.checkIfReferenceExists = checkIfReferenceExists;
+const withTransaction = (firestore, transaction, options) => {
+    return firestore.runTransaction(firestore.app, transaction, options);
+};
+exports.withTransaction = withTransaction;

package/lib/version.js

@@ -1,2 +1,3 @@
+"use strict";
 // Generated by genversion.
-module.exports = '0.4.2';
+module.exports = '0.4.5';