@nu-art/firebase-backend 0.401.9 → 0.500.6

package/firestore/MongoInterface.js

@@ -0,0 +1,132 @@
+/*
+ * 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 { __stringify, BadImplementationException, ImplementationMissingException, StaticLogger } from '@nu-art/ts-common';
+const MqlComparatorMap = {
+    $nin: '$nin',
+    $in: '$in',
+    $ac: '$elemMatch',
+    $aca: '$in',
+    $gt: '$gt',
+    $gte: '$gte',
+    $lt: '$lt',
+    $lte: '$lte',
+    $eq: '$eq',
+    $neq: '$ne',
+};
+export class MongoInterface {
+    static buildQuery(query) {
+        try {
+            const result = { filter: {} };
+            if (query?.where)
+                result.filter = this.buildFilter(query.where);
+            if (query?.select)
+                result.projection = this.buildProjection(query.select);
+            if (query?.orderBy)
+                result.sort = this.buildSort(query.orderBy);
+            if (query?.limit !== undefined)
+                Object.assign(result, this.buildPagination(query.limit));
+            return result;
+        }
+        catch (e) {
+            StaticLogger.logError(`Query: ${JSON.stringify(query)}`);
+            StaticLogger.logError(`Error: ${e}`);
+            throw e;
+        }
+    }
+    static buildFilter(where, prefix) {
+        const filter = {};
+        for (const field of Object.keys(where)) {
+            const value = where[field];
+            if (value === undefined || value === null)
+                continue;
+            const key = prefix ? `${prefix}.${field}` : field;
+            if (Array.isArray(value)) {
+                if (value.length === 0)
+                    throw new BadImplementationException(`Empty array in where clause for field '${key}'`);
+                if (value.length === 1)
+                    filter[key] = value[0];
+                else
+                    filter[key] = { $in: value };
+                continue;
+            }
+            if (this.isQueryComparator(value)) {
+                const comparatorKey = Object.keys(value)[0];
+                const mqlOp = MqlComparatorMap[comparatorKey];
+                if (!mqlOp)
+                    throw new ImplementationMissingException(`No MQL comparator for: ${comparatorKey} in filter: ${__stringify(where)}`);
+                const operand = value[comparatorKey];
+                if (operand === undefined)
+                    throw new ImplementationMissingException(`No value for comparator ${comparatorKey} in filter: ${__stringify(where)}`);
+                if (comparatorKey === '$ac') {
+                    filter[key] = operand;
+                }
+                else {
+                    filter[key] = { [mqlOp]: operand };
+                }
+                continue;
+            }
+            const valueType = typeof value;
+            if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+                filter[key] = value;
+                continue;
+            }
+            if (valueType === 'object') {
+                Object.assign(filter, this.buildFilter(value, key));
+                continue;
+            }
+            throw new ImplementationMissingException(`Cannot compile where clause for '${key}' with value type '${valueType}' in filter: ${__stringify(where)}`);
+        }
+        return filter;
+    }
+    static isQueryComparator(value) {
+        if (typeof value !== 'object' || Array.isArray(value))
+            return false;
+        const keys = Object.keys(value);
+        return keys.length === 1 && (value['$ac'] !== undefined ||
+            value['$aca'] !== undefined ||
+            value['$in'] !== undefined ||
+            value['$nin'] !== undefined ||
+            value['$gt'] !== undefined ||
+            value['$gte'] !== undefined ||
+            value['$lt'] !== undefined ||
+            value['$lte'] !== undefined ||
+            value['$neq'] !== undefined ||
+            value['$eq'] !== undefined);
+    }
+    static buildProjection(select) {
+        const projection = {};
+        for (const field of select)
+            projection[field] = 1;
+        return projection;
+    }
+    static buildSort(orderBy) {
+        const sort = {};
+        for (const entry of orderBy)
+            sort[entry.key] = entry.order === 'asc' ? 1 : -1;
+        return sort;
+    }
+    static buildPagination(limit) {
+        if (typeof limit === 'number')
+            return { limit };
+        const page = limit.page || 0;
+        const result = { limit: limit.itemsCount };
+        if (page > 0)
+            result.skip = limit.itemsCount * page;
+        return result;
+    }
+}

package/firestore/MongoWrapperBE.d.ts

@@ -0,0 +1,18 @@
+import { Database, DB_Prototype } from '@nu-art/db-api-shared';
+import { Logger } from '@nu-art/ts-common';
+import { MongoCollection } from './MongoCollection.js';
+import { FirestoreCollectionHooks } from './FirestoreCollection.js';
+import type { Db as MongoDriverDb, MongoClient } from 'mongodb';
+export declare const CONST_MONGODB_EMULATOR_HOST = "MONGODB_EMULATOR_HOST";
+export declare class MongoWrapperBE extends Logger {
+    private static instances;
+    static isEmulator(): boolean;
+    static getOrCreate(client: MongoClient, dbName: string): MongoWrapperBE;
+    readonly client: MongoClient;
+    readonly db: MongoDriverDb;
+    private readonly collections;
+    constructor(client: MongoClient, dbName: string);
+    runTransaction: <ReturnType>(processor: () => Promise<ReturnType>, label?: string) => Promise<ReturnType>;
+    getCollection<Proto extends DB_Prototype>(dbDef: Database<Proto>, hooks?: FirestoreCollectionHooks<Proto['dbType']>): MongoCollection<Proto>;
+    listCollections(): Promise<string[]>;
+}

package/firestore/MongoWrapperBE.js

@@ -0,0 +1,95 @@
+/*
+ * 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 { Logger, Promise_all_sequentially } from '@nu-art/ts-common';
+import { MongoCollection } from './MongoCollection.js';
+import { getActiveTransaction, MemKey_FirestoreTransaction } from './consts.js';
+import { MemStorage } from '@nu-art/ts-common/mem-storage';
+export const CONST_MONGODB_EMULATOR_HOST = 'MONGODB_EMULATOR_HOST';
+export class MongoWrapperBE extends Logger {
+    static instances = {};
+    static isEmulator() {
+        return !!process.env[CONST_MONGODB_EMULATOR_HOST];
+    }
+    static getOrCreate(client, dbName) {
+        const key = dbName;
+        if (this.instances[key])
+            return this.instances[key];
+        return this.instances[key] = new MongoWrapperBE(client, dbName);
+    }
+    client;
+    db;
+    collections = {};
+    constructor(client, dbName) {
+        super();
+        this.client = client;
+        this.db = client.db(dbName);
+    }
+    runTransaction = async (processor, label) => {
+        if (getActiveTransaction())
+            return processor();
+        const tag = label ?? 'MongoWrapper';
+        const postTransactionActions = [];
+        const session = this.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);
+                    // @ts-ignore
+                    session.postTransaction = (action) => {
+                        postTransactionActions.push(action);
+                    };
+                    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}`);
+            await Promise_all_sequentially(postTransactionActions);
+            return result;
+        }
+        finally {
+            await session.endSession();
+        }
+    };
+    getCollection(dbDef, hooks) {
+        const existing = this.collections[dbDef.dbKey];
+        if (existing)
+            return existing;
+        return this.collections[dbDef.dbKey] = new MongoCollection(this.db, dbDef, hooks);
+    }
+    async listCollections() {
+        const collections = await this.db.listCollections().toArray();
+        return collections.map(c => c.name);
+    }
+}

package/firestore/consts.d.ts

@@ -0,0 +1,23 @@
+import { Dispatcher, UniqueId } from '@nu-art/ts-common';
+import { CanDeleteDBEntitiesProto } from './types.js';
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { PotentialDependenciesToDelete } from '@nu-art/firebase-shared';
+import { Transaction } from 'firebase-admin/firestore';
+export declare const canDeleteDispatcher: Dispatcher<CanDeleteDBEntitiesProto, "__canDeleteEntitiesProto", [type: any, itemIds: string[]], import("@nu-art/firebase-shared").DB_EntityDependencyV2>;
+export type TransactionWrapper = {
+    transaction: Transaction;
+    active: boolean;
+    writeCount?: number;
+    beginTransaction?: () => void;
+};
+export declare const MemKey_FirestoreTransaction: MemKey<TransactionWrapper>;
+export declare function getActiveTransaction(): Transaction | undefined;
+export declare function markTransactionWrite(): void;
+export type MemKey_DeletedDocs_Type = {
+    transaction: Transaction;
+    deleted: {
+        [dbKey: string]: Set<UniqueId>;
+    };
+};
+export declare const MemKey_DeletedDocs: MemKey<MemKey_DeletedDocs_Type[]>;
+export declare function addDeletedToTransaction(deleted: PotentialDependenciesToDelete): void;

package/firestore/consts.js

@@ -0,0 +1,34 @@
+import { Dispatcher } from '@nu-art/ts-common';
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+export const canDeleteDispatcher = new Dispatcher('__canDeleteEntitiesProto');
+export const MemKey_FirestoreTransaction = new MemKey('firestore--transaction');
+export function getActiveTransaction() {
+    const wrapper = MemKey_FirestoreTransaction.peak();
+    if (!wrapper?.active)
+        return undefined;
+    return wrapper.transaction;
+}
+export function markTransactionWrite() {
+    const wrapper = MemKey_FirestoreTransaction.peak();
+    if (!wrapper?.active)
+        return;
+    if (wrapper.writeCount === 0)
+        wrapper.beginTransaction?.();
+    wrapper.writeCount = (wrapper.writeCount ?? 0) + 1;
+}
+export const MemKey_DeletedDocs = new MemKey('deleted--docs');
+export function addDeletedToTransaction(deleted) {
+    const transaction = getActiveTransaction();
+    if (!transaction)
+        return;
+    const storage = MemKey_DeletedDocs.get([]);
+    let item = storage.find(i => i.transaction === transaction);
+    if (!item) {
+        item = { transaction, deleted: {} };
+        storage.push(item);
+    }
+    if (!item.deleted[deleted.dbKey])
+        item.deleted[deleted.dbKey] = new Set();
+    deleted.ids.forEach(id => item.deleted[deleted.dbKey].add(id));
+    MemKey_DeletedDocs.set(storage);
+}

package/firestore/types.d.ts

@@ -1,6 +1,11 @@
-import { CollectionReference, QueryDocumentSnapshot, Query, DocumentReference, Firestore, DocumentData } from 'firebase-admin/firestore';
+import { DB_Prototype } from '@nu-art/db-api-shared';
+import { DB_EntityDependencyV2 } from '@nu-art/firebase-shared';
+import { CollectionReference, DocumentData, DocumentReference, Firestore, Query, QueryDocumentSnapshot } from 'firebase-admin/firestore';
 export type FirestoreType_Collection = CollectionReference;
 export type FirestoreType_DocumentSnapshot<T = DocumentData> = QueryDocumentSnapshot<T>;
 export type FirestoreType_Query = Query;
 export type FirestoreType_DocumentReference<T> = DocumentReference<T>;
 export type FirestoreType = Firestore;
+export type CanDeleteDBEntitiesProto = {
+    __canDeleteEntitiesProto: <T extends DB_Prototype>(type: T['dbKey'], itemIds: string[]) => Promise<DB_EntityDependencyV2>;
+};

package/firestore/types.js

@@ -1,25 +1 @@
-/*
- * 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.
- */
 export {};
-// export type FirestoreType_Collection = admin.CollectionReference | firebase.firestore.CollectionReference;
-// export type FirestoreType_DocumentSnapshot = admin.firestore.QueryDocumentSnapshot | firebase.firestore.QueryDocumentSnapshot;
-// export type FirestoreType_Query = (admin.firestore.Query | firebase.firestore.Query) & { select?: (...field: string[]) => FirestoreType_Query };
-// export type FirestoreType_DocumentReference = admin.firestore.DocumentReference | firebase.firestore.DocumentReference;
-// export type FirestoreType = (admin.firestore.Firestore | firebase.firestore.Firestore) & ({ listCollections?: () => Promise<FirestoreType_Collection[]> });
-// export type FirestoreType_Transaction = admin.firestore.Transaction | firebase.firestore.Transaction;
-//

package/{functions-v2 → functions}/ModuleBE_BaseFunction.d.ts

@@ -1,6 +1,9 @@
-import { Module } from '@nu-art/ts-common';
-import { FirebaseFunctionInterface } from '../functions/firebase-function.js';
-export declare abstract class ModuleBE_BaseFunction<Config = any> extends Module<Config> implements FirebaseFunctionInterface {
+import { Module, TS_Object } from '@nu-art/ts-common';
+export interface FirebaseFunctionInterface {
+    getFunction(): any;
+    onFunctionReady(): Promise<void>;
+}
+export declare abstract class ModuleBE_BaseFunction<Config extends TS_Object = any> extends Module<Config> implements FirebaseFunctionInterface {
     protected isReady: boolean;
     protected toBeExecuted: (() => Promise<any>)[];
     protected toBeResolved: (value?: (PromiseLike<any>)) => void;

package/{functions-v2 → functions}/ModuleBE_BaseFunction.js

@@ -5,6 +5,7 @@ export class ModuleBE_BaseFunction extends Module {
     toBeResolved;
     constructor(tag) {
         super(tag);
+        this.addToClassStack(ModuleBE_BaseFunction);
         this.onFunctionReady = this.onFunctionReady.bind(this);
     }
     async handleCallback(callback) {

package/{functions-v2/ModuleBE_ExpressFunction_V2.d.ts → functions/ModuleBE_ExpressFunction_Class.d.ts}

@@ -1,11 +1,13 @@
 import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
 import { Express } from 'express';
 import { HttpsFunction, HttpsOptions } from 'firebase-functions/v2/https';
-export declare class ModuleBE_ExpressFunction_V2<Config = {}> extends ModuleBE_BaseFunction<{
+export type ExpressResolver = () => Express;
+export declare class ModuleBE_ExpressFunction_Class extends ModuleBE_BaseFunction<{
     options: HttpsOptions;
-} & Config> {
+}> {
     private function;
-    protected constructor(name?: string);
+    private readonly expressResolver;
+    constructor(name?: string, expressResolver?: ExpressResolver);
     getFunction: () => HttpsFunction;
     protected createFunction(_express: Express): HttpsFunction;
 }

package/{functions-v2/ModuleBE_ExpressFunction_V2.js → functions/ModuleBE_ExpressFunction_Class.js}

@@ -2,15 +2,19 @@ import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
 import { addItemToArray } from '@nu-art/ts-common';
 import express from 'express';
 import { onRequest } from 'firebase-functions/v2/https';
-export class ModuleBE_ExpressFunction_V2 extends ModuleBE_BaseFunction {
+export class ModuleBE_ExpressFunction_Class extends ModuleBE_BaseFunction {
     function;
-    constructor(name = 'api') {
+    expressResolver;
+    constructor(name = 'api', expressResolver) {
         super(name);
+        this.setName(name);
+        this.expressResolver = expressResolver ?? (() => express());
+        this.addToClassStack(ModuleBE_ExpressFunction_Class);
     }
     getFunction = () => {
         if (this.function)
             return this.function;
-        const _express = express();
+        const _express = this.expressResolver();
         const realFunction = this.createFunction(_express);
         return this.function = onRequest(this.config.options, (req, res) => {
             if (this.isReady) { // @ts-ignore

package/{functions-v2 → functions}/ModuleBE_FirebaseDBListener.d.ts

@@ -1,5 +1,6 @@
+import { TS_Object } from '@nu-art/ts-common';
 import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
-export declare abstract class ModuleBE_FirebaseDBListener<DataType = any, ConfigType = any> extends ModuleBE_BaseFunction<ConfigType> {
+export declare abstract class ModuleBE_FirebaseDBListener<DataType = any, ConfigType extends TS_Object = any> extends ModuleBE_BaseFunction<ConfigType> {
     private readonly listeningPath;
     private function;
     protected constructor(listeningPath: string, name?: string);

package/{functions-v2 → functions}/ModuleBE_FirebaseDBListener.js

@@ -8,6 +8,7 @@ export class ModuleBE_FirebaseDBListener extends ModuleBE_BaseFunction {
         super();
         if (name)
             this.setName(name);
+        this.addToClassStack(ModuleBE_FirebaseDBListener);
         this.listeningPath = listeningPath;
     }
     getFunction = () => {

package/{functions-v2 → functions}/ModuleBE_FirebaseScheduler.js

@@ -18,6 +18,7 @@ export class ModuleBE_FirebaseScheduler extends ModuleBE_BaseFunction {
     constructor(name, tag) {
         super(tag);
         name && this.setName(name);
+        this.addToClassStack(ModuleBE_FirebaseScheduler);
     }
     /**
      * Add a running condition to the list of conditions that must pass in order for the backup to execute

package/{functions-v2 → functions}/ModuleBE_FirestoreListener.d.ts

@@ -1,6 +1,10 @@
 import { TS_Object } from '@nu-art/ts-common';
-import { FirestoreConfigs } from '../functions/firebase-function.js';
 import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { HttpsOptions } from 'firebase-functions/v2/https';
+export type FirestoreConfigs = {
+    runTimeOptions?: HttpsOptions;
+    configs: any;
+};
 import { DocumentOptions, DocumentSnapshot, FirestoreEvent } from 'firebase-functions/v2/firestore';
 import { Change, CloudFunction } from 'firebase-functions/v2';
 export declare abstract class ModuleBE_FirestoreListener<DataType extends TS_Object, ConfigType extends FirestoreConfigs = FirestoreConfigs> extends ModuleBE_BaseFunction<ConfigType & DocumentOptions> {

package/{functions-v2 → functions}/ModuleBE_FirestoreListener.js

@@ -6,6 +6,7 @@ export class ModuleBE_FirestoreListener extends ModuleBE_BaseFunction {
     constructor(collectionName, name, tag) {
         super(tag);
         name && this.setName(name);
+        this.addToClassStack(ModuleBE_FirestoreListener);
         this.setDefaultConfig({ document: `${collectionName}/{docId}` });
     }
     getFunction = () => {

package/{functions-v2 → functions}/ModuleBE_PubSubFunction.d.ts

@@ -1,6 +1,9 @@
-import { TS_Object } from '@nu-art/ts-common';
+import { StringMap, TS_Object } from '@nu-art/ts-common';
 import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
-import { TopicMessage } from '../functions/firebase-function.js';
+export type TopicMessage = {
+    data: string;
+    attributes: StringMap;
+};
 import { CloudEvent, CloudFunction } from 'firebase-functions/v2';
 import { MessagePublishedData } from 'firebase-functions/v2/pubsub';
 export declare abstract class ModuleBE_PubSubFunction<T extends TS_Object> extends ModuleBE_BaseFunction {

package/{functions-v2 → functions}/ModuleBE_PubSubFunction.js

@@ -7,6 +7,7 @@ export class ModuleBE_PubSubFunction extends ModuleBE_BaseFunction {
     constructor(topic, tag) {
         super(tag);
         this.topic = topic;
+        this.addToClassStack(ModuleBE_PubSubFunction);
     }
     _onPublish = async (object, originalMessage, event) => {
         try {

package/{functions-v2 → functions}/ModuleBE_StorageListener.js

@@ -7,6 +7,7 @@ export class ModuleBE_StorageListener extends ModuleBE_BaseFunction {
         super();
         if (path)
             this.setDefaultConfig({ path: path, timeoutSeconds: 300, memory: '2GB' });
+        this.addToClassStack(ModuleBE_StorageListener);
         name && this.setName(name);
     }
     getFunction = () => {

package/index.d.ts

@@ -2,20 +2,23 @@ export * from './auth/firebase-session.js';
 export * from './auth/FirebaseSession_Admin.js';
 export * from './database/DatabaseWrapperBE.js';
 export * from './storage/types.js';
-export * from './firestore-v3/consts.js';
-export * from './firestore-v3/DocWrapperV3.js';
-export * from './firestore-v3/FirestoreCollectionV3.js';
-export * from './firestore-v3/FirestoreInterfaceV3.js';
-export * from './firestore-v3/FirestoreWrapperBEV3.js';
-export * from './firestore-v3/types.js';
+export * from './firestore/consts.js';
+export * from './firestore/DocWrapper.js';
+export * from './firestore/FirestoreCollection.js';
+export * from './firestore/FirestoreInterface.js';
+export * from './firestore/FirestoreWrapperBE.js';
+export * from './firestore/MongoCollection.js';
+export * from './firestore/MongoInterface.js';
+export * from './firestore/MongoWrapperBE.js';
+export * from './firestore/types.js';
 export * from './push/PushMessagesWrapperBE.js';
 export * from './push/types.js';
 export * from './storage/StorageWrapperBE.js';
-export * from './functions-v2/ModuleBE_BaseFunction.js';
-export * from './functions-v2/ModuleBE_ExpressFunction_V2.js';
-export * from './functions-v2/ModuleBE_FirebaseDBListener.js';
-export * from './functions-v2/ModuleBE_FirebaseScheduler.js';
-export * from './functions-v2/ModuleBE_FirestoreListener.js';
-export * from './functions-v2/ModuleBE_PubSubFunction.js';
-export * from './functions-v2/ModuleBE_StorageListener.js';
+export * from './functions/ModuleBE_BaseFunction.js';
+export * from './functions/ModuleBE_ExpressFunction_Class.js';
+export * from './functions/ModuleBE_FirebaseDBListener.js';
+export * from './functions/ModuleBE_FirebaseScheduler.js';
+export * from './functions/ModuleBE_FirestoreListener.js';
+export * from './functions/ModuleBE_PubSubFunction.js';
+export * from './functions/ModuleBE_StorageListener.js';
 export * from './ModuleBE_Firebase.js';

package/index.js

@@ -19,20 +19,23 @@ export * from './auth/firebase-session.js';
 export * from './auth/FirebaseSession_Admin.js';
 export * from './database/DatabaseWrapperBE.js';
 export * from './storage/types.js';
-export * from './firestore-v3/consts.js';
-export * from './firestore-v3/DocWrapperV3.js';
-export * from './firestore-v3/FirestoreCollectionV3.js';
-export * from './firestore-v3/FirestoreInterfaceV3.js';
-export * from './firestore-v3/FirestoreWrapperBEV3.js';
-export * from './firestore-v3/types.js';
+export * from './firestore/consts.js';
+export * from './firestore/DocWrapper.js';
+export * from './firestore/FirestoreCollection.js';
+export * from './firestore/FirestoreInterface.js';
+export * from './firestore/FirestoreWrapperBE.js';
+export * from './firestore/MongoCollection.js';
+export * from './firestore/MongoInterface.js';
+export * from './firestore/MongoWrapperBE.js';
+export * from './firestore/types.js';
 export * from './push/PushMessagesWrapperBE.js';
 export * from './push/types.js';
 export * from './storage/StorageWrapperBE.js';
-export * from './functions-v2/ModuleBE_BaseFunction.js';
-export * from './functions-v2/ModuleBE_ExpressFunction_V2.js';
-export * from './functions-v2/ModuleBE_FirebaseDBListener.js';
-export * from './functions-v2/ModuleBE_FirebaseScheduler.js';
-export * from './functions-v2/ModuleBE_FirestoreListener.js';
-export * from './functions-v2/ModuleBE_PubSubFunction.js';
-export * from './functions-v2/ModuleBE_StorageListener.js';
+export * from './functions/ModuleBE_BaseFunction.js';
+export * from './functions/ModuleBE_ExpressFunction_Class.js';
+export * from './functions/ModuleBE_FirebaseDBListener.js';
+export * from './functions/ModuleBE_FirebaseScheduler.js';
+export * from './functions/ModuleBE_FirestoreListener.js';
+export * from './functions/ModuleBE_PubSubFunction.js';
+export * from './functions/ModuleBE_StorageListener.js';
 export * from './ModuleBE_Firebase.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/firebase-backend",
-  "version": "0.401.9",
+  "version": "0.500.6",
   "description": "Storm - Express & Typescript based backend framework Backend",
   "keywords": [
     "TacB0sS",
@@ -30,28 +30,31 @@
   "scripts": {
     "build": "tsc",
     "run-tests": "firebase emulators:exec \"npm run test\"",
-    "test": "ts-mocha -w -p src/test/tsconfig.json --timeout 0 --inspect=8107 --watch-files '**/*.ts' src/test/firestore-v2/__test.ts",
+    "test": "ts-mocha -p src/test/tsconfig.json --timeout 0 'src/test/**/*.test.firebase.ts'",
+    "test:watch": "ts-mocha -w -p src/test/tsconfig.json --timeout 0 --inspect=8107 --watch-files '**/*.ts' 'src/test/**/*.test.firebase.ts'",
     "rtv2": "firebase emulators:exec \"npm run test-v2\"",
-    "test-v2": "ts-mocha -w -p src/test/tsconfig.json --timeout 0 --inspect=8107 --watch-files '**/*.ts' src/test/firestore-v2/__test.ts"
+    "test-v2": "ts-mocha -p src/test/tsconfig.json --timeout 0 'src/test/**/*.test.firebase.ts'"
   },
   "dependencies": {
-    "@nu-art/firebase-shared": "0.401.9",
+    "@nu-art/db-api-shared": "0.500.6",
+    "@nu-art/firebase-shared": "0.500.6",
     "@google-cloud/common": "^5.0.2",
     "@google-cloud/firestore": "^7.11.0",
     "@google-cloud/storage": "^7.15.0",
-    "@nu-art/google-services-backend": "0.401.9",
-    "@nu-art/ts-common": "0.401.9",
+    "@nu-art/google-services-backend": "0.500.6",
+    "@nu-art/ts-common": "0.500.6",
     "express": "^4.18.2",
     "firebase": "^11.9.0",
     "firebase-admin": "13.4.0",
     "firebase-functions": "6.3.2",
     "google-auth-library": "^10.0.0",
+    "mongodb": "^7.1.1",
     "http-proxy": "1.18.1",
     "url": "0.11.3",
     "ws": "^8.13.0"
   },
   "devDependencies": {
-    "@nu-art/testalot": "0.401.9",
+    "@nu-art/testalot": "0.500.6",
     "@types/compression": "^1.0.1",
     "@types/chai": "^4.3.4",
     "@types/mocha": "^10.0.1",