@nu-art/thunderstorm-backend 0.400.5

package/modules/ModuleBE_ForceUpgrade.js

@@ -0,0 +1,70 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * 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, ApiException, BadImplementationException, compareVersions, ImplementationMissingException, Module } from '@nu-art/ts-common';
+import { ApiDef_ForceUpgrade, HeaderKey_AppVersion, HeaderKey_BrowserType, HeaderKey_UserAgent } from '@nu-art/thunderstorm-shared';
+import { createQueryServerApi } from '../core/typed-api.js';
+import { HeaderKey } from './server/HeaderKey.js';
+import { addRoutes } from './ModuleBE_APIs.js';
+const Header_AppVersion = new HeaderKey(HeaderKey_AppVersion);
+const Header_BrowserType = new HeaderKey(HeaderKey_BrowserType);
+const Header_UserAgent = new HeaderKey(HeaderKey_UserAgent);
+const DefaultRegexps = {
+    chrome: 'Chrome/([0-9\.]+)'
+};
+class ModuleBE_ForceUpgrade_Class extends Module {
+    static Middleware = async () => ModuleBE_ForceUpgrade.assertVersion();
+    constructor() {
+        super();
+    }
+    init() {
+        super.init();
+        addRoutes([createQueryServerApi(ApiDef_ForceUpgrade.v1.assertAppVersion, async (params) => {
+                return this.compareVersion();
+            })]);
+    }
+    compareVersion() {
+        const appVersion = Header_AppVersion.get();
+        const userAgentString = Header_UserAgent.get();
+        const browserType = Header_BrowserType.get();
+        if (!browserType)
+            throw new ImplementationMissingException(`Browser type not specified`);
+        const chromeRegexp = this.config.regexp?.[browserType] || DefaultRegexps[browserType];
+        const version = userAgentString.match(new RegExp(chromeRegexp))?.[1];
+        if (!version)
+            throw new BadImplementationException(`Error extracting version.. \nUserAgent: '${userAgentString}'\n config: '${__stringify(this.config)}'`);
+        const requiredBrowserVersion = this.config.browser?.[browserType];
+        if (!requiredBrowserVersion)
+            throw new ImplementationMissingException(`Unsupported browser type: ${browserType}`);
+        let app = false;
+        let browser = false;
+        if (this.config.app)
+            app = compareVersions(appVersion, this.config.app) === 1;
+        if (requiredBrowserVersion)
+            browser = compareVersions(version, requiredBrowserVersion) === 1;
+        return { type: 'upgrade-required', data: { app, browser } };
+    }
+    async assertVersion() {
+        const upgradeRequired = this.compareVersion();
+        if (upgradeRequired.data.app || upgradeRequired.data.browser)
+            throw new ApiException(426, 'require upgrade..').setErrorBody(upgradeRequired);
+    }
+}
+export const ModuleBE_ForceUpgrade = new ModuleBE_ForceUpgrade_Class();

package/modules/ModuleBE_ServerInfo.d.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nu-art/ts-common';
+import { BasicServerInfo } from '@nu-art/thunderstorm-shared';
+type Config = BasicServerInfo;
+export declare class ModuleBE_ServerInfo_Class extends Module<Config> {
+    private serverInfoData;
+    constructor();
+    init(): Promise<void>;
+    private getServerInfo;
+    /**
+     * Perform a "ping" to the environment's default Firebase project's Firestore
+     */
+    pingFirestore: () => Promise<"ERROR" | "OK">;
+    /**
+     * Perform a "ping" to the environment's default Firebase project's RTDB
+     */
+    pingFirebaseRTDB: () => Promise<"ERROR" | "OK">;
+    private writeServerInfoState;
+}
+export declare const ModuleBE_ServerInfo: ModuleBE_ServerInfo_Class;
+export {};

package/modules/ModuleBE_ServerInfo.js

@@ -0,0 +1,76 @@
+import { Module, RuntimeVersion } from '@nu-art/ts-common';
+import { createQueryServerApi } from '../core/typed-api.js';
+import { addRoutes } from './ModuleBE_APIs.js';
+import { Storm } from '../core/Storm.js';
+import { ModuleBE_Firebase } from '@nu-art/firebase-backend';
+import { ApiDef_ServerInfo, Const_ERROR, Const_OK, Default_ServerInfoNodePath } from '@nu-art/thunderstorm-shared';
+import { ModuleBE_SyncManager } from './sync-manager/ModuleBE_SyncManager.js';
+export class ModuleBE_ServerInfo_Class extends Module {
+    serverInfoData;
+    constructor() {
+        super();
+    }
+    async init() {
+        super.init();
+        ModuleBE_Firebase.createAdminSession().getStorage().getMainBucket().then(async (bucket) => {
+            this.setDefaultConfig({
+                environment: Storm.getInstance().getEnvironment(),
+                version: RuntimeVersion(),
+                bucketName: bucket.getBucketName()
+            });
+        });
+        addRoutes([
+            createQueryServerApi(ApiDef_ServerInfo.v1.getServerInfo, this.getServerInfo),
+            createQueryServerApi(ApiDef_ServerInfo.v1.updateServerInfoState, async () => this.writeServerInfoState())
+        ]);
+        this.serverInfoData = ModuleBE_Firebase.createAdminSession().getDatabase().ref(Default_ServerInfoNodePath);
+    }
+    getServerInfo = async () => {
+        const firestoreResponse = await this.pingFirestore();
+        const firebaseRTDBResponse = await this.pingFirebaseRTDB();
+        const response = {
+            environment: this.config.environment,
+            version: this.config.version,
+            bucketName: this.config.bucketName,
+            status: {
+                firestore: firestoreResponse,
+                firebase: firebaseRTDBResponse
+            }
+        };
+        return response;
+    };
+    /**
+     * Perform a "ping" to the environment's default Firebase project's Firestore
+     */
+    pingFirestore = async () => {
+        try {
+            await ModuleBE_SyncManager.collection.query.custom({ where: {}, limit: 1 });
+            return Const_OK;
+        }
+        catch (e) {
+            this.logError(e);
+            return Const_ERROR;
+        }
+    };
+    /**
+     * Perform a "ping" to the environment's default Firebase project's RTDB
+     */
+    pingFirebaseRTDB = async () => {
+        try {
+            await this.serverInfoData.get();
+            return Const_OK;
+        }
+        catch (e) {
+            this.logError(e);
+            return Const_ERROR;
+        }
+    };
+    writeServerInfoState = async () => {
+        await this.serverInfoData.set({
+            environment: this.config.environment,
+            version: this.config.version,
+            bucketName: this.config.bucketName,
+        });
+    };
+}
+export const ModuleBE_ServerInfo = new ModuleBE_ServerInfo_Class();

package/modules/_imports.d.ts

@@ -0,0 +1,6 @@
+export * from './server/server-api.js';
+export * from './server/HttpServer.js';
+export * from './proxy/RemoteProxyCaller.js';
+export * from './proxy/ModuleBE_RemoteProxy.js';
+export * from '../utils/promisify-request.js';
+export * from './CleanupScheduler.js';

package/modules/_imports.js

@@ -0,0 +1,26 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * 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 * from './server/server-api.js';
+export * from './server/HttpServer.js';
+export * from './proxy/RemoteProxyCaller.js';
+export * from './proxy/ModuleBE_RemoteProxy.js';
+export * from '../utils/promisify-request.js';
+export * from './CleanupScheduler.js';

package/modules/_tdb/service-accounts.d.ts

@@ -0,0 +1,19 @@
+import { Dispatcher, UniqueId } from '@nu-art/ts-common';
+export type ServiceAccountCredentials = {
+    serviceAccount: {
+        email: string;
+        accountId?: string;
+        token?: string;
+    };
+};
+export type DefaultDef_ServiceAccount = {
+    moduleName: string;
+    email: string;
+    description?: string;
+    ttl?: number;
+    groupIds?: UniqueId[];
+};
+export interface RequiresServiceAccount {
+    __requiresServiceAccount(): DefaultDef_ServiceAccount | DefaultDef_ServiceAccount[];
+}
+export declare const dispatcher_collectServiceAccounts: Dispatcher<RequiresServiceAccount, "__requiresServiceAccount", [], DefaultDef_ServiceAccount | DefaultDef_ServiceAccount[]>;

package/modules/_tdb/service-accounts.js

@@ -0,0 +1,2 @@
+import { Dispatcher } from '@nu-art/ts-common';
+export const dispatcher_collectServiceAccounts = new Dispatcher('__requiresServiceAccount');

package/modules/action-processor/Action_SetupProject.d.ts

@@ -0,0 +1,9 @@
+import { ActionDeclaration } from './types.js';
+export type SetupProjectPromise = {
+    priority: number;
+    processor: () => Promise<void>;
+};
+export interface PerformProjectSetup {
+    __performProjectSetup(): SetupProjectPromise;
+}
+export declare const RAD_SetupProject: ActionDeclaration;

package/modules/action-processor/Action_SetupProject.js

@@ -0,0 +1,23 @@
+import { _keys, Dispatcher, StaticLogger } from '@nu-art/ts-common';
+const dispatcher_ProjectSetup = new Dispatcher('__performProjectSetup');
+const Action_SetupProject = async (logger) => {
+    logger.logInfo('Setting up Project');
+    const promises = dispatcher_ProjectSetup.dispatchModule();
+    const promiseMap = promises.reduce((resultMap, promise) => {
+        resultMap[promise.priority] = resultMap[promise.priority] ?? { processors: [] };
+        resultMap[promise.priority].processors.push(promise.processor);
+        return resultMap;
+    }, {});
+    const priorities = _keys(promiseMap).sort(); // Start with priority 0, as most important
+    for (const priorityKey of priorities) {
+        StaticLogger.logInfoBold(`Running SetupProject[${priorityKey}]`);
+        await Promise.all(promiseMap[priorityKey].processors.map(async (processor) => processor()));
+    }
+    logger.logInfo('Project Setup Completed!');
+};
+export const RAD_SetupProject = {
+    key: 'setup-project',
+    group: 'Initialization',
+    description: '...',
+    processor: Action_SetupProject
+};

package/modules/action-processor/ModuleBE_ActionProcessor.d.ts

@@ -0,0 +1,11 @@
+import { Logger, Module } from '@nu-art/ts-common';
+import { ActionDeclaration } from './types.js';
+export declare class ModuleBE_ActionProcessor_Class extends Module {
+    private readonly actions;
+    constructor();
+    protected init(): void;
+    readonly registerAction: (rad: ActionDeclaration, logger: Logger) => void;
+    private refactor;
+    private list;
+}
+export declare const ModuleBE_ActionProcessor: ModuleBE_ActionProcessor_Class;

package/modules/action-processor/ModuleBE_ActionProcessor.js

@@ -0,0 +1,67 @@
+import { _values, ApiException, BadImplementationException, exists, isErrorOfType, LogLevel, Module, resolveContent } from '@nu-art/ts-common';
+// import {ApiDefServer} from '../../utils/api-caller-types.js';
+import { ApiDef_ActionProcessing } from '@nu-art/thunderstorm-shared/action-processor/index';
+import { createBodyServerApi, createQueryServerApi } from '../../core/typed-api.js';
+import { addRoutes } from '../ModuleBE_APIs.js';
+import { RAD_SetupProject } from './Action_SetupProject.js';
+import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
+export class ModuleBE_ActionProcessor_Class extends Module {
+    actions = {};
+    constructor() {
+        super();
+        this.setMinLevel(LogLevel.Verbose);
+    }
+    init() {
+        super.init();
+        addRoutes([
+            createBodyServerApi(ApiDef_ActionProcessing.vv1.execute, this.refactor),
+            createQueryServerApi(ApiDef_ActionProcessing.vv1.list, this.list)
+        ]);
+        this.registerAction(RAD_SetupProject, this);
+    }
+    registerAction = (rad, logger) => {
+        this.logInfo(`Registering action: ${rad.key}`);
+        if (this.actions[rad.key])
+            throw new BadImplementationException(`ActionProcessor with key ${rad.key} was registered twice!`);
+        this.actions[rad.key] = {
+            action: (data) => rad.processor(logger || this, data),
+            declaration: rad
+        };
+    };
+    refactor = async (action) => {
+        this.logWarning(`RECEIVED ACTION: ${action.key}`);
+        const actionObj = this.actions[action.key];
+        if (exists(actionObj.declaration.visible) && !resolveContent(actionObj.declaration.visible))
+            throw HttpCodes._4XX.FORBIDDEN('Action Forbidden for User');
+        const refactoringAction = actionObj.action;
+        if (!refactoringAction) {
+            throw HttpCodes._4XX.NOT_FOUND(`NO SUCH ACTION: ${action.key}`);
+        }
+        try {
+            this.logWarning(`ACTION '${action.key}' - EXECUTING`);
+            await refactoringAction?.(action.data);
+            this.logWarning(`ACTION '${action.key}' - SUCCESSFUL`);
+        }
+        catch (e) {
+            this.logError(`ACTION '${action.key}' - FAILED`, e);
+            if (isErrorOfType(e, ApiException))
+                throw e;
+            const message = `ACTION FAILED: ${actionObj.declaration.label}`;
+            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(message, '', e);
+        }
+    };
+    list = async () => {
+        return _values(this.actions)
+            .filter(action => !exists(action.declaration.visible) || resolveContent(action.declaration.visible))
+            .map(action => {
+            const declaration = action.declaration;
+            return {
+                key: declaration.key,
+                label: declaration.label ?? declaration.key,
+                description: declaration.description,
+                group: declaration.group,
+            };
+        });
+    };
+}
+export const ModuleBE_ActionProcessor = new ModuleBE_ActionProcessor_Class();

package/modules/action-processor/types.d.ts

@@ -0,0 +1,10 @@
+import { Logger, ResolvableContent } from '@nu-art/ts-common';
+export type ActionProcessor = (logger: Logger, data?: any) => Promise<void>;
+export type ActionDeclaration = {
+    label?: string;
+    visible?: ResolvableContent<boolean>;
+    key: string;
+    processor: ActionProcessor;
+    description: string;
+    group: string;
+};

package/modules/action-processor/types.js

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

package/modules/archiving/ModuleBE_Archiving.d.ts

@@ -0,0 +1,119 @@
+import { DB_Object } from '@nu-art/ts-common';
+import { ModuleBE_FirestoreListener } from '@nu-art/firebase-backend';
+import { ModuleBE_BaseDB } from '../db-api-gen/ModuleBE_BaseDB.js';
+import { RequestBody_HardDeleteUnique, RequestQuery_DeleteAll, RequestQuery_GetHistory } from '@nu-art/thunderstorm-shared';
+type Params = {
+    collectionName: string;
+    docId: string;
+};
+export declare const Const_ArchivedCollectionPath = "/_archived";
+/**
+ * This class extends FirestoreFunctionModule and handles Firestore database operations
+ * with custom logic for archiving and Time-To-Live (TTL) functionality.
+ */
+export declare class ModuleBE_ArchiveModule_Class<DBType extends DB_Object> extends ModuleBE_FirestoreListener<DBType> {
+    private readonly TTL;
+    private readonly lastUpdatedTTL;
+    protected readonly moduleMapper: {
+        [key: string]: ModuleBE_BaseDB<any>;
+    };
+    /**
+     * Constructor initializes TTL, lastUpdatedTTL moduleMapper and sets api routes for the module.
+     */
+    constructor();
+    /**
+     * Initializes the `moduleMapper` by populating it with Firestore collections.
+     * Iterates through all modules obtained from the Storm instance and adds modules
+     * which are Firestore DB modules to the `moduleMapper`.
+     */
+    protected init(): void;
+    /**
+     * Deletes a unique document by its ID in a Firestore transaction.
+     * This method first retrieves the document with the given ID.
+     * If the document is found, it is marked for deletion and an upsert operation is performed.
+     * The upsert operation triggers a Firestore OnUpdate event, which will delete the document and its '_archived' sub-collection.
+     *
+     * @param body - An object of type `RequestBody_HardDeleteUnique` containing the following fields:
+     *    - _id: The ID of the document to be deleted.
+     *    - collectionName: The name of the collection the document belongs to.
+     *    - dbInstance: (optional) The instance of the document. If not provided, the method will attempt to retrieve it using the given ID.
+     * @returns - A promise that performs the deletion operation.
+     * @throws - A `BadImplementationException` if no module is found for the given collection or if no document with the provided ID is found.
+     */
+    hardDeleteUnique: (body: RequestBody_HardDeleteUnique) => Promise<void>;
+    /**
+     * Deletes all documents in the specified collection.
+     * This function first retrieves all documents in the collection.
+     * It then deletes each document in the collection in parallel chunks for efficiency.
+     *
+     * @param queryParams - Params includes the name of the collection in which the documents will be deleted.
+     * @returns - A promise that performs the deletion operation.
+     * @throws - A BadImplementationException if no corresponding module is found for the given collection.
+     */
+    hardDeleteAll: (queryParams: RequestQuery_DeleteAll) => Promise<void>;
+    /**
+     * Asynchronously retrieves the document history from the '_archived' collection group.
+     *
+     * This function takes a RequestQuery_GetHistory object as a parameter, which contains the name of the collection
+     * and the ID of the document for which the history should be retrieved.
+     * It then finds the respective Firestore DB module for the provided collection.
+     *
+     * If no module is found for the given collection, a BadImplementationException is thrown.
+     *
+     * The function queries the '_archived' collection group where the '_originDocId' field matches the provided
+     * document ID, and orders the results by the '__created' timestamp in descending order.
+     * It then maps the document snapshots to their respective data, creating an array of DBType documents, which is returned.
+     *
+     * @param queryParams - The request query parameters containing the collection name and the document ID.
+     * @returns - An array of DBType documents representing the history of the specified document.
+     * @throws - A BadImplementationException if no module is found for the given collection.
+     */
+    getDocumentHistory: (queryParams: RequestQuery_GetHistory) => Promise<DBType[]>;
+    /**
+     * Checks if the Time-To-Live (TTL) for a document instance has been exceeded.
+     *
+     * @param instance - The document instance to check.
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @returns - A boolean indicating whether the TTL has been exceeded (true) or not (false).
+     */
+    private checkTTL;
+    /**
+     * Checks if the `lastUpdatedTTL` for a document instance has been exceeded.
+     * This represents a secondary TTL which is based on the last update time of the document.
+     *
+     * @param instance - The document instance to check.
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @returns - A boolean indicating whether the `lastUpdatedTTL` has been exceeded (true) or not (false).
+     */
+    private checkLastUpdatedTTL;
+    /**
+     * Inserts a document into the '_archived' sub-collection.
+     * This function is used for archiving the previous state of the document before it was changed.
+     *
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @param before - The state of the document before changes.
+     * @returns - A promise that performs the archiving operation or undefined in case of an error.
+     */
+    private insertToArchive;
+    /**
+     * Hard deletes a document and its associated archived documents.
+     *
+     * @param instance - The instance of the document to delete.
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @returns - A promise to perform the deletion operation.
+     */
+    private hardDeleteDoc;
+    /**
+     * Processes changes in the Firestore collection.
+     * Depending on the state of the documents, it either archives the documents,
+     * checks the Time-To-Live (TTL) or performs a hard delete operation.
+     *
+     * @param params - An object containing the collectionName and the document ID.
+     * @param before - The state of the document before changes.
+     * @param after - The state of the document after changes.
+     * @returns - A promise that performs the necessary operation based on the document states.
+     */
+    processChanges(params: Params, before: DBType | undefined, after: DBType | undefined): Promise<void | FirebaseFirestore.WriteResult[]>;
+}
+export declare const ModuleBE_Archiving: ModuleBE_ArchiveModule_Class<DB_Object>;
+export {};