@nu-art/firebase-backend 0.401.9 → 0.500.6

package/ModuleBE_Firebase.d.ts

@@ -1,10 +1,20 @@
 /**
  * Created by tacb0ss on 25/08/2018.
  */
-import { Module } from '@nu-art/ts-common';
+import { Module, TypedMap } from '@nu-art/ts-common';
 import { FirebaseSession_Admin } from './auth/FirebaseSession_Admin.js';
+export type FirestoreMongoConfig = {
+    firestoreUid: string;
+    firestoreLocation: string;
+};
+export type MongoConnectionConfig = {
+    mongoUrl?: string;
+    firestoreMongo?: FirestoreMongoConfig;
+    params?: TypedMap<string | number>;
+};
 type ConfigType = {
     isEmulator?: boolean;
+    mongo?: MongoConnectionConfig;
 };
 export declare const FIREBASE_DEFAULT_PROJECT_ID = "local";
 export declare class ModuleBE_Firebase_Class extends Module<ConfigType> {
@@ -13,6 +23,10 @@ export declare class ModuleBE_Firebase_Class extends Module<ConfigType> {
     protected init(): void;
     __resetForTests(): Promise<void>;
     createAdminSession(authKey?: string): FirebaseSession_Admin;
+    resolveMongoUrl(authKey?: string): string;
+    private resolveMongoConfig;
+    private static readonly firestoreMongoDefaults;
+    private static buildFirestoreMongoUrl;
     createModuleStateFirebaseRef<T>(module: Module, _relativePath: string): import("./index.js").FirebaseRef<T>;
 }
 export declare const ModuleBE_Firebase: ModuleBE_Firebase_Class;

package/ModuleBE_Firebase.js

@@ -18,8 +18,9 @@
 /**
  * Created by tacb0ss on 25/08/2018.
  */
-import { Module } from '@nu-art/ts-common';
+import { composeUrl, ImplementationMissingException, merge, Module } from '@nu-art/ts-common';
 import { FirebaseSession_Admin } from './auth/FirebaseSession_Admin.js';
+import { FirebaseSession } from './auth/firebase-session.js';
 // import {FirebaseSession_UserPassword} from "./auth/FirebaseSession_UserPassword.js";
 import { readFileSync } from 'fs';
 import { ModuleBE_Auth } from '@nu-art/google-services-backend';
@@ -31,6 +32,7 @@ export class ModuleBE_Firebase_Class extends Module {
         super('firebase');
     }
     init() {
+        FirebaseSession.setMongoUrlResolver((authKey) => this.resolveMongoUrl(authKey));
     }
     async __resetForTests() {
         this.logWarning('__resetForTests');
@@ -42,10 +44,9 @@ export class ModuleBE_Firebase_Class extends Module {
         const session = this.adminSessions[authKey];
         if (session)
             return session;
-        // try to fetch the service account from the auth serviceAccount by the authKey
         let serviceAccount;
         try {
-            serviceAccount = ModuleBE_Auth.getAuthConfig(authKey);
+            serviceAccount = ModuleBE_Auth.getCredentials(authKey);
         }
         catch (e) {
             if (authKey !== FIREBASE_DEFAULT_PROJECT_ID)
@@ -58,6 +59,41 @@ export class ModuleBE_Firebase_Class extends Module {
         this.logInfo(`Creating Firebase session for auth key: ${authKey}`, serviceAccount);
         return this.adminSessions[authKey] = new FirebaseSession_Admin(authKey, serviceAccount).connect();
     }
+    resolveMongoUrl(authKey) {
+        const mongoConfig = this.resolveMongoConfig(authKey);
+        if (mongoConfig?.mongoUrl)
+            return composeUrl(mongoConfig.mongoUrl, mongoConfig.params);
+        if (mongoConfig?.firestoreMongo)
+            return ModuleBE_Firebase_Class.buildFirestoreMongoUrl(mongoConfig.firestoreMongo, mongoConfig.params);
+        throw new ImplementationMissingException(`No MongoDB connection configured for session '${authKey ?? 'default'}'. ` +
+            'Set mongo.mongoUrl or mongo.firestoreMongo in ModuleBE_Firebase config (default), or in auth config (keyed).');
+    }
+    resolveMongoConfig(authKey) {
+        if (!authKey || authKey === FIREBASE_DEFAULT_PROJECT_ID)
+            return this.config?.mongo;
+        try {
+            const authConfig = ModuleBE_Auth.getAuthConfig(authKey);
+            if (typeof authConfig === 'object' && 'mongo' in authConfig)
+                return authConfig.mongo;
+        }
+        catch (_e) {
+        }
+        return undefined;
+    }
+    static firestoreMongoDefaults = {
+        loadBalanced: 'true',
+        tls: 'true',
+        retryWrites: 'false',
+        connectTimeoutMS: 30000,
+        socketTimeoutMS: 60000,
+        authMechanism: 'MONGODB-OIDC',
+        authMechanismProperties: 'ENVIRONMENT:gcp,TOKEN_RESOURCE:FIRESTORE',
+    };
+    static buildFirestoreMongoUrl(config, overrides) {
+        const { firestoreUid, firestoreLocation } = config;
+        const baseUrl = `mongodb://${firestoreUid}.${firestoreLocation}.firestore.goog:443/default`;
+        return composeUrl(baseUrl, merge(ModuleBE_Firebase_Class.firestoreMongoDefaults, overrides));
+    }
     createModuleStateFirebaseRef(module, _relativePath) {
         let relativePath = _relativePath;
         if (relativePath.startsWith('/'))

package/auth/firebase-session.d.ts

@@ -6,9 +6,10 @@ import { DatabaseWrapperBE } from '../database/DatabaseWrapperBE.js';
 import { StorageWrapperBE } from '../storage/StorageWrapperBE.js';
 import { PushMessagesWrapperBE } from '../push/PushMessagesWrapperBE.js';
 import { App } from 'firebase-admin/app';
-import { FirestoreWrapperBEV3 } from '../firestore-v3/FirestoreWrapperBEV3.js';
-import { FirebaseConfig } from '@nu-art/firebase-shared';
 import { FirestoreWrapperBE } from '../firestore/FirestoreWrapperBE.js';
+import { MongoWrapperBE } from '../firestore/MongoWrapperBE.js';
+import { FirebaseConfig } from '@nu-art/firebase-shared';
+import { MongoClient } from 'mongodb';
 /**
  * Represents the credentials of a Firebase user.
  */
@@ -22,13 +23,17 @@ export type Firebase_UserCredential = {
 /**
  * An abstract class that serves as a base for Firebase session classes.
  */
+export type MongoUrlResolver = (authKey?: string) => string;
 export declare abstract class FirebaseSession<Config> extends Logger {
+    private static mongoUrlResolver?;
+    static setMongoUrlResolver(resolver: MongoUrlResolver): void;
     app: App;
     protected databases: TypedMap<DatabaseWrapperBE>;
     protected storage?: StorageWrapperBE;
-    protected firestoresV3: TypedMap<FirestoreWrapperBEV3>;
-    protected messaging?: PushMessagesWrapperBE;
     protected firestores: TypedMap<FirestoreWrapperBE>;
+    protected mongos: TypedMap<MongoWrapperBE>;
+    protected mongoClient?: MongoClient;
+    protected messaging?: PushMessagesWrapperBE;
     protected config: Config;
     protected firebaseAppName: string;
     private readonly admin;
@@ -49,11 +54,10 @@ export declare abstract class FirebaseSession<Config> extends Logger {
      * Returns an instance of the StorageWrapperBE object, which provides access to a cloud storage service.
      */
     getStorage(): StorageWrapperBE;
-    /**
-     * Returns an instance of the FirestoreWrapperBE object, which provides access to the Firestore database service.
-     */
     getFirestore(dbName?: string): FirestoreWrapperBE;
-    getFirestoreV3(dbName?: string): FirestoreWrapperBEV3;
+    setMongoClient(client: MongoClient): void;
+    reconnectMongo(): Promise<void>;
+    getMongo(dbName: string): MongoWrapperBE;
     /**
      * Returns an instance of the PushMessagesWrapperBE object, which provides access to push messaging services.
      */

package/auth/firebase-session.js

@@ -18,23 +18,25 @@
 /**
  * Created by tacb0ss on 25/08/2018.
  */
-import { Logger } from '@nu-art/ts-common';
+import { ImplementationMissingException, Logger } from '@nu-art/ts-common';
 import { DatabaseWrapperBE } from '../database/DatabaseWrapperBE.js';
 import { StorageWrapperBE } from '../storage/StorageWrapperBE.js';
 import { PushMessagesWrapperBE } from '../push/PushMessagesWrapperBE.js';
-import { FirestoreWrapperBEV3 } from '../firestore-v3/FirestoreWrapperBEV3.js';
 import { FirestoreWrapperBE } from '../firestore/FirestoreWrapperBE.js';
-// export type FirebaseApp = admin.app.App | firebase.app.App
-/**
- * An abstract class that serves as a base for Firebase session classes.
- */
+import { MongoWrapperBE } from '../firestore/MongoWrapperBE.js';
+import { MongoClient } from 'mongodb';
 export class FirebaseSession extends Logger {
+    static mongoUrlResolver;
+    static setMongoUrlResolver(resolver) {
+        FirebaseSession.mongoUrlResolver = resolver;
+    }
     app;
     databases = {};
     storage;
-    firestoresV3 = {};
-    messaging;
     firestores = {};
+    mongos = {};
+    mongoClient;
+    messaging;
     config;
     firebaseAppName;
     admin;
@@ -69,18 +71,54 @@ export class FirebaseSession extends Logger {
             return this.storage;
         return this.storage = new StorageWrapperBE(this);
     }
-    /**
-     * Returns an instance of the FirestoreWrapperBE object, which provides access to the Firestore database service.
-     */
     getFirestore(dbName) {
         if (!this.firestores[dbName ?? 'default'])
             this.firestores[dbName ?? 'default'] = new FirestoreWrapperBE(this, dbName);
         return this.firestores[dbName ?? 'default'];
     }
-    getFirestoreV3(dbName) {
-        if (!this.firestoresV3[dbName ?? 'default'])
-            this.firestoresV3[dbName ?? 'default'] = new FirestoreWrapperBEV3(this, dbName);
-        return this.firestoresV3[dbName ?? 'default'];
+    setMongoClient(client) {
+        this.mongoClient = client;
+    }
+    async reconnectMongo() {
+        if (!this.mongoClient)
+            return;
+        this.logWarning('Reconnecting MongoDB — closing existing client');
+        try {
+            await this.mongoClient.close();
+        }
+        catch (e) {
+            this.logWarning(`Error closing MongoDB client during reconnect: ${e}`);
+        }
+        this.mongoClient = undefined;
+        for (const key of Object.keys(this.mongos))
+            delete this.mongos[key];
+    }
+    getMongo(dbName) {
+        if (!this.mongoClient) {
+            if (!FirebaseSession.mongoUrlResolver)
+                throw new ImplementationMissingException('MongoUrlResolver not set — call FirebaseSession.setMongoUrlResolver() during module init');
+            const url = FirebaseSession.mongoUrlResolver(this.firebaseAppName);
+            this.logInfo(`Creating MongoClient: ${url}`);
+            this.mongoClient = new MongoClient(url, { monitorCommands: true });
+            this.mongoClient.on('commandStarted', (event) => {
+                this.logDebug(`MongoDB >>> [${event.commandName}] reqId=${event.requestId} ns=${event.databaseName}.${event.command[event.commandName]}`);
+            });
+            this.mongoClient.on('commandFailed', (event) => {
+                this.logError(`MongoDB commandFailed [${event.commandName}] reqId=${event.requestId}: ${event.failure.message}`);
+            });
+            this.mongoClient.on('commandSucceeded', (event) => {
+                const reply = event.reply;
+                if (event.commandName === 'find' && !reply?.cursor) {
+                    this.logError(`MongoDB <<< [${event.commandName}] reqId=${event.requestId} MISSING CURSOR — reply=${JSON.stringify(reply)}`);
+                }
+                else {
+                    this.logDebug(`MongoDB <<< [${event.commandName}] reqId=${event.requestId} ok=${reply?.ok} ${event.duration}ms`);
+                }
+            });
+        }
+        if (!this.mongos[dbName])
+            this.mongos[dbName] = new MongoWrapperBE(this.mongoClient, dbName);
+        return this.mongos[dbName];
     }
     /**
      * Returns an instance of the PushMessagesWrapperBE object, which provides access to push messaging services.

package/firestore/DocWrapper.d.ts

@@ -0,0 +1,30 @@
+import { DB_Prototype } from '@nu-art/db-api-shared';
+import { TS_Object, UniqueId } from '@nu-art/ts-common';
+import { FirestoreType_DocumentReference } from './types.js';
+import { FirestoreCollection } from './FirestoreCollection.js';
+import type { firestore as Fa } from 'firebase-admin';
+export type UpdateObject<DBType extends TS_Object> = {
+    _id: UniqueId;
+} & Fa.UpdateData<DBType>;
+export declare class DocWrapper<Proto extends DB_Prototype> {
+    readonly ref: FirestoreType_DocumentReference<Proto['dbType']>;
+    readonly collection: FirestoreCollection<Proto>;
+    data?: Proto['dbType'];
+    protected constructor(collection: FirestoreCollection<Proto>, ref: FirestoreType_DocumentReference<Proto['dbType']>, data?: Proto['dbType']);
+    fromCache: () => Proto["dbType"] | undefined;
+    cleanCache: () => DocWrapper<Proto>;
+    private assertId;
+    get: () => Promise<Proto["dbType"] | undefined>;
+    prepareForCreate: (preDBItem: Proto["uiType"], upgrade?: boolean) => Promise<Proto["dbType"]>;
+    create: (preDBItem: Proto["uiType"]) => Promise<Proto["dbType"]>;
+    prepareForSet: (updatedDBItem: Proto["dbType"], dbItem?: Proto["dbType"], upgrade?: boolean) => Promise<Proto["dbType"]>;
+    set: (item: Proto["uiType"] | Proto["dbType"]) => Promise<Proto["dbType"]>;
+    private postWriteProcessing;
+    prepareForUpdate(updateData: UpdateObject<Proto['dbType']>): Promise<UpdateObject<Proto["dbType"]>>;
+    /**
+     * Recursively replaces any undefined or null fields in DB item with firestore.FieldValue.delete()
+     */
+    private updateDeletedFields;
+    update: (updateData: UpdateObject<Proto["dbType"]>) => Promise<Proto["dbType"] | undefined>;
+    delete: () => Promise<Proto["dbType"] | undefined>;
+}

package/{firestore-v3/DocWrapperV3.js → firestore/DocWrapper.js}

@@ -1,10 +1,10 @@
 import { _keys, currentTimeMillis, exists, MUSTNeverHappenException } from '@nu-art/ts-common';
-import { assertUniqueId } from './FirestoreCollectionV3.js';
+import { assertUniqueId } from './FirestoreCollection.js';
 import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
-import { addDeletedToTransaction } from './consts.js';
+import { addDeletedToTransaction, getActiveTransaction } from './consts.js';
 import admin from 'firebase-admin';
 const { FieldValue } = admin.firestore;
-export class DocWrapperV3 {
+export class DocWrapper {
     ref;
     collection;
     data;
@@ -25,12 +25,13 @@ export class DocWrapperV3 {
         if (item._id !== this.ref.id)
             throw new MUSTNeverHappenException(`Composed _id does not match doc ref id! \n expected: ${this.ref.id} \n actual: ${item._id} \n`);
     }
-    get = async (transaction) => {
+    get = async () => {
+        const transaction = getActiveTransaction();
         if (transaction)
             return this.data ?? (this.data = (await transaction.get(this.ref)).data());
         return this.data ?? (this.data = (await this.ref.get()).data());
     };
-    prepareForCreate = async (preDBItem, transaction, upgrade = true) => {
+    prepareForCreate = async (preDBItem, upgrade = true) => {
         const now = currentTimeMillis();
         this.assertId(preDBItem);
         preDBItem.__updated = preDBItem.__created = now;
@@ -38,24 +39,25 @@ export class DocWrapperV3 {
             preDBItem._v = this.collection.getVersion();
             await this.collection.hooks?.upgradeInstances([preDBItem]);
         }
-        await this.collection.hooks?.preWriteProcessing?.(preDBItem, undefined, transaction);
+        await this.collection.hooks?.preWriteProcessing?.(preDBItem, undefined);
         this.collection.validateItem(preDBItem);
         return preDBItem;
     };
-    create = async (preDBItem, transaction) => {
+    create = async (preDBItem) => {
         const dbItem = await this.prepareForCreate(preDBItem);
+        const transaction = getActiveTransaction();
         if (transaction) {
             transaction.create(this.ref, dbItem);
             this.data = dbItem;
         }
         else
             await this.ref.create(dbItem);
-        this.postWriteProcessing({ updated: dbItem }, 'create', transaction);
+        this.postWriteProcessing({ updated: dbItem }, 'create');
         return dbItem;
     };
-    prepareForSet = async (updatedDBItem, dbItem, transaction, upgrade = true) => {
+    prepareForSet = async (updatedDBItem, dbItem, upgrade = true) => {
         if (!dbItem)
-            return this.prepareForCreate(updatedDBItem, transaction);
+            return this.prepareForCreate(updatedDBItem);
         this.assertId(updatedDBItem);
         updatedDBItem.__created = dbItem.__created;
         this.collection.dbDef.lockKeys?.forEach(lockedKey => {
@@ -67,24 +69,25 @@ export class DocWrapperV3 {
             await this.collection.hooks?.upgradeInstances([updatedDBItem]);
         }
         updatedDBItem._v = this.collection.getVersion();
-        await this.collection.hooks?.preWriteProcessing?.(updatedDBItem, dbItem, transaction);
+        await this.collection.hooks?.preWriteProcessing?.(updatedDBItem, dbItem);
         this.collection.validateItem(updatedDBItem);
         return updatedDBItem;
     };
-    set = async (item, transaction) => {
+    set = async (item) => {
+        const transaction = getActiveTransaction();
         if (!transaction)
-            return this.collection.runTransaction((transaction) => this.set(item, transaction));
-        const currDBItem = await this.get(transaction);
+            return this.collection.runTransaction(() => this.set(item));
+        const currDBItem = await this.get();
         if ((currDBItem?.__updated || 0) > (item.__updated || currentTimeMillis()))
             throw HttpCodes._4XX.ENTITY_IS_OUTDATED('Item is outdated', `${this.collection.collection.path}/${currDBItem?._id} is outdated`);
-        const newDBItem = await this.prepareForSet(item, currDBItem, transaction, false);
-        // Will always get here with a transaction!
+        const newDBItem = await this.prepareForSet(item, currDBItem, false);
         transaction.set(this.ref, newDBItem);
         this.data = currDBItem;
-        this.postWriteProcessing({ updated: newDBItem, before: currDBItem }, 'set', transaction);
+        this.postWriteProcessing({ updated: newDBItem, before: currDBItem }, 'set');
         return newDBItem;
     };
-    postWriteProcessing(data, actionType, transaction) {
+    postWriteProcessing(data, actionType) {
+        const transaction = getActiveTransaction();
         const toExecute = () => this.collection.hooks?.postWriteProcessing?.(data, actionType);
         if (transaction)
             // @ts-ignore
@@ -92,21 +95,16 @@ export class DocWrapperV3 {
         else
             toExecute();
     }
-    async prepareForUpdate(updateData, transaction) {
+    async prepareForUpdate(updateData) {
         delete updateData.__created;
         delete updateData._v;
         updateData.__updated = currentTimeMillis();
-        // this.collection.dbDef.lockKeys?.forEach(lockedKey => {
-        // 	(updateData as Partial<Proto['dbType']>)[lockedKey] = undefined;
-        // });
         this.updateDeletedFields(updateData);
-        await this.collection.validateUpdateData(updateData, transaction);
+        await this.collection.validateUpdateData(updateData);
         return updateData;
     }
     /**
      * Recursively replaces any undefined or null fields in DB item with firestore.FieldValue.delete()
-     * @private
-     * @param updateData
      */
     updateDeletedFields(updateData) {
         if (typeof updateData !== 'object' || updateData === null)
@@ -128,21 +126,21 @@ export class DocWrapperV3 {
         this.postWriteProcessing({ updated: dbItem }, 'update');
         return dbItem;
     };
-    delete = async (transaction) => {
+    delete = async () => {
+        const transaction = getActiveTransaction();
         if (!transaction)
-            return this.collection.runTransaction(transaction => this.delete(transaction));
-        const dbItem = await this.get(transaction);
+            return this.collection.runTransaction(() => this.delete());
+        const dbItem = await this.get();
         if (!dbItem)
             return;
-        addDeletedToTransaction(transaction, {
+        addDeletedToTransaction({
             dbKey: this.collection.dbDef.entityName,
             ids: [dbItem._id]
         });
-        await this.collection.hooks?.canDeleteItems([dbItem], transaction);
-        // Will always get here with a transaction!
+        await this.collection.hooks?.canDeleteItems([dbItem]);
         transaction.delete(this.ref);
         this.cleanCache();
-        this.postWriteProcessing({ deleted: dbItem }, 'delete', transaction);
+        this.postWriteProcessing({ deleted: dbItem }, 'delete');
         return dbItem;
     };
 }

package/firestore/FirestoreCollection.d.ts

@@ -1,71 +1,153 @@
-import { Subset, TS_Object } from '@nu-art/ts-common';
-import { FirestoreType_Collection, FirestoreType_DocumentSnapshot } from './types.js';
-import { Clause_Select, Clause_Where, FilterKeys, FirestoreQuery } from '@nu-art/firebase-shared';
+import { Database, DB_Prototype } from '@nu-art/db-api-shared';
+import { CustomException, InvalidResult, Logger, TS_Object, UniqueId } from '@nu-art/ts-common';
+import { FirestoreType_Collection, FirestoreType_DocumentReference } from './types.js';
+import { Clause_Where, FirestoreQuery, MultiWriteOperation } from '@nu-art/firebase-shared';
 import { FirestoreWrapperBE } from './FirestoreWrapperBE.js';
-import { FirestoreTransaction } from './FirestoreTransaction.js';
-import { Transaction } from 'firebase-admin/firestore';
+import { firestore } from 'firebase-admin';
+import { DocWrapper, UpdateObject } from './DocWrapper.js';
+import UpdateData = firestore.UpdateData;
+export type PostWriteProcessingData<DBType extends TS_Object> = {
+    before?: DBType | DBType[];
+    updated?: DBType | DBType[];
+    deleted?: DBType | DBType[] | null;
+};
+export type CollectionActionType = 'create' | 'set' | 'update' | 'delete';
+export type FirestoreCollectionHooks<DBType extends TS_Object> = {
+    canDeleteItems: (dbItems: DBType[]) => Promise<void>;
+    preWriteProcessing?: (dbInstance: DBType, originalDbInstance?: DBType) => Promise<void>;
+    manipulateQuery?: (query: FirestoreQuery<DBType>) => FirestoreQuery<DBType>;
+    postWriteProcessing?: (data: PostWriteProcessingData<DBType>, actionType: CollectionActionType) => Promise<void>;
+    upgradeInstances: (instances: DBType[]) => Promise<any>;
+};
+export type MultiWriteItem<Op extends MultiWriteOperation, DBType extends TS_Object> = Op extends 'delete' ? undefined : Op extends 'update' ? UpdateObject<DBType> : DBType;
+type MultiWriteType = 'bulk' | 'batch';
 /**
- * FirestoreCollection is a class for handling Firestore collections. It takes in the name, FirestoreWrapperBE instance, and uniqueKeys as parameters.
+ * # <ins>FirestoreBulkException</ins>
+ * @category Exceptions
  */
-export declare class FirestoreCollection<Type extends TS_Object> {
-    readonly name: string;
+export declare class FirestoreBulkException extends CustomException {
+    causes?: Error[];
+    constructor(causes?: Error[]);
+}
+/**
+ * FirestoreCollection is a class for handling Firestore collections.
+ */
+export declare class FirestoreCollection<Proto extends DB_Prototype> extends Logger {
     readonly wrapper: FirestoreWrapperBE;
     readonly collection: FirestoreType_Collection;
+    readonly dbDef: Database<Proto>;
+    readonly uniqueKeys: Proto['uniqueKeys'][] | string[];
+    private readonly validator;
+    readonly hooks?: FirestoreCollectionHooks<Proto['dbType']>;
+    constructor(wrapper: FirestoreWrapperBE, _dbDef: Database<Proto>, hooks?: FirestoreCollectionHooks<Proto['dbType']>);
+    doc: Readonly<{
+        _: (ref: FirestoreType_DocumentReference<Proto["dbType"]>, data?: Proto["dbType"]) => DocWrapper<Proto>;
+        unique: (id: Proto["uniqueParam"]) => DocWrapper<Proto>;
+        item: (item: Proto["uiType"]) => DocWrapper<Proto>;
+        all: (_ids: (Proto["uniqueParam"])[]) => DocWrapper<Proto>[];
+        allItems: (preDBItems: Proto["uiType"][]) => DocWrapper<Proto>[];
+        query: (query: FirestoreQuery<Proto["dbType"]>) => Promise<DocWrapper<Proto>[]>;
+        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>) => Promise<DocWrapper<Proto>[]>;
+    }>;
+    private getAll;
+    private _customQuery;
+    query: Readonly<{
+        unique: (_id: Proto["uniqueParam"]) => Promise<Proto["dbType"] | undefined>;
+        uniqueAssert: (_id: Proto["uniqueParam"]) => Promise<Proto["dbType"]>;
+        uniqueWhere: (where: Clause_Where<Proto["dbType"]>) => Promise<Proto["dbType"]>;
+        uniqueCustom: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"]>;
+        all: (_ids: (Proto["uniqueParam"])[]) => Promise<(Proto["dbType"] | undefined)[]>;
+        custom: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        where: (where: Clause_Where<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+    }>;
+    uniqueGetOrCreate: (where: Clause_Where<Proto["dbType"]>, toCreate: () => Promise<Proto["uiType"]>) => Promise<Proto["dbType"] | Proto["uiType"]>;
+    protected _createAll: (preDBItems: Proto["uiType"][], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+    create: Readonly<{
+        item: (preDBItem: Proto["uiType"]) => Promise<Proto["dbType"]>;
+        all: (preDBItems: Proto["uiType"][], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+    }>;
+    private _setAll;
+    set: Readonly<{
+        item: (preDBItem: Proto["uiType"]) => Promise<Proto["dbType"]>;
+        all: (items: (Proto["uiType"] | Proto["dbType"])[]) => Promise<Awaited<Proto["dbType"]>[]>;
+        /**
+         * Multi is a non atomic operation
+         */
+        multi: (items: (Proto["uiType"] | Proto["dbType"])[], multiWriteType?: MultiWriteType) => Promise<Awaited<Proto["dbType"]>[]>;
+    }>;
+    private upgradeInstances;
+    protected _updateAll: (updateData: UpdateObject<Proto["dbType"]>[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+    validateUpdateData(updateData: UpdateData<Proto['dbType']>): Promise<void>;
+    protected _deleteQuery: (query: FirestoreQuery<Proto["dbType"]>, multiWriteType?: MultiWriteType) => Promise<NonNullable<Proto["dbType"]>[]>;
+    protected _deleteUnManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>, multiWriteType?: MultiWriteType) => Promise<NonNullable<Proto["dbType"]>[]>;
+    protected _deleteAll: (docsToBeDeleted: DocWrapper<Proto>[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+    private deleteCollection;
+    delete: Readonly<{
+        unique: (id: Proto["uniqueParam"]) => Promise<Proto["dbType"] | undefined>;
+        item: (item: Proto["uiType"]) => Promise<Proto["dbType"] | undefined>;
+        all: (ids: (Proto["uniqueParam"])[]) => Promise<Proto["dbType"][]>;
+        allDocs: (docs: DocWrapper<Proto>[]) => Promise<Proto["dbType"][]>;
+        allItems: (items: Proto["uiType"][]) => Promise<Proto["dbType"][]>;
+        query: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        where: (where: Clause_Where<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        /**
+         * Multi is a non atomic operation — doesn't use transactions. Use 'all' variants for transaction.
+         */
+        multi: {
+            all: (ids: UniqueId[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+            items: (items: Proto["uiType"][], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+            allDocs: (docs: DocWrapper<Proto>[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
+            query: (query: FirestoreQuery<Proto["dbType"]>, multiWriteType?: MultiWriteType) => Promise<NonNullable<Proto["dbType"]>[]>;
+        };
+        yes: {
+            iam: {
+                sure: {
+                    iwant: {
+                        todelete: {
+                            the: {
+                                collection: {
+                                    delete: () => Promise<void>;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    }>;
     /**
-     * External unique as in there must never ever be two that answer the same query
-     */
-    readonly externalUniqueFilter: ((object: Subset<Type>) => Clause_Where<Type>);
-    /**
-     * @param name
-     * @param wrapper
-     * @param uniqueKeys
+     * @param writer Type of BulkWriter - can be Bulk writer or Batch writer
+     * @param doc
+     * @param operation create/update/set/delete
+     * @param item - mandatory for everything but delete
      */
-    constructor(name: string, wrapper: FirestoreWrapperBE, uniqueKeys?: FilterKeys<Type>);
+    private addToMultiWrite;
+    private multiWrite;
+    private bulkWrite;
     /**
-     Executes a Firestore query on the collection.
-     @param ourQuery - The query to execute.
-     @returns A Promise that resolves to an array of FirestoreType_DocumentSnapshot objects.
-     @private
+     * @param docs docs to write to
+     * @param operation create/update/set/delete
+     * @param items mandatory for everything but delete
      */
-    private _query;
+    private batchWrite;
     /**
-
-     Executes a unique Firestore query on the collection.
-     @param ourQuery - The query to execute.
-     @returns A Promise that resolves to a single FirestoreType_DocumentSnapshot object, or undefined if no match is found.
-     @private
+     * Runs the processor within a Firestore transaction scope. If already inside a transaction
+     * (detected via MemKey), the existing transaction is reused. Otherwise a new one is created.
      */
-    private _queryUnique;
-    /**
-     Executes a unique Firestore query on the collection and returns the matching object.
-     @param ourQuery - The query to execute.
-     @returns A Promise that resolves to the matching object, or undefined if no match is found.
-     */
-    queryUnique(ourQuery: FirestoreQuery<Type>): Promise<Type | undefined>;
-    insert(instance: Type, _id?: string): Promise<Type>;
-    insertAll(instances: Type[]): Promise<Awaited<Type>[]>;
-    query(ourQuery: FirestoreQuery<Type>): Promise<Type[]>;
-    upsert(instance: Type): Promise<Type>;
-    upsertAll(instances: Type[]): Promise<Type[]>;
-    patch(instance: Subset<Type>): Promise<Type>;
-    deleteItem(instance: Type): Promise<Type | undefined>;
-    deleteUnique(query: FirestoreQuery<Type>): Promise<Type | undefined>;
-    delete(query: FirestoreQuery<Type>): Promise<Type[]>;
-    private deleteBatch;
-    deleteAll(): Promise<Type[]>;
-    getAll(select?: Clause_Select<Type>): Promise<Type[]>;
-    runInTransaction<ReturnType>(processor: (transaction: FirestoreTransaction) => Promise<ReturnType>): Promise<ReturnType>;
-    createDocumentReference(_id?: string): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
-    getUniqueFilter: () => (object: Subset<Type>) => Clause_Where<Type>;
-    newQueryUnique(ourQuery: FirestoreQuery<Type>): Promise<DocWrapper<Type> | undefined>;
-    newQuery(ourQuery: FirestoreQuery<Type>): Promise<DocWrapper<Type>[]>;
-}
-export declare class DocWrapper<T extends TS_Object> {
-    wrapper: FirestoreWrapperBE;
-    doc: FirestoreType_DocumentSnapshot<T>;
-    constructor(wrapper: FirestoreWrapperBE, doc: FirestoreType_DocumentSnapshot<T>);
-    runInTransaction<R>(processor: (transaction: Transaction) => Promise<R>): Promise<R>;
-    delete: (transaction?: Transaction) => Promise<T>;
-    get: () => T;
-    set: (instance: T, transaction?: Transaction) => Promise<T>;
+    runTransaction: <ReturnType>(processor: () => Promise<ReturnType>) => Promise<ReturnType>;
+    runTransactionInChunks: <T = any, R = any>(items: T[], processor: (chunk: typeof items) => Promise<R[]>, chunkSize?: number) => Promise<R[]>;
+    getVersion: () => any;
+    needsUpgrade: (version?: string) => boolean;
+    validateItem(dbItem: Proto['dbType']): void;
+    protected onValidationError(instance: Proto['dbType'], results: InvalidResult<Proto['dbType']>): void;
+    private assertNoDuplicatedIds;
+    composeDbObjectUniqueId: (item: Proto["uiType"]) => string;
 }
+/**
+ * If the collection has unique keys, assert they exist, and use them to generate the _id.
+ * In the case an _id already exists, verify it is not different from the uniqueKeys-generated _id.
+ */
+export declare const assertUniqueId: <Proto extends DB_Prototype>(item: Proto["dbType"], keys: Proto["uniqueKeys"]) => Proto["dbType"]["_id"];
+export {};