@nu-art/firebase-backend 0.400.5

package/firestore-v3/FirestoreWrapperBEV3.js

@@ -0,0 +1,154 @@
+/*
+ * 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 { FirestoreCollectionV3, } from './FirestoreCollectionV3.js';
+import { FirebaseBaseWrapper } from '../auth/FirebaseBaseWrapper.js';
+import { Promise_all_sequentially } from '@nu-art/ts-common';
+import { DocumentReference, DocumentSnapshot, getFirestore, QuerySnapshot, } from 'firebase-admin/firestore';
+export class FirestoreWrapperBEV3 extends FirebaseBaseWrapper {
+    firestore;
+    collections = {};
+    constructor(firebaseSession, dbName) {
+        super(firebaseSession);
+        if (dbName)
+            this.firestore = getFirestore(firebaseSession.app, dbName);
+        else
+            this.firestore = getFirestore(firebaseSession.app);
+    }
+    runTransaction = async (processor, transaction) => {
+        if (transaction) // if a transaction was provided to be used, use it
+            return processor(transaction);
+        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: {}, // Mock DocumentReference
+                    exists,
+                    data: () => (exists ? data : undefined),
+                    get: (fieldPath) => data[fieldPath],
+                    metadata: {}, // Mock 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) => {
+                // update deletions
+                updateTransactionUpdates(documentRef, false);
+                writeActions.push(() => originDelete(documentRef, precondition));
+                return transaction;
+            };
+            // @ts-ignore
+            transaction.get = async (args) => {
+                // @ts-ignore
+                const doc = await originGet(args);
+                // handle doc snapshot
+                if (doc instanceof DocumentSnapshot) {
+                    const document = doc.data();
+                    if (!document)
+                        return doc;
+                    return transactionUpdates[document._id] ?? doc;
+                }
+                // handle query snapshot
+                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 toRet = await processor(transaction);
+            writeActions.forEach(action => action());
+            return toRet;
+        });
+        await Promise_all_sequentially(postTransactionActions);
+        return toRet;
+    };
+    getCollection(dbDef, hooks) {
+        const collection = this.collections[dbDef.dbKey];
+        if (collection)
+            return collection;
+        return this.collections[dbDef.dbKey] = new FirestoreCollectionV3(this, dbDef, hooks);
+    }
+    listen(collection, doc) {
+        collection.wrapper.firestore.doc(`${collection.collection.path}/${doc}`).onSnapshot(() => {
+            this.logInfo('received snapshot!');
+        });
+    }
+    // public async deleteCollection(name: string) {
+    // 	return this.getCollection(name).deleteAll();
+    // }
+    async listCollections() {
+        if (!this.firestore.listCollections)
+            return [];
+        return this.firestore.listCollections();
+    }
+    isEmulator() {
+        return !!process.env.FIRESTORE_EMULATOR_HOST || false;
+    }
+}

package/firestore-v3/consts.d.ts

@@ -0,0 +1,13 @@
+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';
+export declare const canDeleteDispatcherV3: Dispatcher<CanDeleteDBEntitiesProto, "__canDeleteEntitiesProto", [type: any, itemIds: string[], transaction?: FirebaseFirestore.Transaction | undefined], import("@nu-art/firebase-shared").DB_EntityDependencyV2>;
+export type MemKey_DeletedDocs_Type = {
+    transaction: FirebaseFirestore.Transaction;
+    deleted: {
+        [dbKey: string]: Set<UniqueId>;
+    };
+};
+export declare const MemKey_DeletedDocs: MemKey<MemKey_DeletedDocs_Type[]>;
+export declare function addDeletedToTransaction(transaction: FirebaseFirestore.Transaction | undefined, deleted: PotentialDependenciesToDelete): void;

package/firestore-v3/consts.js

@@ -0,0 +1,18 @@
+import { Dispatcher } from '@nu-art/ts-common';
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+export const canDeleteDispatcherV3 = new Dispatcher('__canDeleteEntitiesProto');
+export const MemKey_DeletedDocs = new MemKey('deleted--docs');
+export function addDeletedToTransaction(transaction, deleted) {
+    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-v3/types.d.ts

@@ -0,0 +1,6 @@
+import { DBProto } from '@nu-art/ts-common';
+import { DB_EntityDependencyV2 } from '@nu-art/firebase-shared';
+import { Transaction } from 'firebase-admin/firestore';
+export type CanDeleteDBEntitiesProto = {
+    __canDeleteEntitiesProto: <T extends DBProto<any>>(type: T['dbKey'], itemIds: string[], transaction?: Transaction) => Promise<DB_EntityDependencyV2>;
+};

package/firestore-v3/types.js

@@ -0,0 +1 @@
+export {};

package/functions/firebase-function.d.ts

@@ -0,0 +1,38 @@
+import { Express } from 'express';
+import { StringMap } from '@nu-art/ts-common';
+import { HttpsFunction, HttpsOptions } from 'firebase-functions/v2/https';
+export interface TBR_ExpressFunctionInterface {
+    getExpressFunction(): Firebase_ExpressFunction;
+}
+export interface FirebaseFunctionInterface {
+    getFunction(): HttpsFunction;
+    onFunctionReady(): Promise<void>;
+}
+export declare class Firebase_ExpressFunction implements FirebaseFunctionInterface {
+    private readonly express;
+    private function;
+    private toBeExecuted;
+    private isReady;
+    private toBeResolved;
+    private name;
+    static config: HttpsOptions;
+    constructor(_express: Express);
+    setName(name: string): this;
+    static setConfig(config: HttpsOptions): void;
+    getName(): string;
+    getFunction: () => HttpsFunction;
+    onFunctionReady: () => Promise<void>;
+}
+export type FirestoreConfigs = {
+    runTimeOptions?: HttpsOptions;
+    configs: any;
+};
+export type BucketConfigs = {
+    runtimeOpts?: HttpsOptions;
+    path: string;
+    bucketName?: string;
+};
+export type TopicMessage = {
+    data: string;
+    attributes: StringMap;
+};

package/functions/firebase-function.js

@@ -0,0 +1,53 @@
+import { addItemToArray } from '@nu-art/ts-common';
+import { onRequest } from 'firebase-functions/v2/https';
+export class Firebase_ExpressFunction {
+    express;
+    function;
+    toBeExecuted = [];
+    isReady = false;
+    toBeResolved;
+    name = 'api';
+    static config = {};
+    constructor(_express) {
+        this.express = _express;
+    }
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    static setConfig(config) {
+        this.config = config;
+    }
+    getName() {
+        return this.name;
+    }
+    getFunction = () => {
+        if (this.function)
+            return this.function;
+        const realFunction = onRequest(Firebase_ExpressFunction.config, this.express);
+        return this.function = onRequest(Firebase_ExpressFunction.config, (req, res) => {
+            if (this.isReady) {
+                return realFunction(req, res);
+            }
+            return new Promise((resolve) => {
+                // @ts-ignore
+                addItemToArray(this.toBeExecuted, () => realFunction(req, res));
+                this.toBeResolved = resolve;
+            });
+        });
+    };
+    onFunctionReady = async () => {
+        this.isReady = true;
+        const toBeExecuted = this.toBeExecuted;
+        this.toBeExecuted = [];
+        for (const toExecute of toBeExecuted) {
+            try {
+                await toExecute();
+            }
+            catch (e) {
+                console.error('Error running function: ', e);
+            }
+        }
+        this.toBeResolved && this.toBeResolved();
+    };
+}

package/functions-v2/ModuleBE_BaseFunction.d.ts

@@ -0,0 +1,11 @@
+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 {
+    protected isReady: boolean;
+    protected toBeExecuted: (() => Promise<any>)[];
+    protected toBeResolved: (value?: (PromiseLike<any>)) => void;
+    protected constructor(tag?: string);
+    abstract getFunction(): any;
+    protected handleCallback(callback: () => Promise<any>): Promise<any>;
+    onFunctionReady: () => Promise<void>;
+}

package/functions-v2/ModuleBE_BaseFunction.js

@@ -0,0 +1,32 @@
+import { addItemToArray, dispatch_onApplicationNotification, Module, ServerErrorSeverity } from '@nu-art/ts-common';
+export class ModuleBE_BaseFunction extends Module {
+    isReady = false;
+    toBeExecuted = [];
+    toBeResolved;
+    constructor(tag) {
+        super(tag);
+        this.onFunctionReady = this.onFunctionReady.bind(this);
+    }
+    async handleCallback(callback) {
+        if (this.isReady)
+            return await callback();
+        return new Promise((resolve) => {
+            addItemToArray(this.toBeExecuted, async () => await callback());
+            this.toBeResolved = resolve;
+        });
+    }
+    onFunctionReady = async () => {
+        this.isReady = true;
+        const toBeExecuted = this.toBeExecuted;
+        this.toBeExecuted = [];
+        for (const toExecute of toBeExecuted) {
+            try {
+                await toExecute();
+            }
+            catch (e) {
+                await dispatch_onApplicationNotification.dispatchModuleAsync(ServerErrorSeverity.Critical, this, e.message);
+            }
+        }
+        this.toBeResolved && this.toBeResolved();
+    };
+}

package/functions-v2/ModuleBE_ExpressFunction_V2.d.ts

@@ -0,0 +1,11 @@
+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<{
+    options: HttpsOptions;
+} & Config> {
+    private function;
+    protected constructor(name?: string);
+    getFunction: () => HttpsFunction;
+    protected createFunction(_express: Express): HttpsFunction;
+}

package/functions-v2/ModuleBE_ExpressFunction_V2.js

@@ -0,0 +1,29 @@
+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 {
+    function;
+    constructor(name = 'api') {
+        super(name);
+    }
+    getFunction = () => {
+        if (this.function)
+            return this.function;
+        const _express = express();
+        const realFunction = this.createFunction(_express);
+        return this.function = onRequest(this.config.options, (req, res) => {
+            if (this.isReady) { // @ts-ignore
+                return realFunction(req, res);
+            }
+            return new Promise((resolve) => {
+                // @ts-ignore
+                addItemToArray(this.toBeExecuted, () => realFunction(req, res));
+                this.toBeResolved = resolve;
+            });
+        });
+    };
+    createFunction(_express) {
+        return onRequest(this.config.options, _express);
+    }
+}

package/functions-v2/ModuleBE_FirebaseDBListener.d.ts

@@ -0,0 +1,10 @@
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+export declare abstract class ModuleBE_FirebaseDBListener<DataType = any, ConfigType = any> extends ModuleBE_BaseFunction<ConfigType> {
+    private readonly listeningPath;
+    private function;
+    protected constructor(listeningPath: string, name?: string);
+    abstract processChanges(before: DataType, after: DataType, params: {
+        [param: string]: any;
+    }): Promise<any>;
+    getFunction: () => import("firebase-functions").CloudFunction<import("firebase-functions/database").DatabaseEvent<import("firebase-functions").Change<import("firebase-functions/database").DataSnapshot>, Record<string, string>>>;
+}

package/functions-v2/ModuleBE_FirebaseDBListener.js

@@ -0,0 +1,24 @@
+import { deepClone } from '@nu-art/ts-common';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { onValueWritten } from 'firebase-functions/v2/database';
+export class ModuleBE_FirebaseDBListener extends ModuleBE_BaseFunction {
+    listeningPath;
+    function;
+    constructor(listeningPath, name) {
+        super();
+        if (name)
+            this.setName(name);
+        this.listeningPath = listeningPath;
+    }
+    getFunction = () => {
+        if (this.function)
+            return this.function;
+        const handler = (event) => {
+            const before = event.data.before && event.data.before.val();
+            const after = event.data.after && event.data.after.val();
+            const params = deepClone(event.params);
+            return this.handleCallback(() => this.processChanges(before, after, params));
+        };
+        return this.function = onValueWritten(this.listeningPath, handler);
+    };
+}

package/functions-v2/ModuleBE_FirebaseScheduler.d.ts

@@ -0,0 +1,32 @@
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { ScheduleFunction, ScheduleOptions } from 'firebase-functions/v2/scheduler';
+/**
+ An abstract class representing a scheduled Firebase Cloud Function.
+ It extends the FirebaseFunction class and adds scheduling capabilities.
+ */
+export declare abstract class ModuleBE_FirebaseScheduler<ConfigType = any> extends ModuleBE_BaseFunction<ConfigType & ScheduleOptions> {
+    private function;
+    private runningCondition;
+    /**
+     *
+     * @param name
+     * @param tag
+     * @protected
+     */
+    protected constructor(name?: string, tag?: string);
+    /**
+     * Add a running condition to the list of conditions that must pass in order for the backup to execute
+     */
+    addRunningCondition(runningCondition: () => Promise<boolean>): this;
+    /**
+     * Set the schedule for this scheduled event
+     */
+    setSchedule(schedule: string): this;
+    abstract onScheduledEvent(): Promise<any>;
+    /**
+     * Check all running conditions,
+     * return early if any fail
+     */
+    private _onScheduledEvent;
+    getFunction: () => ScheduleFunction;
+}

package/functions-v2/ModuleBE_FirebaseScheduler.js

@@ -0,0 +1,57 @@
+import { addItemToArray, ImplementationMissingException } from '@nu-art/ts-common';
+import { MemStorage } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { onSchedule } from 'firebase-functions/v2/scheduler';
+/**
+ An abstract class representing a scheduled Firebase Cloud Function.
+ It extends the FirebaseFunction class and adds scheduling capabilities.
+ */
+export class ModuleBE_FirebaseScheduler extends ModuleBE_BaseFunction {
+    function;
+    runningCondition = [async () => true];
+    /**
+     *
+     * @param name
+     * @param tag
+     * @protected
+     */
+    constructor(name, tag) {
+        super(tag);
+        name && this.setName(name);
+    }
+    /**
+     * Add a running condition to the list of conditions that must pass in order for the backup to execute
+     */
+    addRunningCondition(runningCondition) {
+        addItemToArray(this.runningCondition, runningCondition);
+        return this;
+    }
+    /**
+     * Set the schedule for this scheduled event
+     */
+    setSchedule(schedule) {
+        this.config.schedule = schedule;
+        return this;
+    }
+    /**
+     * Check all running conditions,
+     * return early if any fail
+     */
+    _onScheduledEvent = async () => {
+        const results = await Promise.all(this.runningCondition.map(condition => condition()));
+        if (results.includes(false)) {
+            this.logDebug('will not execute backup.. running conditions didn\'t pass: ', results);
+            return;
+        }
+        return this.onScheduledEvent();
+    };
+    getFunction = () => {
+        if (!this.config.schedule)
+            throw new ImplementationMissingException('MUST set schedule !!');
+        if (this.function)
+            return this.function;
+        return this.function = onSchedule(this.config, async () => {
+            return this.handleCallback(() => new MemStorage().init(this._onScheduledEvent));
+        });
+    };
+}

package/functions-v2/ModuleBE_FirestoreListener.d.ts

@@ -0,0 +1,13 @@
+import { TS_Object } from '@nu-art/ts-common';
+import { FirestoreConfigs } from '../functions/firebase-function.js';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+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> {
+    private function;
+    protected constructor(collectionName: string, name?: string, tag?: string);
+    abstract processChanges(params: {
+        [param: string]: any;
+    }, before?: DataType, after?: DataType): Promise<any>;
+    getFunction: () => CloudFunction<FirestoreEvent<Change<DocumentSnapshot> | undefined, Record<string, string>>> | undefined;
+}

package/functions-v2/ModuleBE_FirestoreListener.js

@@ -0,0 +1,21 @@
+import { deepClone } from '@nu-art/ts-common';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { onDocumentWritten } from 'firebase-functions/v2/firestore';
+export class ModuleBE_FirestoreListener extends ModuleBE_BaseFunction {
+    function;
+    constructor(collectionName, name, tag) {
+        super(tag);
+        name && this.setName(name);
+        this.setDefaultConfig({ document: `${collectionName}/{docId}` });
+    }
+    getFunction = () => {
+        if (this.function)
+            return this.function;
+        this.function = onDocumentWritten(this.config, event => {
+            const before = event.data?.before && event.data?.before.data();
+            const after = event.data?.after && event.data?.after.data();
+            const params = deepClone(event.params);
+            return this.handleCallback(() => this.processChanges(params, before, after));
+        });
+    };
+}

package/functions-v2/ModuleBE_PubSubFunction.d.ts

@@ -0,0 +1,13 @@
+import { TS_Object } from '@nu-art/ts-common';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { TopicMessage } from '../functions/firebase-function.js';
+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 {
+    private function;
+    private readonly topic;
+    protected constructor(topic: string, tag?: string);
+    abstract onPublish(object: T | undefined, originalMessage: TopicMessage, event: CloudEvent<MessagePublishedData>): Promise<any>;
+    private _onPublish;
+    getFunction: () => CloudFunction<CloudEvent<MessagePublishedData<any>>>;
+}

package/functions-v2/ModuleBE_PubSubFunction.js

@@ -0,0 +1,47 @@
+import { __stringify, dispatch_onApplicationNotification, ImplementationMissingException, ServerErrorSeverity } from '@nu-art/ts-common';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { onMessagePublished } from 'firebase-functions/v2/pubsub';
+export class ModuleBE_PubSubFunction extends ModuleBE_BaseFunction {
+    function;
+    topic;
+    constructor(topic, tag) {
+        super(tag);
+        this.topic = topic;
+    }
+    _onPublish = async (object, originalMessage, event) => {
+        try {
+            return await this.onPublish(object, originalMessage, event);
+        }
+        catch (e) {
+            const _message = `Error publishing pub/sub message` + __stringify(object) +
+                '\n' + ` to topic ${this.topic}` + '\n with attributes: ' + __stringify(originalMessage.attributes) + '\n' + __stringify(e);
+            this.logError(_message);
+            try {
+                await dispatch_onApplicationNotification.dispatchModuleAsync(ServerErrorSeverity.Critical, this, { message: _message });
+            }
+            catch (_e) {
+                this.logError('Error while handing pubsub error', _e);
+            }
+            throw e;
+        }
+    };
+    getFunction = () => {
+        if (!this.config.topic)
+            throw new ImplementationMissingException('MUST set a topic !!');
+        if (this.function)
+            return this.function;
+        return this.function = onMessagePublished(this.config, async (event) => {
+            // need to validate etc...
+            const originalMessage = event.data.message;
+            let data;
+            try {
+                data = JSON.parse(Buffer.from(originalMessage.data, 'base64').toString());
+            }
+            catch (e) {
+                this.logError(`Error parsing the data attribute from pub/sub message to topic ${this.topic}` +
+                    '\n' + __stringify(originalMessage.data) + '\n' + __stringify(e));
+            }
+            return this.handleCallback(() => this._onPublish(data, originalMessage, event));
+        });
+    };
+}

package/functions-v2/ModuleBE_StorageListener.d.ts

@@ -0,0 +1,13 @@
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { StorageEvent, StorageOptions } from 'firebase-functions/v2/storage';
+import { CloudFunction } from 'firebase-functions/v2';
+type Created = {
+    path: string;
+} & StorageOptions;
+export declare abstract class ModuleBE_StorageListener<ConfigType> extends ModuleBE_BaseFunction<ConfigType & Created> {
+    private function;
+    protected constructor(path?: string, name?: string);
+    abstract onFinalize(event: StorageEvent): Promise<any>;
+    getFunction: () => CloudFunction<StorageEvent>;
+}
+export {};

package/functions-v2/ModuleBE_StorageListener.js

@@ -0,0 +1,34 @@
+import { __stringify, dispatch_onApplicationNotification, ServerErrorSeverity } from '@nu-art/ts-common';
+import { ModuleBE_BaseFunction } from './ModuleBE_BaseFunction.js';
+import { onObjectFinalized } from 'firebase-functions/v2/storage';
+export class ModuleBE_StorageListener extends ModuleBE_BaseFunction {
+    function;
+    constructor(path, name) {
+        super();
+        if (path)
+            this.setDefaultConfig({ path: path, timeoutSeconds: 300, memory: '2GB' });
+        name && this.setName(name);
+    }
+    getFunction = () => {
+        if (this.function)
+            return this.function;
+        const handler = async (event) => {
+            try {
+                return await this.handleCallback(() => this.onFinalize(event));
+            }
+            catch (e) {
+                const _message = `Error handling callback to onFinalize bucket listener method on path:` + this.config.path +
+                    '\n' + `File changed ${event.data.name}` + '\n with attributes: ' + __stringify(context) + '\n' + __stringify(e);
+                this.logError(_message);
+                try {
+                    await dispatch_onApplicationNotification.dispatchModuleAsync(ServerErrorSeverity.Critical, this, { message: _message });
+                }
+                catch (_e) {
+                    this.logError('Error while handing bucket listener error', _e);
+                }
+                throw e;
+            }
+        };
+        return this.function = onObjectFinalized(this.config, handler);
+    };
+}