@data-weave/backend-firestore 0.4.26 → 0.5.1

package/dist/FirestoreReference.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreReference = void 0;
+const datamanager_1 = require("@data-weave/datamanager");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+class FirestoreReference extends datamanager_1.LiveReference {
+    firestore;
+    docRef;
+    options;
+    unsubscribeFromSnapshot;
+    constructor(firestore, docRef, options) {
+        super(docRef.id, options);
+        this.firestore = firestore;
+        this.docRef = docRef;
+        this.options = options;
+    }
+    async resolve() {
+        if (this.options?.readMode === 'realtime') {
+            return new Promise(res => {
+                // Unsubscribe from any existing snapshot listener
+                if (this.unsubscribeFromSnapshot) {
+                    this.unsubscribeFromSnapshot();
+                }
+                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);
+                        res(this.value);
+                    }
+                }, error => {
+                    this.onError(error);
+                    res(this.value);
+                });
+            });
+        }
+        try {
+            const doc = await this.firestore.getDoc(this.docRef);
+            this.onUpdate(this.parseDocumentSnapshot(doc));
+        }
+        catch (error) {
+            this.onError(error);
+        }
+        return this.value;
+    }
+    get path() {
+        return this.docRef.path;
+    }
+    onError(error) {
+        const wrapped = new errors_1.FirestoreReferenceError(error, {
+            path: this.docRef.path,
+            id: this.docRef.id,
+            readMode: this.options?.readMode,
+            snapshotOptions: this.options?.snapshotOptions,
+            type: 'reference',
+        });
+        super.onError(wrapped);
+    }
+    unsubscribe() {
+        this.unsubscribeFromSnapshot?.();
+        this.setStale();
+    }
+    parseDocumentSnapshot(docSnapshot) {
+        if (!(0, utils_1.checkIfReferenceExists)(docSnapshot))
+            throw new Error(`Document does not exist ${this.docRef.path}`);
+        return docSnapshot.data(this.options?.snapshotOptions);
+    }
+}
+exports.FirestoreReference = FirestoreReference;
+//# sourceMappingURL=FirestoreReference.js.map

package/dist/errors.d.ts

@@ -0,0 +1,29 @@
+import { FirestoreReadMode, FirestoreTypes } from './firestoreTypes';
+export interface FirestoreReferenceContext {
+    path: string;
+    id: string;
+    readMode?: FirestoreReadMode;
+    snapshotOptions?: FirestoreTypes.SnapshotOptions;
+    type: 'reference';
+}
+export interface FirestoreListContext {
+    query: FirestoreTypes.Query<unknown>;
+    readMode?: FirestoreReadMode;
+    type: 'list';
+}
+export declare class FirestoreError extends Error {
+    readonly cause: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class FirestoreReferenceError extends FirestoreError {
+    readonly context: FirestoreReferenceContext;
+    constructor(cause: unknown, context: FirestoreReferenceContext);
+}
+export declare class FirestoreListError extends FirestoreError {
+    readonly context: FirestoreListContext;
+    constructor(cause: unknown, context: FirestoreListContext);
+}
+export declare class FirestoreDataManagerError extends FirestoreError {
+    constructor(message: string, cause?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreDataManagerError = exports.FirestoreListError = exports.FirestoreReferenceError = exports.FirestoreError = void 0;
+class FirestoreError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'FirestoreError';
+        this.cause = cause;
+    }
+}
+exports.FirestoreError = FirestoreError;
+class FirestoreReferenceError extends FirestoreError {
+    context;
+    constructor(cause, context) {
+        super(`FirestoreReference error at "${context.path}"`, cause);
+        this.context = context;
+        this.name = 'FirestoreReferenceError';
+    }
+}
+exports.FirestoreReferenceError = FirestoreReferenceError;
+class FirestoreListError extends FirestoreError {
+    context;
+    constructor(cause, context) {
+        super('FirestoreList error', cause);
+        this.context = context;
+        this.name = 'FirestoreListError';
+    }
+}
+exports.FirestoreListError = FirestoreListError;
+class FirestoreDataManagerError extends FirestoreError {
+    constructor(message, cause) {
+        super(message, cause);
+        this.name = 'FirestoreDataManagerError';
+    }
+}
+exports.FirestoreDataManagerError = FirestoreDataManagerError;
+//# sourceMappingURL=errors.js.map

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

@@ -2,9 +2,9 @@ import { WithoutId } from '@data-weave/datamanager';
 import type * as FirestoreTypes from '@firebase/firestore';
 import type { FieldPath, WithFieldValue as FirestoreWithFieldValue, QueryConstraint } from '@firebase/firestore';
 import type { HttpsCallable, HttpsCallableOptions } from '@firebase/functions-types';
-import type { FieldValue, Transaction } from '@google-cloud/firestore';
+import type { Transaction as AdminTransaction, FieldValue } from '@google-cloud/firestore';
 export type DocumentData = FirestoreTypes.DocumentData;
-export { FieldValue, FirestoreTypes, Transaction };
+export { FieldValue, FirestoreTypes };
 /**
  * Same as Partial but all fields are required to be included
  */
@@ -53,6 +53,18 @@ export type OrderBy<T extends DocumentData, Fields extends string = FilterableFi
     Fields,
     FirestoreTypes.OrderByDirection
 ];
+export type AggregateFieldSpec = {
+    readonly type: 'sum' | 'average';
+    readonly field: string;
+} | {
+    readonly type: 'count';
+};
+export type AggregateSpec = {
+    readonly [alias: string]: AggregateFieldSpec;
+};
+export type AggregateResult<T extends AggregateSpec> = {
+    [K in keyof T]: number | null;
+};
 export declare abstract class FieldValues {
     abstract serverTimestamp(): FirestoreTypes.FieldValue;
     abstract delete(): FirestoreTypes.FieldValue;
@@ -60,13 +72,6 @@ export declare abstract class FieldValues {
     abstract arrayUnion(...elements: any[]): FirestoreTypes.FieldValue;
     abstract arrayRemove(...elements: any[]): FirestoreTypes.FieldValue;
 }
-/**********
- *
- *
- * INJECTABLES
- *
- *
- * **********/
 export interface FirestoreAppSettings {
     persistence?: boolean;
     cacheSizeBytes?: number;
@@ -81,12 +86,13 @@ export declare abstract class FirestoreApp {
     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>;
+    abstract runTransaction?<T>(updateFunction: (transaction: AdminTransaction) => 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 getAggregateFromServer<Spec extends AggregateSpec>(query: FirestoreTypes.Query, spec: Spec): Promise<AggregateResult<Spec>>;
     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;
@@ -100,7 +106,7 @@ export declare abstract class Firestore {
     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>;
+    abstract runTransaction<T>(firestore: FirestoreApp, transaction: (transaction: FirestoreTypes.Transaction) => Promise<T>, options?: FirestoreTypes.TransactionOptions): Promise<T>;
 }
 export declare abstract class FirestoreSettings {
     abstract readMode: FirestoreReadMode;
@@ -115,3 +121,4 @@ export declare class DummyFirestoreFunctions implements FirestoreFunctions {
     useEmulator(): void;
     useFunctionsEmulator(): void;
 }
+//# sourceMappingURL=firestoreTypes.d.ts.map

package/dist/firestoreTypes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyFirestoreFunctions = exports.FirestoreFunctions = exports.FirestoreSettings = exports.Firestore = exports.FirestoreApp = exports.FieldValues = void 0;
+class FieldValues {
+}
+exports.FieldValues = FieldValues;
+class FirestoreApp {
+}
+exports.FirestoreApp = FirestoreApp;
+class Firestore {
+}
+exports.Firestore = Firestore;
+class FirestoreSettings {
+}
+exports.FirestoreSettings = FirestoreSettings;
+class FirestoreFunctions {
+}
+exports.FirestoreFunctions = FirestoreFunctions;
+class DummyFirestoreFunctions {
+    httpsCallable() {
+        return () => {
+            throw new Error('httpsCallable not implemented - DummyFirestoreFunctions');
+        };
+    }
+    useEmulator() { }
+    useFunctionsEmulator() { }
+}
+exports.DummyFirestoreFunctions = DummyFirestoreFunctions;
+//# sourceMappingURL=firestoreTypes.js.map

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

@@ -1,6 +1,9 @@
+export * from './errors';
+export * from './FirestoreAdminAdapter';
 export * from './FirestoreDataManager';
 export * from './FirestoreList';
 export * from './FirestoreMetadata';
 export * from './FirestoreReference';
 export * from './firestoreTypes';
 export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/{lib → dist}/index.js

@@ -14,9 +14,12 @@ 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("./errors"), exports);
+__exportStar(require("./FirestoreAdminAdapter"), exports);
 __exportStar(require("./FirestoreDataManager"), exports);
 __exportStar(require("./FirestoreList"), exports);
 __exportStar(require("./FirestoreMetadata"), exports);
 __exportStar(require("./FirestoreReference"), exports);
 __exportStar(require("./firestoreTypes"), exports);
 __exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -1,5 +1,5 @@
 import { WithoutId } from '@data-weave/datamanager';
-import { DocumentData, Firestore, FirestoreTypes, InternalFirestoreDataConverter, Transaction, WithFieldValue } from './firestoreTypes';
+import { DocumentData, Firestore, FirestoreTypes, InternalFirestoreDataConverter, 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;
@@ -11,4 +11,5 @@ export declare class MergeConverters<T extends DocumentData, SerializedT extends
 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>;
+export declare const withTransaction: (firestore: Firestore, transaction: (transaction: FirestoreTypes.Transaction) => Promise<void>, options?: FirestoreTypes.TransactionOptions) => Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/{lib → dist}/utils.js

@@ -3,29 +3,72 @@ 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 ConverterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConverterError';
+    }
+}
 class MergeConverters {
+    converter1;
+    converter2;
     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));
+        try {
+            if (options) {
+                return {
+                    ...this.converter1.toFirestore(modelObject, options),
+                    ...this.converter2.toFirestore(modelObject, options),
+                };
+            }
+            else {
+                return {
+                    ...this.converter1.toFirestore(modelObject),
+                    ...this.converter2.toFirestore(modelObject),
+                };
+            }
         }
-        else {
-            return Object.assign(Object.assign({}, this.converter1.toFirestore(modelObject)), this.converter2.toFirestore(modelObject));
+        catch (error) {
+            throw new ConverterError(`Failed to convert model object to firestore: ${error}`);
         }
     }
     fromFirestore(snapshot, options) {
-        return Object.assign(Object.assign({}, this.converter1.fromFirestore(snapshot, options)), this.converter2.fromFirestore(snapshot, options));
+        try {
+            return {
+                ...this.converter1.fromFirestore(snapshot, options),
+                ...this.converter2.fromFirestore(snapshot, options),
+            };
+        }
+        catch (error) {
+            throw new ConverterError(`Failed to convert snapshot to model object: ${error}`);
+        }
     }
 }
 exports.MergeConverters = MergeConverters;
+function buildAggregateSpec(spec) {
+    return Object.fromEntries(Object.keys(spec).map(alias => {
+        const fieldSpec = spec[alias];
+        if (fieldSpec.type === 'count') {
+            return [alias, (0, firestore_1.count)()];
+        }
+        const factory = fieldSpec.type === 'sum' ? firestore_1.sum : firestore_1.average;
+        return [alias, factory(fieldSpec.field)];
+    }));
+}
+async function modularGetAggregateFromServer(ref, spec) {
+    const sdkSpec = buildAggregateSpec(spec);
+    const snapshot = await (0, firestore_1.getAggregateFromServer)(ref, sdkSpec);
+    return snapshot.data();
+}
 function createModularFirestoreAdapter(firestore) {
     return {
         app: firestore,
         collection: firestore_1.collection,
         getDocs: firestore_1.getDocs,
+        getAggregateFromServer: modularGetAggregateFromServer,
         getDoc: firestore_1.getDoc,
         serverTimestamp: firestore_1.serverTimestamp,
         query: firestore_1.query,
@@ -38,8 +81,6 @@ function createModularFirestoreAdapter(firestore) {
         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,
     };
 }
@@ -63,3 +104,4 @@ const withTransaction = (firestore, transaction, options) => {
     return firestore.runTransaction(firestore.app, transaction, options);
 };
 exports.withTransaction = withTransaction;
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,16 +1,25 @@
 {
     "name": "@data-weave/backend-firestore",
-    "version": "0.4.26",
+    "version": "0.5.1",
     "author": "",
-    "main": "lib/index.js",
-    "types": "lib/index.d.ts",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
     "files": [
-        "lib/**/*.js",
-        "lib/**/*.d.ts"
+        "dist/**/*.js",
+        "dist/**/*.d.ts"
     ],
+    "devDependencies": {
+        "@data-weave/datamanager": "~0.5.0",
+        "@firebase/firestore": "^4.7.8",
+        "@firebase/functions-types": "^0.6.3",
+        "@google-cloud/firestore": "^7.11.1",
+        "@types/node": "^22.10.2",
+        "firebase": "^11.9.0",
+        "typescript": "5.9.3"
+    },
     "scripts": {
-        "clean": "rm -rf lib",
-        "build": "genversion --force --semi src/version.js && tsc",
+        "clean": "rm -rf dist",
+        "build": "tsc",
         "build:clean": "npm run clean && npm run build",
         "prepare": "npm run build"
     },
@@ -23,8 +32,10 @@
         "registry": "https://registry.npmjs.org/"
     },
     "peerDependencies": {
-        "@data-weave/datamanager": "~0.4.25",
         "firebase": ">=11.0.0"
     },
-    "gitHead": "70c0827db3b7982a46ae896d1693b02a6581bc4d"
+    "dependencies": {
+        "@data-weave/datamanager": "~0.5.0"
+    },
+    "gitHead": "df44d823b93b392d9e3b685fafb0d17399001291"
 }

package/lib/FirestoreDataManager.d.ts

@@ -1,46 +0,0 @@
-import { Cache, DataManager, IdentifiableReference, List, ListPaginationParams, WithMetadata, WithoutId } from '@data-weave/datamanager';
-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;
-    readonly disableCache?: boolean;
-}
-export interface QueryParams<T> {
-    readonly filters?: Array<FilterBy<T & FirestoreSerializedMetadata>>;
-    readonly orderBy?: Array<OrderBy<T & FirestoreSerializedMetadata>>;
-}
-export declare class FirestoreDataManager<T extends FirestoreTypes.DocumentData, SerializedT extends FirestoreTypes.DocumentData = T> implements DataManager<T> {
-    private readonly firestore;
-    private readonly collectionPath;
-    private readonly converter;
-    private readonly opts?;
-    private mergedConverter;
-    private collection;
-    private collectionQuery;
-    private managerOptions;
-    private refCache;
-    private listCache;
-    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;
-}