@nu-art/thunderstorm-backend 0.400.5

package/core/BaseStorm.d.ts

@@ -0,0 +1,17 @@
+import { Module, ModuleManager, TS_Object } from '@nu-art/ts-common';
+export type StormConfig = {
+    envKey: string;
+    pathToDefaultConfig: string;
+    pathToEnvOverrideConfig: string;
+};
+export declare abstract class BaseStorm extends ModuleManager {
+    protected innerConfig: StormConfig;
+    private override;
+    readonly isDebug = false;
+    constructor(config: StormConfig | string);
+    getEnvironment(): string;
+    setOverride(override: TS_Object): void;
+    protected resolveConfig: () => Promise<void>;
+    getEnvConfigRef<Config>(module: Module<Config>): import("@nu-art/firebase-backend").FirebaseRef<Config>;
+    getGlobalEnvConfigRef(): import("@nu-art/firebase-backend").FirebaseRef<TS_Object>;
+}

package/core/BaseStorm.js

@@ -0,0 +1,77 @@
+/*
+ * 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 { merge, ModuleManager } from '@nu-art/ts-common';
+import { ModuleBE_Firebase } from '@nu-art/firebase-backend';
+export class BaseStorm extends ModuleManager {
+    innerConfig;
+    override = {};
+    isDebug = false;
+    constructor(config) {
+        super();
+        if (typeof config === 'string')
+            this.innerConfig = {
+                envKey: config,
+                pathToDefaultConfig: `_config/default.json`,
+                pathToEnvOverrideConfig: `_config/${config}.json`,
+            };
+        else
+            this.innerConfig = config;
+    }
+    getEnvironment() {
+        return this.innerConfig.envKey;
+    }
+    setOverride(override) {
+        this.override = override;
+    }
+    resolveConfig = async () => {
+        const database = ModuleBE_Firebase.createAdminSession().getDatabase();
+        this.logInfo(`LOADING RTDB FROM: ${database.getUrl()}`);
+        let initialized = 0;
+        const listener = (resolve) => (snapshot) => {
+            if (initialized >= 2) {
+                this.logWarning('CONFIGURATION HAS CHANGED... KILLING PROCESS!!!');
+                process.exit(2);
+            }
+            resolve(snapshot || {});
+            initialized++;
+        };
+        const defaultPromise = new Promise((resolve) => {
+            this.logInfo(`Loading default config from: ${database.getUrl()}${this.innerConfig.pathToDefaultConfig}`);
+            database.listen(`/${this.innerConfig.pathToDefaultConfig}`, listener(resolve));
+        });
+        const envPromise = new Promise((resolve) => {
+            this.logInfo(`Loading env override config from: ${database.getUrl()}${this.innerConfig.pathToEnvOverrideConfig}`);
+            database.listen(`/${this.innerConfig.pathToEnvOverrideConfig}`, listener(resolve));
+        });
+        const [defaultConfig, overrideConfig] = await Promise.all([
+            defaultPromise,
+            envPromise
+        ]);
+        const merge1 = merge(defaultConfig, overrideConfig);
+        this.setConfig(merge(merge1, this.override) || {});
+    };
+    getEnvConfigRef(module) {
+        return ModuleBE_Firebase.createAdminSession().getDatabase().ref(`/${this.innerConfig.pathToEnvOverrideConfig}/${module.getName()}`);
+    }
+    getGlobalEnvConfigRef() {
+        return ModuleBE_Firebase.createAdminSession().getDatabase().ref(`/${this.innerConfig.pathToEnvOverrideConfig}`);
+    }
+}

package/core/Storm.d.ts

@@ -0,0 +1,15 @@
+import { StormConfig, BaseStorm } from './BaseStorm.js';
+import { HttpRoute, RouteResolver } from '../modules/server/route-resolvers/index.js';
+export declare class Storm extends BaseStorm {
+    private routeResolver;
+    private functions;
+    constructor(config: StormConfig | string);
+    init(): this;
+    setInitialRouteResolver(routeResolver: RouteResolver): this;
+    startServer(onStarted?: () => Promise<void>): any;
+    getRoutes(): HttpRoute[];
+    build(onStarted?: () => Promise<void>): any;
+    private startServerImpl;
+    static getInstance(): Storm;
+    getConfig(): any;
+}

package/core/Storm.js

@@ -0,0 +1,93 @@
+/*
+ * 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 { BeLogged, LogClient_Function, LogClient_Terminal, LogLevel } from '@nu-art/ts-common';
+import { Firebase_ExpressFunction } from '@nu-art/firebase-backend';
+import { BaseStorm } from './BaseStorm.js';
+import { HttpServer } from '../modules/server/HttpServer.js';
+import { ModuleBE_BaseFunction, ModuleBE_Firebase } from '@nu-art/firebase-backend';
+import { ServerApi } from '../modules/server/server-api.js';
+const modules = [
+    HttpServer,
+    ModuleBE_Firebase,
+];
+export class Storm extends BaseStorm {
+    routeResolver;
+    functions = [];
+    constructor(config) {
+        super(config);
+        BeLogged.addClient(process.env.GCLOUD_PROJECT && process.env.FUNCTIONS_EMULATOR ? LogClient_Terminal : LogClient_Function);
+        this.addModulePack(modules);
+        this.setMinLevel(LogLevel.Info);
+    }
+    init() {
+        ServerApi.isDebug = this.config.isDebug === true;
+        super.init();
+        this.routeResolver.resolveApi();
+        if (this.config.printRoutes === true)
+            this.routeResolver.printRoutes();
+        return this;
+    }
+    setInitialRouteResolver(routeResolver) {
+        this.routeResolver = routeResolver;
+        return this;
+    }
+    startServer(onStarted) {
+        const modulesAsFunction = this.modules.filter((module) => {
+            const b = module instanceof ModuleBE_BaseFunction;
+            // console.log(`${module.getName()} function ${b}`)
+            return b;
+        });
+        this.functions = [new Firebase_ExpressFunction(HttpServer.getExpress()), ...modulesAsFunction];
+        this.startServerImpl(onStarted)
+            .then(() => this.logInfo('Server Started!!'))
+            .catch(reason => {
+            this.logError('failed to launch server', reason);
+            throw reason;
+        });
+        return this.functions.reduce((toRet, _function) => {
+            toRet[_function.getName()] = _function.getFunction();
+            return toRet;
+        }, {});
+    }
+    getRoutes() {
+        return this.routeResolver.resolveRoutes();
+    }
+    build(onStarted) {
+        return this.startServer(onStarted);
+    }
+    async startServerImpl(onStarted) {
+        const label = 'Resolving Config';
+        console.time(label);
+        await this.resolveConfig();
+        console.timeEnd(label);
+        this.init();
+        await HttpServer.startServer();
+        const functions = await Promise.all(this.functions.map(moduleAsFunction => moduleAsFunction.onFunctionReady()));
+        await onStarted?.();
+        return functions;
+    }
+    static getInstance() {
+        return Storm.instance;
+    }
+    getConfig() {
+        return this.config;
+    }
+}

package/core/db-def.d.ts

@@ -0,0 +1,10 @@
+import { DBDef_V3, DBProto } from '@nu-art/ts-common';
+export type DBApiBEConfig<Proto extends DBProto<any>> = {
+    uniqueKeys: Proto['uniqueKeys'];
+    itemName: string;
+    versions: Proto['versions'];
+    TTL: number;
+    lastUpdatedTTL: number;
+    lockKeys?: Proto['lockKeys'];
+};
+export declare const getModuleBEConfig: <Proto extends DBProto<any, any, any>>(dbDef: DBDef_V3<Proto>) => DBApiBEConfig<Proto>;

package/core/db-def.js

@@ -0,0 +1,11 @@
+import { Const_UniqueKeys, Day, Hour } from '@nu-art/ts-common';
+export const getModuleBEConfig = (dbDef) => {
+    return {
+        versions: dbDef.versions,
+        lockKeys: dbDef.lockKeys,
+        uniqueKeys: dbDef.uniqueKeys || Const_UniqueKeys,
+        itemName: dbDef.entityName,
+        TTL: dbDef.TTL || Hour * 2,
+        lastUpdatedTTL: dbDef.lastUpdatedTTL || Day,
+    };
+};

package/core/default-storm.d.ts

@@ -0,0 +1,3 @@
+import { Storm } from './Storm.js';
+import { StormConfig } from './BaseStorm.js';
+export declare function createStorm(config: StormConfig | string): Storm;

package/core/default-storm.js

@@ -0,0 +1,30 @@
+/*
+ * 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 { ModuleBE_Firebase } from '@nu-art/firebase-backend';
+import { HttpServer } from '../modules/server/HttpServer.js';
+import { Storm } from './Storm.js';
+const modules = [
+    HttpServer,
+    ModuleBE_Firebase,
+];
+export function createStorm(config) {
+    return new Storm(config).addModulePack(modules);
+}

package/core/storm-modulepack.d.ts

@@ -0,0 +1,3 @@
+import { Module } from '@nu-art/ts-common';
+export declare const ModulePack_ThunderstormBE: Module[];
+export declare const ModulePackBE_Thunderstorm: Module<any, any, import("@nu-art/ts-common").Validator<any> | import("@nu-art/ts-common").TypeValidator<any>>[];

package/core/storm-modulepack.js

@@ -0,0 +1,20 @@
+import { ModuleBE_SyncManager } from '../modules/sync-manager/ModuleBE_SyncManager.js';
+import { ModuleBE_APIs } from '../modules/ModuleBE_APIs.js';
+import { ModuleBE_SyncEnv } from '../modules/sync-env/ModuleBE_SyncEnv.js';
+import { ModuleBE_ActionProcessor } from '../modules/action-processor/ModuleBE_ActionProcessor.js';
+import { ModuleBE_ServerInfo } from '../modules/ModuleBE_ServerInfo.js';
+import { ModulePackBE_AppConfigDB } from '../_entity/app-config/index.js';
+import { ModulePackBE_BackupDocDB } from '../_entity/backup-doc/index.js';
+import { ModuleBE_CollectionActions } from '../modules/collection-actions/ModuleBE_CollectionActions.js';
+export const ModulePack_ThunderstormBE = [
+    ModuleBE_ServerInfo,
+    ModuleBE_SyncManager,
+    ModuleBE_APIs,
+    ModuleBE_SyncEnv,
+    ModuleBE_ActionProcessor,
+    ModuleBE_CollectionActions,
+    // ...ModulePackBE_EditableTest,
+    ...ModulePackBE_AppConfigDB,
+    ...ModulePackBE_BackupDocDB,
+];
+export const ModulePackBE_Thunderstorm = ModulePack_ThunderstormBE;

package/core/typed-api.d.ts

@@ -0,0 +1,7 @@
+import { _ServerBodyApi, _ServerQueryApi } from '../modules/server/server-api.js';
+import { ApiDef, BaseHttpRequest, BodyApi, HttpMethod_Body, HttpMethod_Query, QueryApi } from '@nu-art/thunderstorm-shared';
+import { ServerApi_Middleware } from '../utils/types.js';
+export declare function createQueryServerApi<API extends QueryApi<any, any, any, any, HttpMethod_Query>>(apiDef: ApiDef<API>, action: (params: API['P']) => Promise<API['R']>, ...middleware: ServerApi_Middleware[]): _ServerQueryApi<API>;
+export declare function createBodyServerApi<API extends BodyApi<any, any, any, any, HttpMethod_Body>>(apiDef: ApiDef<API>, action: (body: API['B']) => Promise<API['R']>, ...middleware: ServerApi_Middleware[]): _ServerBodyApi<API>;
+export declare function apiWithQueryAxios<API extends QueryApi<any, any>>(apiDef: ApiDef<API>, onCompleted?: (response: API['R'], params: API['P'], request: BaseHttpRequest<API>) => Promise<any>, onError?: (errorResponse: any, input: API['P'] | API['B'], request: BaseHttpRequest<API>) => Promise<any>): (params: API["P"]) => BaseHttpRequest<API>;
+export declare function apiWithBodyAxios<API extends BodyApi<any, any, any, any, HttpMethod_Body>>(apiDef: ApiDef<API>, onCompleted?: (response: API['R'], body: API['B'], request: BaseHttpRequest<API>) => Promise<any>, onError?: (errorResponse: any, input: API['P'] | API['B'], request: BaseHttpRequest<API>) => Promise<any>): (body: API["B"]) => BaseHttpRequest<API>;

package/core/typed-api.js

@@ -0,0 +1,46 @@
+/*
+ * 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 { AxiosHttpModule } from '../modules/http/AxiosHttpModule.js';
+import { _ServerBodyApi, _ServerQueryApi } from '../modules/server/server-api.js';
+export function createQueryServerApi(apiDef, action, ...middleware) {
+    return new _ServerQueryApi(apiDef, action).setMiddlewares(...middleware);
+}
+export function createBodyServerApi(apiDef, action, ...middleware) {
+    return new _ServerBodyApi(apiDef, action).setMiddlewares(...middleware);
+}
+export function apiWithQueryAxios(apiDef, onCompleted, onError) {
+    return (params) => {
+        return AxiosHttpModule
+            .createRequest(apiDef)
+            .setUrlParams(params)
+            .setOnError(onError)
+            .setOnCompleted(onCompleted);
+    };
+}
+export function apiWithBodyAxios(apiDef, onCompleted, onError) {
+    return (body) => {
+        return AxiosHttpModule
+            .createRequest(apiDef)
+            .setBodyAsJson(body)
+            .setOnError(onError)
+            .setOnCompleted(onCompleted);
+    };
+}

package/exceptions.d.ts

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

package/exceptions.js

@@ -0,0 +1,21 @@
+/*
+ * 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 {};

package/index.d.ts

@@ -0,0 +1,27 @@
+export * from './modules/proxy/RemoteProxyCaller.js';
+export * from './modules/proxy/ModuleBE_RemoteProxy.js';
+export * from './modules/CleanupScheduler.js';
+export * from './modules/ModuleBE_APIs.js';
+export * from './modules/action-processor/ModuleBE_ActionProcessor.js';
+export * from './modules/action-processor/types.js';
+export * from './modules/server/server-errors.js';
+export * from './modules/server/server-api.js';
+export * from './modules/server/HeaderKey.js';
+export * from './modules/server/HttpServer.js';
+export * from './modules/server/route-resolvers/index.js';
+export * from './modules/http/AxiosHttpModule.js';
+export * from './modules/http/types.js';
+export * from './modules/ModuleBE_ForceUpgrade.js';
+export * from './modules/ModuleBE_ServerInfo.js';
+export * from './utils/promisify-request.js';
+export * from './utils/types.js';
+export * from './utils/file.js';
+export * from './core/Storm.js';
+export * from './core/typed-api.js';
+export * from './core/db-def.js';
+export * from './modules/archiving/ModuleBE_Archiving.js';
+export * from './modules/sync-env/ModuleBE_SyncEnv.js';
+export * from './modules/sync-manager/ModuleBE_SyncManager.js';
+export * from './modules/db-api-gen/ModuleBE_BaseDB.js';
+export * from './modules/db-api-gen/ModuleBE_BaseApi.js';
+export * from './_entity.js';

package/index.js

@@ -0,0 +1,48 @@
+/*
+ * 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 './modules/proxy/RemoteProxyCaller.js';
+export * from './modules/proxy/ModuleBE_RemoteProxy.js';
+export * from './modules/CleanupScheduler.js';
+export * from './modules/ModuleBE_APIs.js';
+export * from './modules/action-processor/ModuleBE_ActionProcessor.js';
+export * from './modules/action-processor/types.js';
+export * from './modules/server/server-errors.js';
+export * from './modules/server/server-api.js';
+export * from './modules/server/HeaderKey.js';
+export * from './modules/server/HttpServer.js';
+export * from './modules/server/route-resolvers/index.js';
+export * from './modules/http/AxiosHttpModule.js';
+export * from './modules/http/types.js';
+export * from './modules/ModuleBE_ForceUpgrade.js';
+export * from './modules/ModuleBE_ServerInfo.js';
+export * from './utils/promisify-request.js';
+export * from './utils/types.js';
+export * from './utils/file.js';
+export * from './core/Storm.js';
+export * from './core/typed-api.js';
+// from db-api-generator
+export * from './core/db-def.js';
+export * from './modules/archiving/ModuleBE_Archiving.js';
+export * from './modules/sync-env/ModuleBE_SyncEnv.js';
+export * from './modules/sync-manager/ModuleBE_SyncManager.js';
+export * from './modules/db-api-gen/ModuleBE_BaseDB.js';
+export * from './modules/db-api-gen/ModuleBE_BaseApi.js';
+export * from './_entity.js';

package/modules/CleanupScheduler.d.ts

@@ -0,0 +1,14 @@
+import { ModuleBE_FirebaseScheduler } from '@nu-art/firebase-backend';
+export type CleanupDetails = {
+    cleanup: () => Promise<void>;
+    interval: number;
+    moduleKey: string;
+};
+export interface OnCleanupSchedulerAct {
+    __onCleanupSchedulerAct: () => CleanupDetails;
+}
+export declare class CleanupScheduler_Class extends ModuleBE_FirebaseScheduler {
+    constructor();
+    onScheduledEvent: () => Promise<any>;
+}
+export declare const CleanupScheduler: CleanupScheduler_Class;

package/modules/CleanupScheduler.js

@@ -0,0 +1,50 @@
+/*
+ * 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 { currentTimeMillis, Dispatcher } from '@nu-art/ts-common';
+import { ModuleBE_Firebase } from '@nu-art/firebase-backend/ModuleBE_Firebase';
+import { ModuleBE_FirebaseScheduler } from '@nu-art/firebase-backend';
+const dispatch_onCleanupSchedulerAct = new Dispatcher('__onCleanupSchedulerAct');
+export class CleanupScheduler_Class extends ModuleBE_FirebaseScheduler {
+    constructor() {
+        super();
+        this.setSchedule('every 1 hours');
+    }
+    onScheduledEvent = async () => {
+        const cleanupStatusCollection = ModuleBE_Firebase.createAdminSession().getFirestore().getCollection('cleanup-status', ['moduleKey']);
+        const cleanups = dispatch_onCleanupSchedulerAct.dispatchModule();
+        await Promise.all(cleanups.map(async (cleanupItem) => {
+            const doc = await cleanupStatusCollection.queryUnique({ where: { moduleKey: cleanupItem.moduleKey } });
+            if (doc && doc.timestamp + cleanupItem.interval > currentTimeMillis())
+                return;
+            try {
+                await cleanupItem.cleanup();
+                await cleanupStatusCollection.upsert({
+                    timestamp: currentTimeMillis(),
+                    moduleKey: cleanupItem.moduleKey
+                });
+            }
+            catch (e) {
+                this.logWarning(`cleanup of ${cleanupItem.moduleKey} has failed with error '${e}'`);
+            }
+        }));
+    };
+}
+export const CleanupScheduler = new CleanupScheduler_Class();

package/modules/ModuleBE_APIs.d.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nu-art/ts-common/core/module';
+import { ServerApi } from './server/server-api.js';
+import { TestResetListener } from '@nu-art/ts-common/testing/types';
+export declare class ModuleBE_APIs_Class extends Module implements TestResetListener {
+    private readonly routes;
+    __resetForTests(): Promise<void>;
+    addRoutes: (apis: ServerApi<any>[]) => void;
+    useRoutes: () => ServerApi<any>[];
+}
+export declare const ModuleBE_APIs: ModuleBE_APIs_Class;
+export declare const addRoutes: (apis: ServerApi<any>[]) => void;

package/modules/ModuleBE_APIs.js

@@ -0,0 +1,19 @@
+import { Module } from '@nu-art/ts-common/core/module';
+import { MUSTNeverHappenException } from '@nu-art/ts-common';
+export class ModuleBE_APIs_Class extends Module {
+    routes = [];
+    async __resetForTests() {
+        this.logWarning('__resetForTests');
+        this.routes.length = 0;
+    }
+    addRoutes = (apis) => {
+        apis.forEach(api => {
+            if (this.routes.find(_api => _api.apiDef.path === api.apiDef.path))
+                throw new MUSTNeverHappenException(`There is more than one API with the path '${api.apiDef.path}'!!!`);
+            this.routes.push(api);
+        });
+    };
+    useRoutes = () => this.routes;
+}
+export const ModuleBE_APIs = new ModuleBE_APIs_Class();
+export const addRoutes = (apis) => ModuleBE_APIs.addRoutes(apis);

package/modules/ModuleBE_CSVParser.d.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nu-art/ts-common';
+import * as Papa from 'papaparse';
+import { Transform } from 'stream';
+declare class ModuleBE_CSVParser_Class extends Module {
+    getTransform_FromCSV: (config?: Papa.ParseConfig) => Transform;
+    getTransform_ToCSV: (config?: Papa.UnparseConfig) => Transform;
+}
+export declare const ModuleBE_CSVParser: ModuleBE_CSVParser_Class;
+export {};

package/modules/ModuleBE_CSVParser.js

@@ -0,0 +1,50 @@
+import { Module } from '@nu-art/ts-common';
+import * as Papa from 'papaparse';
+import { Transform } from 'stream';
+class ModuleBE_CSVParser_Class extends Module {
+    getTransform_FromCSV = (config) => new TransformFromCSV(config);
+    getTransform_ToCSV = (config) => new TransformToCSV(config);
+}
+export const ModuleBE_CSVParser = new ModuleBE_CSVParser_Class();
+class TransformFromCSV extends Transform {
+    config;
+    constructor(config) {
+        super({ objectMode: true });
+        this.config = {
+            header: true,
+            ...config
+        };
+    }
+    _transform(chunk, encoding, callback) {
+        Papa.parse(chunk.toString(), {
+            ...this.config,
+            error: (error) => callback(error),
+            complete: (results) => {
+                results.data.forEach(row => this.push(row));
+                callback();
+            }
+        });
+    }
+}
+class TransformToCSV extends Transform {
+    config;
+    firstChunk;
+    constructor(config) {
+        super({ objectMode: true });
+        this.firstChunk = true;
+        this.config = {
+            header: true,
+            ...config,
+        };
+    }
+    _transform(chunk, encoding, callback) {
+        const data = Array.isArray(chunk) ? chunk : [chunk];
+        const parsed = Papa.unparse(data, this.config);
+        this.push(parsed);
+        if (this.firstChunk) {
+            this.firstChunk = false;
+            this.config.header = false;
+        }
+        callback();
+    }
+}

package/modules/ModuleBE_ForceUpgrade.d.ts

@@ -0,0 +1,21 @@
+import { Module } from '@nu-art/ts-common';
+import { Browser, UpgradeRequired } from '@nu-art/thunderstorm-shared';
+import { ServerApi_Middleware } from '../utils/types.js';
+type VersionConfig = {
+    regexp: {
+        [K in Browser]: string;
+    };
+    browser: {
+        [K in Browser]: string;
+    };
+    app: string;
+};
+declare class ModuleBE_ForceUpgrade_Class extends Module<VersionConfig> {
+    static readonly Middleware: ServerApi_Middleware;
+    constructor();
+    init(): void;
+    compareVersion(): UpgradeRequired;
+    assertVersion(): Promise<void>;
+}
+export declare const ModuleBE_ForceUpgrade: ModuleBE_ForceUpgrade_Class;
+export {};