@data-weave/backend-firestore 0.4.2 → 0.4.3

package/lib/firestoreTypes.d.ts

@@ -0,0 +1,117 @@
+import { WithoutId } from '@data-weave/datamanager';
+import type FirestoreTypes from '@firebase/firestore';
+import type { FieldPath, WithFieldValue as FirestoreWithFieldValue, QueryConstraint } from '@firebase/firestore';
+import type { HttpsCallable, HttpsCallableOptions } from '@firebase/functions-types';
+import { FieldValue, Transaction } from '@google-cloud/firestore';
+export type DocumentData = FirestoreTypes.DocumentData;
+export { FieldValue, FirestoreTypes, Transaction };
+/**
+ * Same as Partial but all fields are required to be included
+ */
+type OptionallyUndefined<T> = {
+    [P in keyof T]: T[P] | undefined;
+};
+export declare interface InternalFirestoreDataConverter<T extends DocumentData, SerializedT extends DocumentData = DocumentData> {
+    toFirestore(modelObject: Partial<WithFieldValue<WithoutId<T>>>, options?: FirestoreTypes.SetOptions): WithFieldValue<WithoutId<SerializedT>>;
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<T, SerializedT>, options?: FirestoreTypes.SnapshotOptions): T;
+}
+export type WithTimestamps<T> = {
+    [K in keyof T]: T[K] extends Date ? FirestoreTypes.Timestamp : T[K] extends Date | null ? FirestoreTypes.Timestamp | null : T[K] extends Date | undefined ? FirestoreTypes.Timestamp | undefined : T[K] extends Date | null | undefined ? FirestoreTypes.Timestamp | null | undefined : T[K] extends object ? T[K] extends any[] ? T[K] extends (infer U)[] ? WithTimestamps<U>[] : T[K] : WithTimestamps<T[K]> : T[K];
+};
+/**
+ * Converts data between model and serialized data. Differs from InternalFirestoreDataConverter
+ * by using `OptionallyUndefined` and `Required` to ensure that all fields are included in de/serialization
+ * even if some model defined properties are optional.
+ */
+export declare interface FirestoreDataConverter<ModelObject, SerializedModelObject = ModelObject> {
+    toFirestore(modelObject: WithoutId<ModelObject>, options?: FirestoreTypes.SetOptions): OptionallyUndefined<Required<WithoutId<WithFieldValue<SerializedModelObject>>>>;
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<WithTimestamps<SerializedModelObject>>, options?: FirestoreTypes.SnapshotOptions): ModelObject;
+}
+export type FirestoreQuery<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = (reference: FirestoreTypes.Query<AppModelType, DbModelType>, filter: any) => FirestoreTypes.Query<AppModelType, DbModelType>;
+export type FirestoreWhere = (field: string | FieldPath, op: string, value: unknown) => any;
+export type FirestoreReadMode = 'realtime' | 'static';
+export interface FirestoreReadOptions {
+    readonly transaction?: FirestoreTypes.Transaction;
+}
+export interface FirestoreWriteOptions {
+    readonly transaction?: FirestoreTypes.Transaction;
+    readonly batcher?: FirestoreTypes.WriteBatch;
+}
+export interface FirebaseCreateOptions extends FirestoreWriteOptions {
+    id?: string;
+    merge?: boolean;
+}
+export declare type WithFieldValue<T> = {
+    [K in keyof T]: FirestoreWithFieldValue<T[K]> | FirestoreTypes.FieldValue;
+};
+type GenNode<K extends string, IsRoot extends boolean> = IsRoot extends true ? `${K}` : `.${K}`;
+export type FilterableFields<T extends object, IsRoot extends boolean = true, K extends keyof T = keyof T> = K extends string ? T[K] extends FirestoreTypes.Timestamp ? `${K}` : T[K] extends Date ? `${K}` : T[K] extends any[] ? GenNode<K, IsRoot> : T[K] extends object ? `${GenNode<K, IsRoot>}${FilterableFields<T[K], false>}` : GenNode<K, IsRoot> : never;
+type GetValue<T, K extends string> = K extends `${infer L}.${infer R}` ? L extends keyof T ? GetValue<T[L], R> : never : K extends keyof T ? T[K] extends Date ? Date | FirestoreTypes.Timestamp : T[K] : K extends string ? string | number | boolean : never;
+export type PrimitiveFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>';
+export type FilterBy<T extends object, Field extends string = FilterableFields<T>> = Field extends string ? GetValue<T, Field> extends any[] ? [Field, 'array-contains', string] | [Field, 'array-contains-any', string[]] : [Field, PrimitiveFilterOp, GetValue<T, Field>] | [Field, 'in', string[]] : never;
+export type OrderBy<T extends DocumentData, Fields extends string = FilterableFields<T>> = [
+    Fields,
+    FirestoreTypes.OrderByDirection
+];
+export declare abstract class FieldValues {
+    abstract serverTimestamp(): FirestoreTypes.FieldValue;
+    abstract delete(): FirestoreTypes.FieldValue;
+    abstract increment(n: number): FirestoreTypes.FieldValue;
+    abstract arrayUnion(...elements: any[]): FirestoreTypes.FieldValue;
+    abstract arrayRemove(...elements: any[]): FirestoreTypes.FieldValue;
+}
+/**********
+ *
+ *
+ * INJECTABLES
+ *
+ *
+ * **********/
+export interface FirestoreAppSettings {
+    persistence?: boolean;
+    cacheSizeBytes?: number;
+    host?: string;
+    ssl?: boolean;
+    ignoreUndefinedProperties?: boolean;
+    serverTimestampBehavior?: 'estimate' | 'previous' | 'none';
+}
+export declare abstract class FirestoreApp {
+    abstract type?: string;
+    abstract toJSON?(): object;
+    abstract terminate?(): Promise<void>;
+    abstract settings?(settings: FirestoreAppSettings): void;
+    abstract useEmulator?(host: string, port: number): void;
+    abstract runTransaction?<T>(updateFunction: (transaction: Transaction) => Promise<T>, options?: FirestoreTypes.TransactionOptions): Promise<T>;
+}
+export declare abstract class Firestore {
+    abstract app: FirestoreApp;
+    abstract collection(reference: FirestoreTypes.CollectionReference | FirestoreApp, path: string): any;
+    abstract getDocs<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>): Promise<FirestoreTypes.QuerySnapshot<AppModelType, DbModelType>>;
+    abstract getDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, path?: string): Promise<FirestoreTypes.DocumentSnapshot<AppModelType, DbModelType>>;
+    abstract serverTimestamp(): FirestoreTypes.FieldValue;
+    abstract increment(n: number): FirestoreTypes.FieldValue;
+    abstract query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>, filter: any): FirestoreTypes.Query<AppModelType, DbModelType>;
+    abstract where(field: string | FieldPath, op: string, value: unknown): QueryConstraint;
+    abstract limit(limit: number): any;
+    abstract orderBy(orderBy: string, direction: FirestoreTypes.OrderByDirection): any;
+    abstract setDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, data: any, options?: FirestoreTypes.SetOptions): Promise<void>;
+    abstract updateDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, data: any): Promise<void>;
+    abstract doc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>, path?: string): FirestoreTypes.DocumentReference<AppModelType, DbModelType>;
+    abstract deleteDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>): Promise<void>;
+    abstract onSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, onNext: (snapshot: FirestoreTypes.DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void): () => void;
+    abstract onSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>, onNext: (snapshot: FirestoreTypes.QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void): () => void;
+    abstract runTransaction<T>(firestore: FirestoreApp, transaction: (transaction: Transaction) => Promise<T>, options?: FirestoreTypes.TransactionOptions): Promise<T>;
+}
+export declare abstract class FirestoreSettings {
+    abstract readMode: FirestoreReadMode;
+}
+export declare abstract class FirestoreFunctions {
+    abstract httpsCallable(name: string, options?: HttpsCallableOptions): HttpsCallable;
+    abstract useEmulator(host: string, port: number): void;
+    abstract useFunctionsEmulator(origin: string): void;
+}
+export declare class DummyFirestoreFunctions implements FirestoreFunctions {
+    httpsCallable(): HttpsCallable;
+    useEmulator(): void;
+    useFunctionsEmulator(): void;
+}

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.d.ts

@@ -0,0 +1,6 @@
+export * from './FirestoreDataManager';
+export * from './FirestoreList';
+export * from './FirestoreMetadata';
+export * from './FirestoreReference';
+export * from './firestoreTypes';
+export * from './utils';

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.d.ts

@@ -0,0 +1,14 @@
+import { WithoutId } from '@data-weave/datamanager';
+import { DocumentData, Firestore, FirestoreTypes, InternalFirestoreDataConverter, Transaction, WithFieldValue } from './firestoreTypes';
+import { Firestore as FirebaseFirestore } from 'firebase/firestore';
+export declare class MergeConverters<T extends DocumentData, SerializedT extends DocumentData, G extends DocumentData, SerializedG extends DocumentData> implements InternalFirestoreDataConverter<T & G, SerializedT & SerializedG> {
+    private converter1;
+    private converter2;
+    constructor(converter1: InternalFirestoreDataConverter<T, SerializedT>, converter2: InternalFirestoreDataConverter<G, SerializedG>);
+    toFirestore(modelObject: WithoutId<Partial<WithFieldValue<T>>> & WithoutId<Partial<WithFieldValue<G>>>, options?: FirestoreTypes.SetOptions): WithFieldValue<WithoutId<SerializedT>> & WithFieldValue<WithoutId<SerializedG>>;
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<T & G, SerializedT & SerializedG>, options: FirestoreTypes.SnapshotOptions): T & G;
+}
+export declare function createModularFirestoreAdapter(firestore: FirebaseFirestore): Firestore;
+export declare const isFieldValue: (value: any) => value is FirestoreTypes.FieldValue;
+export declare const checkIfReferenceExists: (value: any) => boolean;
+export declare const withTransaction: (firestore: Firestore, transaction: (transaction: Transaction) => Promise<void>, options?: FirestoreTypes.TransactionOptions) => Promise<void>;

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,2 @@
 // Generated by genversion.
-module.exports = '0.4.2';
+module.exports = '0.4.3';

package/package.json

@@ -1,11 +1,15 @@
 {
     "name": "@data-weave/backend-firestore",
-    "version": "0.4.2",
+    "version": "0.4.3",
     "author": "",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
+    "files": [
+        "lib/**/*.js",
+        "lib/**/*.d.ts"
+    ],
     "scripts": {
-        "build": "genversion --semi lib/version.js",
+        "build": "genversion --semi lib/version.js && cp -r ../../build/backend-firestore/lib/*.js lib/ && cp -r ../../build/types/backend-firestore/lib/*.d.ts lib/",
         "build:clean": "rimraf android/build && rimraf ios/build",
         "prepare": "npm run build"
     },
@@ -18,8 +22,8 @@
         "registry": "https://registry.npmjs.org/"
     },
     "peerDependencies": {
-        "@data-weave/datamanager": "0.4.1",
+        "@data-weave/datamanager": "0.4.2",
         "firebase": ">=11.0.0"
     },
-    "gitHead": "1dcdcb73b691bdeaa60f9a7dd3ada171fde24f32"
+    "gitHead": "5dd7dfd873ebb8a0b8a11870fac08f41d9548aa7"
 }

package/CHANGELOG.md

@@ -1,78 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-## [0.4.2](https://github.com/data-weave/datamanager/compare/v0.4.1...v0.4.2) (2025-10-15)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.4.1](https://github.com/data-weave/datamanager/compare/v0.4.0...v0.4.1) (2025-10-15)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.4.0](https://github.com/data-weave/datamanager/compare/v0.3.8...v0.4.0) (2025-10-15)
-
-### Features
-
-- add error interceptor ([dde95c8](https://github.com/data-weave/datamanager/commit/dde95c8dba3d02d7861d132314db4d1cf23bec37))
-- add new typing, snapshot options and sane type defaults ([7095568](https://github.com/data-weave/datamanager/commit/7095568892048dc75cccc284e2dd2ba23793a152))
-- create shim for modular firebase as well ([591b25a](https://github.com/data-weave/datamanager/commit/591b25a8cbcf89687b3880cc3ca1cd95a735e11d))
-- move firebase-admin shim to it's own package ([ac9f861](https://github.com/data-weave/datamanager/commit/ac9f861ca810a2a14706e10e87674b1b1f14a964))
-
-## [0.3.8](https://github.com/data-weave/datamanager/compare/v0.3.7...v0.3.8) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.7](https://github.com/data-weave/datamanager/compare/v0.3.6...v0.3.7) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.6](https://github.com/data-weave/datamanager/compare/v0.3.5...v0.3.6) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.5](https://github.com/data-weave/datamanager/compare/v0.3.4...v0.3.5) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.4](https://github.com/data-weave/datamanager/compare/v0.3.3...v0.3.4) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.3](https://github.com/data-weave/datamanager/compare/v0.3.2...v0.3.3) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.2](https://github.com/data-weave/datamanager/compare/v0.3.1...v0.3.2) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## [0.3.1](https://github.com/data-weave/datamanager/compare/v0.3.0...v0.3.1) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/backend-firestore
-
-## 0.3.0 (2025-09-28)
-
-### Features
-
-- add code quality workflow and circular dep check ([9c7b7e3](https://github.com/data-weave/datamanager/commit/9c7b7e34501dfc95ddc2bcff686f55db06d9b1b8))
-- add transactions support ([59db0ff](https://github.com/data-weave/datamanager/commit/59db0ffce889e040828779bd2d03efe5ac088e78))
-- project re-organization ([4a00af3](https://github.com/data-weave/datamanager/commit/4a00af36c4c2f6e49287542e0d5ad85acaa50cda))
-
-### Bug Fixes
-
-- adjust config and lib versions ([9c7e2c9](https://github.com/data-weave/datamanager/commit/9c7e2c9072ea34b1e54326c2612b43c92ec2da4e))
-- adjust tests for firestore realtime snapshots ([539f314](https://github.com/data-weave/datamanager/commit/539f31448f68b084dc4e429663fe71e69c98760e))
-- implement Cache prop & clean up some of anys ([955b11a](https://github.com/data-weave/datamanager/commit/955b11a6ab05224f843db834ad28796602679fac))
-
-### Reverts
-
-- revert incorrect name change ([191e64e](https://github.com/data-weave/datamanager/commit/191e64e1123bdbc3555ff7830a532761157fd8ac))
-
-### Code Refactoring
-
-- abstract out firestoreReference into LiveReference ([7848a87](https://github.com/data-weave/datamanager/commit/7848a872155593e5acab56696d4d9f27f0e6abb2))
-- abstract out LiveList function from FirestorList ([bb4278e](https://github.com/data-weave/datamanager/commit/bb4278e960d0080d1fb18d847036acb189782ec9))
-- adjustments for LiveList & ListReference ([49cd540](https://github.com/data-weave/datamanager/commit/49cd540295693e40bbb9eb75b5101b45c6932921))
-- include namepspace in DataManager name ([9c0a171](https://github.com/data-weave/datamanager/commit/9c0a1712d8de3cef0d2e1f8022044d0ca3628ae6))