@nu-art/firebase-backend 0.401.9 → 0.500.6

package/firestore/FirestoreWrapperBE.js

@@ -17,7 +17,10 @@
  */
 import { FirestoreCollection, } from './FirestoreCollection.js';
 import { FirebaseBaseWrapper } from '../auth/FirebaseBaseWrapper.js';
-import { getFirestore } from 'firebase-admin/firestore';
+import { Promise_all_sequentially } from '@nu-art/ts-common';
+import { DocumentReference, DocumentSnapshot, getFirestore, QuerySnapshot, } from 'firebase-admin/firestore';
+import { getActiveTransaction, MemKey_FirestoreTransaction } from './consts.js';
+import { MemStorage } from '@nu-art/ts-common/mem-storage';
 export class FirestoreWrapperBE extends FirebaseBaseWrapper {
     firestore;
     collections = {};
@@ -28,20 +31,127 @@ export class FirestoreWrapperBE extends FirebaseBaseWrapper {
         else
             this.firestore = getFirestore(firebaseSession.app);
     }
-    getCollection(name, uniqueKeys) {
-        const collection = this.collections[name];
+    runTransaction = async (processor) => {
+        if (getActiveTransaction())
+            return processor();
+        const postTransactionActions = [];
+        const toRet = await this.firestore.runTransaction(async (transaction) => {
+            const writeActions = [];
+            const transactionUpdates = {};
+            // @ts-ignore
+            transaction.postTransaction = (action) => {
+                return postTransactionActions.push(action);
+            };
+            // @ts-ignore
+            transaction.__nu_art__WriteActions = writeActions;
+            const originSet = transaction.set.bind(transaction);
+            const originDelete = transaction.delete.bind(transaction);
+            const originCreate = transaction.create.bind(transaction);
+            const originGet = transaction.get.bind(transaction);
+            const originGetAll = transaction.getAll.bind(transaction);
+            const getMockDocumentSnapshot = (data, _id, exists = true) => {
+                return {
+                    id: _id,
+                    ref: {},
+                    exists,
+                    data: () => (exists ? data : undefined),
+                    get: (fieldPath) => data[fieldPath],
+                    metadata: {},
+                };
+            };
+            const updateTransactionUpdates = async (data, exists = true) => {
+                let _data;
+                let _id;
+                if (data instanceof DocumentReference) {
+                    _id = data.id;
+                    _data = (await data.get()).data();
+                }
+                else {
+                    _id = data._id;
+                    _data = data;
+                }
+                transactionUpdates[_id] = getMockDocumentSnapshot(_data, _id, exists);
+            };
+            transaction.set = (documentRef, data) => {
+                updateTransactionUpdates(data);
+                writeActions.push(() => originSet(documentRef, data));
+                return transaction;
+            };
+            transaction.create = (documentRef, data) => {
+                updateTransactionUpdates(data);
+                writeActions.push(() => originCreate(documentRef, data));
+                return transaction;
+            };
+            transaction.delete = (documentRef, precondition) => {
+                updateTransactionUpdates(documentRef, false);
+                writeActions.push(() => originDelete(documentRef, precondition));
+                return transaction;
+            };
+            // @ts-ignore
+            transaction.get = async (args) => {
+                // @ts-ignore
+                const doc = await originGet(args);
+                if (doc instanceof DocumentSnapshot) {
+                    const document = doc.data();
+                    if (!document)
+                        return doc;
+                    return transactionUpdates[document._id] ?? doc;
+                }
+                if (doc instanceof QuerySnapshot) {
+                    const docs = doc.docs;
+                    // @ts-ignore
+                    return {
+                        docs: docs.map(doc => {
+                            const _doc = doc.data();
+                            if (!_doc)
+                                return doc;
+                            return transactionUpdates[_doc._id] ?? doc;
+                        })
+                    };
+                }
+                return doc;
+            };
+            // @ts-ignore
+            transaction.getAll = async (...documentRefsOrReadOptions) => {
+                const docs = await originGetAll(...documentRefsOrReadOptions);
+                return docs.map(doc => {
+                    const _doc = doc.data();
+                    if (!_doc)
+                        return doc;
+                    return transactionUpdates[_doc._id] ?? doc;
+                });
+            };
+            const parentStorage = MemStorage.getStore();
+            return new MemStorage().init(async () => {
+                const wrapper = { transaction, active: true };
+                MemKey_FirestoreTransaction.set(wrapper);
+                try {
+                    const toRet = await processor();
+                    writeActions.forEach(action => action());
+                    return toRet;
+                }
+                finally {
+                    wrapper.active = false;
+                }
+            }, parentStorage);
+        });
+        await Promise_all_sequentially(postTransactionActions);
+        return toRet;
+    };
+    getCollection(dbDef, hooks) {
+        const collection = this.collections[dbDef.dbKey];
         if (collection)
             return collection;
-        return this.collections[name] = new FirestoreCollection(name, this, uniqueKeys);
+        return this.collections[dbDef.dbKey] = new FirestoreCollection(this, dbDef, hooks);
     }
     listen(collection, doc) {
-        collection.wrapper.firestore.doc(`${collection.name}/${doc}`).onSnapshot(() => {
-            this.logInfo('recieved snapshot!');
+        collection.wrapper.firestore.doc(`${collection.collection.path}/${doc}`).onSnapshot(() => {
+            this.logInfo('received snapshot!');
         });
     }
-    async deleteCollection(name) {
-        return this.getCollection(name).deleteAll();
-    }
+    // public async deleteCollection(name: string) {
+    // 	return this.getCollection(name).deleteAll();
+    // }
     async listCollections() {
         if (!this.firestore.listCollections)
             return [];

package/firestore/MongoCollection.d.ts

@@ -0,0 +1,81 @@
+import { Database, DB_Prototype } from '@nu-art/db-api-shared';
+import { InvalidResult, Logger, UniqueId } from '@nu-art/ts-common';
+import { Clause_Where, FirestoreQuery } from '@nu-art/firebase-shared';
+import { FirestoreCollectionHooks } from './FirestoreCollection.js';
+import type { Collection as MongoDriverCollection, Db as MongoDriverDb } from 'mongodb';
+export declare class MongoCollection<Proto extends DB_Prototype> extends Logger {
+    readonly db: MongoDriverDb;
+    readonly mongoCollection: MongoDriverCollection<Proto['dbType']>;
+    readonly dbDef: Database<Proto>;
+    readonly uniqueKeys: Proto['uniqueKeys'][] | string[];
+    private readonly validator;
+    readonly hooks?: FirestoreCollectionHooks<Proto['dbType']>;
+    constructor(db: MongoDriverDb, _dbDef: Database<Proto>, hooks?: FirestoreCollectionHooks<Proto['dbType']>);
+    private getSession;
+    private sessionOpts;
+    private assertUniqueId;
+    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"]>;
+    private prepareForCreate;
+    private prepareForSet;
+    create: Readonly<{
+        item: (preDBItem: Proto["uiType"]) => Promise<Proto["dbType"]>;
+        all: (preDBItems: Proto["uiType"][]) => Promise<Proto["dbType"][]>;
+    }>;
+    set: Readonly<{
+        item: (preDBItem: Proto["uiType"]) => Promise<Proto["dbType"]>;
+        all: (items: (Proto["uiType"] | Proto["dbType"])[]) => Promise<Proto["dbType"][]>;
+        multi: (items: (Proto["uiType"] | Proto["dbType"])[]) => Promise<Proto["dbType"][]>;
+    }>;
+    private _setAll;
+    private _deleteAll;
+    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"][]>;
+        allItems: (items: Proto["uiType"][]) => Promise<Proto["dbType"][]>;
+        query: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        allDocs: (_docs: any[]) => Promise<Proto["dbType"][]>;
+        where: (where: Clause_Where<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        multi: {
+            all: (ids: UniqueId[]) => Promise<Proto["dbType"][]>;
+            items: (items: Proto["uiType"][]) => Promise<Proto["dbType"][]>;
+            allDocs: (_docs: any[]) => Promise<Proto["dbType"][]>;
+            query: (query: FirestoreQuery<Proto["dbType"]>) => Promise<Proto["dbType"][]>;
+        };
+        yes: {
+            iam: {
+                sure: {
+                    iwant: {
+                        todelete: {
+                            the: {
+                                collection: {
+                                    delete: () => Promise<void>;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    }>;
+    runTransaction: <ReturnType>(processor: () => Promise<ReturnType>, label?: string) => 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;
+}

package/firestore/MongoCollection.js

@@ -0,0 +1,426 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { dbObjectToId } from '@nu-art/db-api-shared';
+import { __stringify, _keys, ApiException, BadImplementationException, batchActionParallel, compare, Const_UniqueKeys, currentTimeMillis, DB_Object_validator, dbIdLength, deepClone, DefaultDBVersion, exists, filterDuplicates, filterInstances, generateHex, keepPartialObject, Logger, MUSTNeverHappenException, StaticLogger, tsValidateResult, ValidationException, } from '@nu-art/ts-common';
+import { composeDbObjectUniqueId, _EmptyQuery, maxBatch } from '@nu-art/firebase-shared';
+import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
+import { addDeletedToTransaction, getActiveTransaction, markTransactionWrite, MemKey_FirestoreTransaction } from './consts.js';
+import { MongoInterface } from './MongoInterface.js';
+import { MemStorage } from '@nu-art/ts-common/mem-storage';
+const getDbDefValidator = (dbDef) => {
+    if (typeof dbDef.modifiablePropsValidator === 'object' && typeof dbDef.generatedPropsValidator === 'object')
+        return { ...dbDef.generatedPropsValidator, ...dbDef.modifiablePropsValidator, ...DB_Object_validator };
+    if (typeof dbDef.modifiablePropsValidator === 'function' && typeof dbDef.generatedPropsValidator === 'function')
+        return [dbDef.modifiablePropsValidator, dbDef.generatedPropsValidator];
+    if (typeof dbDef.modifiablePropsValidator === 'function')
+        return [dbDef.modifiablePropsValidator, (instance) => {
+                const partialInstance = keepPartialObject(instance, _keys(dbDef.generatedPropsValidator));
+                return tsValidateResult(partialInstance, dbDef.generatedPropsValidator);
+            }];
+    return [dbDef.generatedPropsValidator, (instance) => {
+            return tsValidateResult(keepPartialObject(instance, _keys(dbDef.modifiablePropsValidator)), dbDef.modifiablePropsValidator);
+        }];
+};
+export class MongoCollection extends Logger {
+    db;
+    mongoCollection;
+    dbDef;
+    uniqueKeys;
+    validator;
+    hooks;
+    constructor(db, _dbDef, hooks) {
+        super();
+        this.db = db;
+        if (!/[a-z-]{3,}/.test(_dbDef.backend.name))
+            StaticLogger.logWarning('Please follow name pattern for collections /[a-z-]{3,}/');
+        this.mongoCollection = db.collection(_dbDef.backend.name);
+        this.dbDef = _dbDef;
+        this.uniqueKeys = this.dbDef.uniqueKeys || Const_UniqueKeys;
+        this.validator = getDbDefValidator(_dbDef);
+        this.hooks = hooks;
+    }
+    getSession() {
+        const tx = getActiveTransaction();
+        if (!tx)
+            return undefined;
+        if ('abortTransaction' in tx) {
+            const session = tx;
+            const txState = session.transaction?.state;
+            if (txState === 'TRANSACTION_COMMITTED' || txState === 'TRANSACTION_ABORTED')
+                this.logWarning(`SESSION-STALE [${this.dbDef.dbKey}] txState=${txState}`);
+            return session;
+        }
+        return undefined;
+    }
+    sessionOpts() {
+        const session = this.getSession();
+        return session ? { session } : {};
+    }
+    assertUniqueId(item) {
+        if (compare(this.uniqueKeys, Const_UniqueKeys))
+            return (item._id ?? generateHex(dbIdLength));
+        const _id = composeDbObjectUniqueId(item, this.uniqueKeys);
+        if (exists(item._id) && _id !== item._id)
+            throw new MUSTNeverHappenException(`Composed _id does not match existing _id! expected: ${_id}, actual: ${item._id}`);
+        return _id;
+    }
+    async _customQuery(tsQuery, canManipulateQuery) {
+        if (canManipulateQuery)
+            tsQuery = this.hooks?.manipulateQuery?.(deepClone(tsQuery)) ?? tsQuery;
+        const compiled = MongoInterface.buildQuery(tsQuery);
+        let cursor = this.mongoCollection.find(compiled.filter, this.sessionOpts());
+        if (compiled.sort)
+            cursor = cursor.sort(compiled.sort);
+        if (compiled.projection)
+            cursor = cursor.project(compiled.projection);
+        if (compiled.skip)
+            cursor = cursor.skip(compiled.skip);
+        if (compiled.limit)
+            cursor = cursor.limit(compiled.limit);
+        return await cursor.toArray();
+    }
+    query = Object.freeze({
+        unique: async (_id) => {
+            const idStr = typeof _id !== 'string' ? this.assertUniqueId(_id) : _id;
+            const result = await this.mongoCollection.findOne({ _id: idStr }, this.sessionOpts());
+            return result;
+        },
+        uniqueAssert: async (_id) => {
+            const result = await this.query.unique(_id);
+            if (!result)
+                throw new ApiException(404, `Could not find ${this.dbDef.entityName} with _id: ${__stringify(_id)}`);
+            return result;
+        },
+        uniqueWhere: async (where) => this.query.uniqueCustom({ where }),
+        uniqueCustom: async (query) => {
+            const results = await this.query.custom(query);
+            if (results.length === 0)
+                throw new ApiException(404, `Could not find ${this.dbDef.entityName} with unique query: ${JSON.stringify(query)}`);
+            if (results.length > 1)
+                throw new BadImplementationException(`Too many results (${results.length}) in collection (${this.dbDef.dbKey}) for query: ${__stringify(query)}`);
+            return results[0];
+        },
+        all: async (_ids) => {
+            const idStrs = _ids.map(id => typeof id !== 'string' ? this.assertUniqueId(id) : id);
+            const results = await this.mongoCollection.find({ _id: { $in: idStrs } }, this.sessionOpts()).toArray();
+            const resultMap = new Map(results.map(r => [r._id, r]));
+            return idStrs.map(id => resultMap.get(id));
+        },
+        custom: async (query) => {
+            return this._customQuery(query, true);
+        },
+        where: async (where) => {
+            return this.query.custom({ where });
+        },
+        unManipulatedQuery: async (query) => {
+            return this._customQuery(query, false);
+        },
+    });
+    uniqueGetOrCreate = async (where, toCreate) => {
+        try {
+            return await this.query.uniqueWhere(where);
+        }
+        catch (e) {
+            return toCreate();
+        }
+    };
+    prepareForCreate = async (item, upgrade = true) => {
+        const now = currentTimeMillis();
+        item._id = this.assertUniqueId(item);
+        item.__updated = item.__created = now;
+        if (upgrade) {
+            item._v = this.getVersion();
+            await this.hooks?.upgradeInstances([item]);
+        }
+        await this.hooks?.preWriteProcessing?.(item, undefined);
+        this.validateItem(item);
+        return item;
+    };
+    prepareForSet = async (updatedItem, dbItem, upgrade = true) => {
+        if (!dbItem)
+            return this.prepareForCreate(updatedItem);
+        updatedItem._id = this.assertUniqueId(updatedItem);
+        updatedItem.__created = dbItem.__created;
+        this.dbDef.lockKeys?.forEach(lockedKey => {
+            if (exists(dbItem[lockedKey]))
+                updatedItem[lockedKey] = dbItem[lockedKey];
+        });
+        updatedItem.__updated = currentTimeMillis();
+        if (this.needsUpgrade(updatedItem._v))
+            await this.hooks?.upgradeInstances([updatedItem]);
+        updatedItem._v = this.getVersion();
+        await this.hooks?.preWriteProcessing?.(updatedItem, dbItem);
+        this.validateItem(updatedItem);
+        return updatedItem;
+    };
+    create = Object.freeze({
+        item: async (preDBItem) => {
+            const dbItem = await this.prepareForCreate(preDBItem);
+            markTransactionWrite();
+            await this.mongoCollection.insertOne(dbItem, this.sessionOpts());
+            await this.hooks?.postWriteProcessing?.({ updated: dbItem }, 'create');
+            return dbItem;
+        },
+        all: async (preDBItems) => {
+            if (preDBItems.length === 1)
+                return [await this.create.item(preDBItems[0])];
+            const dbItems = await Promise.all(preDBItems.map(item => this.prepareForCreate(item)));
+            this.assertNoDuplicatedIds(dbItems, 'create.all');
+            markTransactionWrite();
+            await this.mongoCollection.insertMany(dbItems, this.sessionOpts());
+            await this.hooks?.postWriteProcessing?.({ updated: dbItems }, 'create');
+            return dbItems;
+        },
+    });
+    set = Object.freeze({
+        item: async (preDBItem) => {
+            const session = this.getSession();
+            if (!session)
+                return this.runTransaction(() => this.set.item(preDBItem), 'set.item');
+            preDBItem._id = this.assertUniqueId(preDBItem);
+            const currDBItem = await this.query.unique(preDBItem._id);
+            if ((currDBItem?.__updated || 0) > (preDBItem.__updated || currentTimeMillis()))
+                throw HttpCodes._4XX.ENTITY_IS_OUTDATED('Item is outdated', `${this.dbDef.backend.name}/${currDBItem?._id} is outdated`);
+            const dbItem = await this.prepareForSet(preDBItem, currDBItem, false);
+            markTransactionWrite();
+            await this.mongoCollection.replaceOne({ _id: dbItem._id }, dbItem, { upsert: true, ...this.sessionOpts() });
+            await this.hooks?.postWriteProcessing?.({ before: currDBItem, updated: dbItem }, 'set');
+            return dbItem;
+        },
+        all: async (items) => {
+            if (this.getSession())
+                return this._setAll(items);
+            return this.runTransactionInChunks(items, (chunk) => this._setAll(chunk));
+        },
+        multi: async (items) => {
+            return this._setAll(items);
+        },
+    });
+    _setAll = async (items) => {
+        const ids = items.map(item => {
+            item._id = this.assertUniqueId(item);
+            return item._id;
+        });
+        const existingItems = await this.query.all(ids);
+        const existingMap = new Map(filterInstances(existingItems).map(item => [item._id, item]));
+        const preparedItems = await Promise.all(items.map(async (item) => {
+            const existing = existingMap.get(item._id);
+            return !exists(existing)
+                ? await this.prepareForCreate(item)
+                : await this.prepareForSet(item, existing);
+        }));
+        this.assertNoDuplicatedIds(preparedItems, 'set.all');
+        const ops = preparedItems.map(item => ({
+            replaceOne: {
+                filter: { _id: item._id },
+                replacement: item,
+                upsert: true,
+            }
+        }));
+        markTransactionWrite();
+        await this.mongoCollection.bulkWrite(ops, this.sessionOpts());
+        if (preparedItems.length)
+            await this.hooks?.postWriteProcessing?.({ before: existingItems, updated: preparedItems }, 'set');
+        return preparedItems;
+    };
+    _deleteAll = async (ids) => {
+        const items = filterInstances(await this.query.all(ids));
+        addDeletedToTransaction({
+            dbKey: this.dbDef.dbKey,
+            ids: items.map(dbObjectToId)
+        });
+        await this.hooks?.canDeleteItems(items);
+        markTransactionWrite();
+        await this.mongoCollection.deleteMany({ _id: { $in: ids } }, this.sessionOpts());
+        await this.hooks?.postWriteProcessing?.({ deleted: items }, 'delete');
+        return items;
+    };
+    delete = Object.freeze({
+        unique: async (id) => {
+            const idStr = typeof id !== 'string' ? this.assertUniqueId(id) : id;
+            const session = this.getSession();
+            if (!session)
+                return this.runTransaction(() => this.delete.unique(id), 'delete.unique');
+            const dbItem = await this.query.unique(id);
+            if (!dbItem)
+                return;
+            addDeletedToTransaction({ dbKey: this.dbDef.entityName, ids: [dbItem._id] });
+            await this.hooks?.canDeleteItems([dbItem]);
+            markTransactionWrite();
+            await this.mongoCollection.deleteOne({ _id: idStr }, this.sessionOpts());
+            await this.hooks?.postWriteProcessing?.({ deleted: dbItem }, 'delete');
+            return dbItem;
+        },
+        item: async (item) => {
+            item._id = this.assertUniqueId(item);
+            return this.delete.unique(item._id);
+        },
+        all: async (ids) => {
+            const idStrs = ids.map(id => typeof id !== 'string' ? this.assertUniqueId(id) : id);
+            if (!this.getSession())
+                return this.runTransactionInChunks(idStrs, (chunk) => this._deleteAll(chunk));
+            return this._deleteAll(idStrs);
+        },
+        allItems: async (items) => {
+            const ids = items.map(item => {
+                item._id = this.assertUniqueId(item);
+                return item._id;
+            });
+            if (!this.getSession())
+                return this.runTransactionInChunks(ids, (chunk) => this._deleteAll(chunk));
+            return this._deleteAll(ids);
+        },
+        query: async (query) => {
+            if (!exists(query) || compare(query, _EmptyQuery))
+                throw new MUSTNeverHappenException('An empty query was passed to delete.query!');
+            const items = await this.query.custom(query);
+            const ids = filterInstances(items.map(dbObjectToId));
+            if (!this.getSession()) {
+                await this.runTransactionInChunks(ids, (chunk) => this._deleteAll(chunk));
+                return items;
+            }
+            return this._deleteAll(ids);
+        },
+        allDocs: async (_docs) => {
+            const ids = _docs.map((d) => d._id || d.ref?.id).filter(Boolean);
+            if (!this.getSession())
+                return this.runTransactionInChunks(ids, (chunk) => this._deleteAll(chunk));
+            return this._deleteAll(ids);
+        },
+        where: async (where) => {
+            return this.delete.query({ where });
+        },
+        unManipulatedQuery: async (query) => {
+            if (!exists(query) || compare(query, _EmptyQuery))
+                throw new MUSTNeverHappenException('An empty query was passed to delete.unManipulatedQuery!');
+            const items = await this._customQuery(query, false);
+            const ids = filterInstances(items.map(dbObjectToId));
+            if (!this.getSession()) {
+                await this.runTransactionInChunks(ids, (chunk) => this._deleteAll(chunk));
+                return items;
+            }
+            return this._deleteAll(ids);
+        },
+        multi: {
+            all: async (ids) => this._deleteAll(ids),
+            items: async (items) => {
+                const _ids = items.map(item => {
+                    item._id = this.assertUniqueId(item);
+                    return item._id;
+                });
+                return this._deleteAll(_ids);
+            },
+            allDocs: async (_docs) => {
+                const ids = _docs.map((d) => d._id || d.ref?.id).filter(Boolean);
+                return this._deleteAll(ids);
+            },
+            query: async (query) => {
+                const items = await this.query.custom(query);
+                const ids = filterInstances(items.map(dbObjectToId));
+                return this._deleteAll(ids);
+            }
+        },
+        yes: { iam: { sure: { iwant: { todelete: { the: { collection: {
+                                    delete: async () => {
+                                        markTransactionWrite();
+                                        await this.mongoCollection.deleteMany({}, this.sessionOpts());
+                                        await this.hooks?.postWriteProcessing?.({ deleted: null }, 'delete');
+                                    }
+                                } } } } } } }
+    });
+    runTransaction = async (processor, label) => {
+        const existingSession = this.getSession();
+        if (existingSession)
+            return processor();
+        const tag = label ? `${this.dbDef.dbKey}:${label}` : this.dbDef.dbKey;
+        const client = this.db.client;
+        const session = client.startSession();
+        this.logDebug(`TX-START [${tag}]`);
+        try {
+            let result;
+            const wrapper = {
+                transaction: session,
+                active: true,
+                writeCount: 0,
+                beginTransaction: () => session.startTransaction(),
+            };
+            const parentStorage = MemStorage.getStore();
+            try {
+                await new MemStorage().init(async () => {
+                    MemKey_FirestoreTransaction.set(wrapper);
+                    result = await processor();
+                }, parentStorage);
+            }
+            catch (e) {
+                wrapper.active = false;
+                if (wrapper.writeCount > 0)
+                    await session.abortTransaction();
+                throw e;
+            }
+            wrapper.active = false;
+            if (wrapper.writeCount > 0)
+                await session.commitTransaction();
+            this.logDebug(`TX-END [${tag}] writes=${wrapper.writeCount}`);
+            return result;
+        }
+        finally {
+            await session.endSession();
+        }
+    };
+    runTransactionInChunks = async (items, processor, chunkSize = maxBatch) => {
+        return batchActionParallel(items, chunkSize, (chunk) => this.runTransaction(() => processor(chunk), `chunk(${chunk.length})`));
+    };
+    getVersion = () => {
+        return this.dbDef.versions?.[0] || DefaultDBVersion;
+    };
+    needsUpgrade = (version) => {
+        const versions = this.dbDef.versions || [DefaultDBVersion];
+        if (!version)
+            return false;
+        const index = versions.indexOf(version);
+        if (index === -1)
+            throw HttpCodes._4XX.BAD_REQUEST('Invalid Object Version', `Provided item with version(${version}) which doesn't exist for collection '${this.dbDef.dbKey} (${__stringify(this.dbDef.versions)})' `);
+        return index !== 0;
+    };
+    validateItem(dbItem) {
+        const results = tsValidateResult(dbItem, this.validator);
+        if (results)
+            this.onValidationError(dbItem, results);
+    }
+    onValidationError(instance, results) {
+        StaticLogger.logError(`error validating ${this.dbDef.entityName}:`, instance, 'With Error: ', results);
+        const validationException = new ValidationException(`error validating ${this.dbDef.entityName}`, instance, results);
+        throw new ApiException(HttpCodes._4XX.FAILED_VALIDATION.code, `error validating ${this.dbDef.entityName}`).setErrorBody(validationException);
+    }
+    assertNoDuplicatedIds(items, originFunctionName) {
+        if (filterDuplicates(items, dbObjectToId).length === items.length)
+            return;
+        const idCountMap = items.reduce((countMap, item) => {
+            countMap[item._id] = !exists(countMap[item._id]) ? 1 : 1 + countMap[item._id];
+            return countMap;
+        }, {});
+        _keys(idCountMap).forEach(key => {
+            if (idCountMap[key] === 1)
+                delete idCountMap[key];
+        });
+        throw new BadImplementationException(`${originFunctionName} received the same _id twice: ${__stringify(idCountMap, true)}`);
+    }
+    composeDbObjectUniqueId = (item) => {
+        return composeDbObjectUniqueId(item, this.uniqueKeys);
+    };
+}

package/firestore/MongoInterface.d.ts

@@ -0,0 +1,18 @@
+import { FirestoreQuery } from '@nu-art/firebase-shared';
+import { TS_Object } from '@nu-art/ts-common';
+import type { Document, Filter, Sort } from 'mongodb';
+export type MqlCompiledQuery<T extends TS_Object = TS_Object> = {
+    filter: Filter<T>;
+    sort?: Sort;
+    projection?: Document;
+    skip?: number;
+    limit?: number;
+};
+export declare class MongoInterface {
+    static buildQuery<T extends TS_Object>(query?: FirestoreQuery<T>): MqlCompiledQuery<T>;
+    private static buildFilter;
+    private static isQueryComparator;
+    private static buildProjection;
+    private static buildSort;
+    private static buildPagination;
+}