@data-weave/firestore-admin-adapter 0.6.1

package/dist/FirestoreAdminAdapter.d.ts

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

package/dist/FirestoreAdminAdapter.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FirestoreAdminAdapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,18 @@
+"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("./FirestoreAdminAdapter"), exports);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@data-weave/firestore-admin-adapter",
+    "version": "0.6.1",
+    "author": "",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist/**/*.js",
+        "dist/**/*.d.ts"
+    ],
+    "scripts": {
+        "clean": "rm -rf dist",
+        "build": "tsc",
+        "build:clean": "npm run clean && npm run build",
+        "prepare": "npm run build"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/data-weave/datamanager/tree/master/packages/firestore-admin-adapter"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    },
+    "dependencies": {
+        "@data-weave/backend-firestore": "~0.6.1"
+    },
+    "peerDependencies": {
+        "firebase-admin": ">=12.0.0"
+    },
+    "devDependencies": {
+        "@data-weave/backend-firestore": "~0.6.1",
+        "@data-weave/datamanager": "~0.6.1",
+        "@types/node": "^22.10.2",
+        "firebase-admin": "^13.0.0",
+        "typescript": "5.9.3"
+    }
+}