@nu-art/thunderstorm-backend 0.400.5

package/modules/db-api-gen/ModuleBE_BaseDB.js

@@ -0,0 +1,298 @@
+/*
+ * Database API Generator is a utility library for Thunderstorm.
+ *
+ * Given proper configurations it will dynamically generate APIs to your Firestore
+ * collections, will assert uniqueness and restrict deletion... and more
+ *
+ * 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 { _keys, ApiException, asArray, BadImplementationException, batchActionParallel, currentTimeMillis, dbObjectToId, filterDuplicates, filterInstances, getDotNotatedValue, merge, Module } from '@nu-art/ts-common';
+import { ModuleBE_Firebase, } from '@nu-art/firebase-backend';
+import { getModuleBEConfig } from '../../core/db-def.js';
+import { ModuleBE_SyncManager } from '../sync-manager/ModuleBE_SyncManager.js';
+import { MemKey_DeletedDocs } from '@nu-art/firebase-backend/firestore-v3/consts';
+import { dispatch_CollectEntityDependencies } from '../collection-actions/dispatcher.js';
+const CONST_DefaultWriteChunkSize = 200;
+/**
+ * An abstract base class used for implementing CRUD operations on a specific collection.
+ *
+ * By default, it exposes API endpoints for creating, deleting, updating, querying and querying for unique document.
+ */
+export class ModuleBE_BaseDB extends Module {
+    // @ts-ignore
+    ModuleBE_BaseDBV2 = true;
+    // private static DeleteHardLimit = 250;
+    collection;
+    dbDef;
+    query;
+    create;
+    set;
+    delete;
+    doc;
+    runTransaction;
+    constructor(dbDef, appConfig) {
+        super();
+        const config = getModuleBEConfig(dbDef);
+        const preConfig = { chunksSize: CONST_DefaultWriteChunkSize, ...config, ...appConfig };
+        // @ts-ignore
+        this.setDefaultConfig(preConfig);
+        this.dbDef = dbDef;
+        this.canDeleteItems.bind(this);
+        this._preWriteProcessing.bind(this);
+        this._postWriteProcessing.bind(this);
+        this.upgradeInstances.bind(this);
+        this.manipulateQuery.bind(this);
+        this.collectDependencies.bind(this);
+    }
+    __collectEntityDependencies = async (type, itemIds, transaction) => {
+        //Assert this collection has dependencies fields to go over
+        const dependencyDefs = (this.dbDef.dependencies ?? {});
+        const dependencyDefKeys = _keys(dependencyDefs).filter(key => dependencyDefs[key].dbKey === type);
+        if (!dependencyDefKeys.length)
+            return;
+        //Collect all conflicting item queries
+        const conflictItemQueries = dependencyDefKeys.reduce((acc, dependencyDefKey) => {
+            const dependencyDef = dependencyDefs[dependencyDefKey];
+            let whereClause;
+            switch (dependencyDef.fieldType) {
+                case 'string':
+                    whereClause = ids => ({ [dependencyDefKey]: { $in: ids } });
+                    break;
+                case 'string[]':
+                    whereClause = ids => ({ [dependencyDefKey]: { $aca: ids } });
+                    break;
+                default:
+                    throw new BadImplementationException(`Proto Dependency fieldType is not 'string'/'string[]'. Cannot check for EntityDependency for collection '${this.dbDef.dbKey}'.`);
+            }
+            acc.push(batchActionParallel(itemIds, 10, async (ids) => this.query.unManipulatedQuery({ where: whereClause(ids) }, transaction)));
+            return acc;
+        }, []);
+        if (!conflictItemQueries.length)
+            return;
+        //Get all conflicting items
+        let conflictingItems = filterInstances((await Promise.all(conflictItemQueries)).flat());
+        conflictingItems = filterDuplicates(conflictingItems, dbObjectToId);
+        //Filter out conflicting items that were already deleted in this transaction
+        const ignoredInThisTransaction = MemKey_DeletedDocs.get([]).find(item => item.transaction === transaction);
+        if (ignoredInThisTransaction) {
+            //The key associated with this collection
+            const ignoredForThisCollection = ignoredInThisTransaction.deleted[this.dbDef.dbKey];
+            //Filter out all ids of items which were already deleted in this transaction
+            conflictingItems = conflictingItems.filter(object => !ignoredForThisCollection?.has(object._id));
+        }
+        return {
+            dbKey: type,
+            dependencyMap: this.mapConflicts(conflictingItems, itemIds, dependencyDefKeys),
+        };
+    };
+    mapConflicts = (conflictItems, itemIds, conflictFields) => {
+        return itemIds.reduce((acc, itemId) => {
+            const conflictingItems = conflictItems.filter(item => {
+                for (const field of conflictFields) {
+                    const value = getDotNotatedValue(field, item);
+                    if (asArray(value).includes(itemId))
+                        return true;
+                }
+                return false;
+            });
+            if (conflictingItems.length)
+                acc[itemId] = { [this.dbDef.dbKey]: conflictingItems.map(dbObjectToId) };
+            return acc;
+        }, {});
+    };
+    /**
+     * Executed during the initialization of the module.
+     * The collection reference is set in this method.
+     */
+    init() {
+        const firestore = ModuleBE_Firebase.createAdminSession(this.config?.projectId).getFirestoreV3();
+        this.collection = firestore.getCollection(this.dbDef, {
+            canDeleteItems: this.canDeleteItems.bind(this),
+            preWriteProcessing: this._preWriteProcessing.bind(this),
+            postWriteProcessing: this._postWriteProcessing.bind(this),
+            upgradeInstances: this.upgradeInstances.bind(this),
+            manipulateQuery: this.manipulateQuery.bind(this)
+        });
+        // ############################## API ##############################
+        this.runTransaction = this.collection.runTransaction;
+        const wrapInTryCatch = (input, path) => _keys(input).reduce((acc, key) => {
+            const value = input[key];
+            const newPath = path ? `${path}.${String(key)}` : String(key);
+            if (typeof value === 'function') {
+                acc[key] = (async (...args) => {
+                    try {
+                        return await value(...args);
+                    }
+                    catch (e) {
+                        this.logError(`Error while calling "${newPath}"`);
+                        throw e;
+                    }
+                });
+                return acc;
+            }
+            if (typeof value === 'object' && value !== null) {
+                acc[key] = wrapInTryCatch(value, newPath);
+                return acc;
+            }
+            acc[key] = value;
+            return acc;
+        }, {});
+        this.query = wrapInTryCatch(this.collection.query, 'query');
+        this.create = wrapInTryCatch(this.collection.create, 'create');
+        this.set = wrapInTryCatch(this.collection.set, 'set');
+        this.delete = wrapInTryCatch(this.collection.delete, 'delete');
+        this.doc = wrapInTryCatch(this.collection.doc, 'doc');
+    }
+    querySync = async (syncQuery) => {
+        const items = await this.collection.query.custom(syncQuery);
+        const deletedItems = await ModuleBE_SyncManager.queryDeleted(this.dbDef.dbKey, syncQuery);
+        await this.upgradeInstances(items);
+        return { toUpdate: items, toDelete: deletedItems };
+    };
+    _preWriteProcessing = async (dbItem, originalDbInstance, transaction, upgrade = true) => {
+        await this.preWriteProcessing(dbItem, originalDbInstance, transaction);
+    };
+    /**
+     * Override this method to customize the processing that should be done before create, set or update.
+     *
+     * @param transaction - The transaction object.
+     * @param dbInstance - The DB entry for which the uniqueness is being asserted.
+     * @param originalDbInstance - The DB instance fetched from remote firestore.
+     */
+    async preWriteProcessing(dbInstance, originalDbInstance, transaction) {
+    }
+    _postWriteProcessing = async (data, actionType, transaction) => {
+        const now = currentTimeMillis();
+        if (data.updated && !(Array.isArray(data.updated) && data.updated.length === 0)) {
+            const latestUpdated = Array.isArray(data.updated) ?
+                data.updated.reduce((toRet, current) => Math.max(toRet, current.__updated), data.updated[0].__updated) :
+                data.updated.__updated;
+            await ModuleBE_SyncManager.setLastUpdated(this.dbDef.dbKey, latestUpdated);
+        }
+        if (data.deleted && !(Array.isArray(data.updated) && data.updated.length === 0)) {
+            await ModuleBE_SyncManager.onItemsDeleted(this.dbDef.dbKey, asArray(data.deleted), this.config.uniqueKeys, transaction);
+            await ModuleBE_SyncManager.setLastUpdated(this.dbDef.dbKey, now);
+        }
+        else if (data.deleted === null)
+            // this means the whole collection has been deleted - setting the oldestDeleted to now will trigger a clean sync
+            await ModuleBE_SyncManager.setOldestDeleted(this.dbDef.dbKey, now);
+        await this.postWriteProcessing(data, actionType, transaction);
+    };
+    /**
+     * Override this method to customize processing that should be done after create, set, update or delete.
+     * @param data
+     * @param actionType create/set/update/delete
+     * @param transaction
+     */
+    async postWriteProcessing(data, actionType, transaction) {
+    }
+    manipulateQuery(query) {
+        return query;
+    }
+    preUpsertProcessing;
+    /**
+     * Override this method to provide actions or assertions to be executed before the deletion happens.
+     * @param transaction - The transaction object
+     * @param dbItems - The DB entry that is going to be deleted.
+     */
+    async canDeleteItems(dbItems, transaction) {
+        const dependencies = await this.collectDependencies(dbItems, transaction);
+        if (dependencies)
+            throw new ApiException(422, 'entity has dependencies').setErrorBody({
+                type: 'entity-has-dependencies',
+                data: dependencies
+            });
+    }
+    async collectDependencies(dbInstances, transaction) {
+        const dependencyResponses = await dispatch_CollectEntityDependencies.dispatchModuleAsync(this.dbDef.dbKey, dbInstances.map(dbObjectToId), transaction);
+        const filtered = filterInstances(dependencyResponses);
+        if (!filtered.length)
+            return undefined;
+        const merged = filtered.reduce((acc, dependency) => merge(acc, dependency));
+        return _keys(merged.dependencyMap).length ? merged : undefined;
+    }
+    versionUpgrades = {};
+    /**
+     * Upgrades the entity from the given version to the next one (to the same version if the given version is the latest)
+     * @param version - The version we start from
+     * @param processor
+     */
+    registerVersionUpgradeProcessor(version, processor) {
+        this.versionUpgrades[version] = processor;
+    }
+    /**
+     * Check if the collection has at least one item without the latest version. Version[0] is the latest version.
+     */
+    isCollectionUpToDate = async () => {
+        return (await this.query.unManipulatedQuery({
+            limit: 1,
+            where: { _v: { $neq: this.dbDef.versions[0] } }
+        })).length === 0;
+    };
+    upgradeCollection = async (force = false) => {
+        return this.processCollection(async (instances) => {
+            const instancesToSave = await this.upgradeInstances(instances, force);
+            // @ts-ignore
+            await this.collection.upgradeInstances(instancesToSave);
+        });
+    };
+    processCollection = async (processInstances) => {
+        let docs;
+        const itemsCount = this.config.chunksSize;
+        const query = {
+            limit: { page: 0, itemsCount },
+        };
+        while ((docs = await this.collection.doc.unManipulatedQuery(query)).length > 0) {
+            // this is old Backward compatible from before the assertion of unique ids where the doc ref is the _id of the doc
+            const toDelete = docs.filter(doc => {
+                return doc.ref.id !== doc.data._id;
+            });
+            const instances = docs.map(d => d.data);
+            this.logWarning(`Upgrading batch(${query.limit.page}) found instances(${instances.length}) for entity: "${this.dbDef.entityName}" ....`);
+            await processInstances(instances);
+            if (toDelete.length > 0) {
+                this.logWarning(`Need to delete docs: ${toDelete.length} ${this.dbDef.entityName}s ....`);
+                await this.collection.delete.multi.allDocs(toDelete);
+            }
+            query.limit.page++;
+        }
+    };
+    async upgradeInstances(instances, force = false) {
+        let instancesToSave = [];
+        for (let i = this.config.versions.length - 1; i >= 0; i--) {
+            const version = this.config.versions[i];
+            const instancesToUpgrade = instances.filter(instance => instance._v === version);
+            const nextVersion = this.config.versions[i - 1] ?? version;
+            const versionTransition = `${version} => ${nextVersion}`;
+            if (instancesToUpgrade.length === 0) {
+                this.logVerbose(`No instances to upgrade from ${versionTransition}`);
+                continue;
+            }
+            const upgradeProcessor = this.versionUpgrades[version];
+            if (!upgradeProcessor) {
+                this.logVerbose(`Will not update ${instancesToUpgrade.length} instances of version ${versionTransition}`);
+                this.logVerbose(`No upgrade processor for: ${versionTransition}`);
+            }
+            else {
+                this.logVerbose(`Upgrade instances(${instancesToUpgrade.length}): ${versionTransition}`);
+                await upgradeProcessor?.(instancesToUpgrade);
+                instancesToSave.push(...instancesToUpgrade);
+            }
+            instancesToSave = filterDuplicates(instancesToSave);
+            instancesToUpgrade.forEach(instance => instance._v = nextVersion);
+        }
+        return force ? instances : instancesToSave;
+    }
+}

package/modules/http/AxiosHttpModule.d.ts

@@ -0,0 +1,25 @@
+import { ApiDef, BaseHttpModule_Class, BaseHttpRequest, TypedApi } from '@nu-art/thunderstorm-shared';
+import { ApiError_GeneralErrorMessage, ApiErrorResponse, ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+import { AxiosRequestConfig as Axios_RequestConfig } from 'axios';
+export declare class AxiosHttpModule_Class extends BaseHttpModule_Class {
+    private requestOption;
+    init(): void;
+    createRequest<API extends TypedApi<any, any, any, any>>(apiDef: ApiDef<API>, data?: string): AxiosHttpRequest<API>;
+    setRequestOption(requestOption: Axios_RequestConfig): this;
+}
+export declare const AxiosHttpModule: AxiosHttpModule_Class;
+declare class AxiosHttpRequest<API extends TypedApi<any, any, any, any>> extends BaseHttpRequest<API> {
+    private response?;
+    private cancelController;
+    protected status?: number;
+    private requestOption;
+    constructor(requestKey: string, requestData?: string, shouldCompress?: boolean);
+    getStatus(): number;
+    getResponse(): any;
+    protected abortImpl(): void;
+    getErrorResponse(): ApiErrorResponse<ResponseError | ApiError_GeneralErrorMessage>;
+    setRequestOption(requestOption: Axios_RequestConfig): this;
+    protected executeImpl(): Promise<void>;
+    _getResponseHeader(headerKey: string): string | string[] | undefined;
+}
+export {};

package/modules/http/AxiosHttpModule.js

@@ -0,0 +1,132 @@
+/*
+ * 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.
+ */
+// noinspection TypeScriptPreferShortImport
+import { BaseHttpModule_Class, BaseHttpRequest } from '@nu-art/thunderstorm-shared';
+import { BadImplementationException, composeUrl, StaticLogger } from '@nu-art/ts-common';
+// Axios v1+ import style
+import axios, { CanceledError } from 'axios';
+export class AxiosHttpModule_Class extends BaseHttpModule_Class {
+    requestOption = {};
+    init() {
+        super.init();
+        let origin = this.config.origin;
+        if (!origin)
+            return;
+        if (origin?.endsWith('/'))
+            origin = origin.substring(0, origin.length - 1);
+        this.origin = origin;
+    }
+    createRequest(apiDef, data) {
+        const request = new AxiosHttpRequest(apiDef.path, data, this.shouldCompress())
+            .setLogger(this)
+            .setMethod(apiDef.method)
+            .setTimeout(this.timeout)
+            .setRequestOption(this.requestOption)
+            .addHeaders(this.getDefaultHeaders());
+        if (apiDef.fullUrl)
+            request.setUrl(apiDef.fullUrl);
+        else
+            request.setOrigin(apiDef.baseUrl ?? this.origin).setRelativeUrl(apiDef.path);
+        return request;
+    }
+    setRequestOption(requestOption) {
+        this.requestOption = requestOption;
+        return this;
+    }
+}
+export const AxiosHttpModule = new AxiosHttpModule_Class();
+class AxiosHttpRequest extends BaseHttpRequest {
+    response;
+    cancelController;
+    status;
+    requestOption = {};
+    constructor(requestKey, requestData, shouldCompress) {
+        super(requestKey, requestData);
+        this.compress = shouldCompress === undefined ? false : shouldCompress;
+        this.cancelController = new AbortController();
+    }
+    getStatus() {
+        if (!this.status)
+            throw new BadImplementationException('Missing status..');
+        return this.status;
+    }
+    getResponse() {
+        return this.response?.data;
+    }
+    abortImpl() {
+        this.cancelController.abort();
+    }
+    getErrorResponse() {
+        return { debugMessage: this.getResponse() };
+    }
+    setRequestOption(requestOption) {
+        this.requestOption = requestOption;
+        return this;
+    }
+    executeImpl() {
+        const executor = async (resolve, reject) => {
+            if (this.aborted)
+                return resolve();
+            const fullUrl = composeUrl(this.url, this.params);
+            const body = this.body;
+            if (typeof body === 'string')
+                this.addHeader('Content-Length', `${body.length}`);
+            const headers = Object.keys(this.headers).reduce((carry, headerKey) => {
+                carry[headerKey] = this.headers[headerKey].join('; ');
+                return carry;
+            }, {});
+            const options = {
+                ...this.requestOption,
+                url: fullUrl,
+                method: this.method,
+                headers,
+                timeout: this.timeout,
+                signal: this.cancelController.signal, // ✅ Axios v1 cancellation
+            };
+            if (body)
+                options.data = body;
+            if (this.responseType)
+                options.responseType = this.responseType;
+            this.logger?.logDebug(options);
+            try {
+                this.response = await axios.request(options);
+                this.status = this.response?.status ?? 200;
+                return resolve();
+            }
+            catch (e) {
+                // cancellation path in v1
+                if (e instanceof CanceledError || (axios.isCancel && axios.isCancel(e)) || e?.code === 'ERR_CANCELED') {
+                    this.aborted = true;
+                    StaticLogger.logWarning('Api cancelled: ', e.message);
+                }
+                this.response = e?.response;
+                this.status = this.response?.status ?? 500;
+                return reject(e);
+            }
+        };
+        return new Promise(executor);
+    }
+    _getResponseHeader(headerKey) {
+        if (!this.response)
+            throw new BadImplementationException(`axios didn't return yet`);
+        return this.response.headers?.[headerKey];
+    }
+}

package/modules/http/types.d.ts

@@ -0,0 +1,6 @@
+import { AxiosRequestConfig, AxiosResponse, CancelTokenSource, Method, ResponseType } from 'axios';
+export type Axios_RequestConfig = AxiosRequestConfig;
+export type Axios_Response<T = any> = AxiosResponse<T>;
+export type Axios_CancelTokenSource = CancelTokenSource;
+export type Axios_Method = Method;
+export type Axios_ResponseType = ResponseType;

package/modules/http/types.js

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

package/modules/proxy/ModuleBE_RemoteProxy.d.ts

@@ -0,0 +1,35 @@
+import { Module, TS_Object } from '@nu-art/ts-common';
+import { ServerApi } from '../server/server-api.js';
+import { ServerApi_Middleware } from '../../utils/types.js';
+import { TypedApi } from '@nu-art/thunderstorm-shared';
+type ProxyConfig = {
+    extras?: TS_Object;
+    urls: string[];
+    secret: string;
+};
+export type RemoteProxyConfig = {
+    remotes: {
+        [proxyId: string]: ProxyConfig;
+    };
+    secretHeaderName?: string;
+    proxyHeaderName?: string;
+};
+export declare class ModuleBE_RemoteProxy_Class<Config extends RemoteProxyConfig> extends Module<Config> {
+    readonly Middleware: ServerApi_Middleware;
+    private secretHeader;
+    private proxyHeader;
+    protected init(): void;
+    assertSecret(): TS_Object | undefined;
+}
+export declare class ServerApi_Proxy<API extends TypedApi<any, any, any, any>> extends ServerApi<API> {
+    private readonly api;
+    constructor(api: ServerApi<API>);
+    protected process(): Promise<API['R']>;
+}
+export declare class ServerApi_Alternate<API extends TypedApi<any, any, any, any>> extends ServerApi<API> {
+    private readonly api;
+    constructor(api: ServerApi<API>, pathSuffix: string);
+    protected process(): Promise<API['R']>;
+}
+export declare const ModuleBE_RemoteProxy: ModuleBE_RemoteProxy_Class<RemoteProxyConfig>;
+export {};

package/modules/proxy/ModuleBE_RemoteProxy.js

@@ -0,0 +1,86 @@
+/*
+ * 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 { ApiException, ImplementationMissingException, Module } from '@nu-art/ts-common';
+import { ServerApi } from '../server/server-api.js';
+import { HeaderKey } from '../server/HeaderKey.js';
+import { MemKey_HttpRequestPath } from '../server/consts.js';
+export class ModuleBE_RemoteProxy_Class extends Module {
+    Middleware = async () => {
+        ModuleBE_RemoteProxy.assertSecret();
+    };
+    secretHeader;
+    proxyHeader;
+    init() {
+        if (!this.config)
+            throw new ImplementationMissingException('MUST specify config for this module!!');
+        if (!this.config.secretHeaderName)
+            this.config.secretHeaderName = 'x-secret';
+        if (!this.config.proxyHeaderName)
+            this.config.proxyHeaderName = 'x-proxy';
+        this.secretHeader = new HeaderKey(this.config.secretHeaderName);
+        this.proxyHeader = new HeaderKey(this.config.proxyHeaderName);
+    }
+    assertSecret() {
+        if (!this.secretHeader || !this.proxyHeader)
+            throw new ImplementationMissingException('MUST add RemoteProxy to your module list!!!');
+        const secret = this.secretHeader.get();
+        const proxyId = this.proxyHeader.get();
+        const expectedSecret = this.config.remotes[proxyId];
+        if (!proxyId)
+            throw new ApiException(403, `Missing proxy declaration in config for ${proxyId} !!`);
+        if (!secret)
+            throw new ApiException(403, `Missing secret !!`);
+        if (!expectedSecret)
+            throw new ApiException(403, `ProxyId '${proxyId}' is not registered for remote access !!`);
+        if (expectedSecret.secret !== secret)
+            throw new ApiException(403, `Secret does not match for proxyId: ${proxyId}`);
+        const requestUrl = MemKey_HttpRequestPath.get();
+        if (!expectedSecret.urls?.find(urlPattern => requestUrl.match(urlPattern)))
+            throw new ApiException(403, `Requested url '${requestUrl}' is not allowed from proxyId: ${proxyId}`);
+        return expectedSecret.extras;
+    }
+}
+export class ServerApi_Proxy extends ServerApi {
+    api;
+    constructor(api) {
+        // super(api.method, `${api.relativePath}/proxy`);
+        super({ ...api.apiDef, path: `${api.apiDef.path}/proxy` });
+        this.api = api;
+        this.setMiddlewares(ModuleBE_RemoteProxy.Middleware);
+    }
+    async process() {
+        // @ts-ignore
+        return this.api.process();
+    }
+}
+export class ServerApi_Alternate extends ServerApi {
+    api;
+    constructor(api, pathSuffix) {
+        // super(api.method, `${api.relativePath}/proxy`);
+        super({ ...api.apiDef, path: `${api.apiDef.path}/${pathSuffix}` });
+        this.api = api;
+    }
+    async process() {
+        // @ts-ignore
+        return this.api.process();
+    }
+}
+export const ModuleBE_RemoteProxy = new ModuleBE_RemoteProxy_Class();

package/modules/proxy/RemoteProxyCaller.d.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nu-art/ts-common';
+import { BodyApi, QueryApi } from '@nu-art/thunderstorm-shared';
+export type RemoteServerConfig = {
+    secretHeaderName: string;
+    proxyHeaderName: string;
+    proxyId: string;
+    secret: string;
+    url: string;
+};
+export declare class RemoteProxyCaller<Config extends RemoteServerConfig> extends Module<Config> {
+    protected init(): void;
+    protected executeGetRequest: <API extends QueryApi<any, any, any>>(url: string, _params: API["P"], _headers?: {
+        [key: string]: string;
+    }) => Promise<API["R"]>;
+    protected executePostRequest: <API extends BodyApi<any, any, any>>(url: string, body: API["B"], _headers?: {
+        [key: string]: string;
+    }) => Promise<API["R"]>;
+    private executeRequest;
+}