@nu-art/thunderstorm-backend 0.400.5

package/modules/server/server-api.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Created by tacb0ss on 11/07/2018.
+ */
+import { ApiException, Logger, TypedMap, ValidatorTypeResolver } from '@nu-art/ts-common';
+import { Stream } from 'stream';
+import { ExpressRequest, ExpressResponse, ExpressRouter, ServerApi_Middleware } from '../../utils/types.js';
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { ApiDef, BodyApi, HttpMethod_Body, HttpMethod_Query, QueryApi, TypedApi } from '@nu-art/thunderstorm-shared';
+export declare const MemKey_ServerApi: MemKey<ServerApi<any>>;
+export declare abstract class ServerApi<API extends TypedApi<any, any, any, any>> extends Logger {
+    static isDebug: boolean;
+    printResponse: boolean;
+    printRequest: boolean;
+    headersToLog: string[];
+    private url;
+    private middlewares?;
+    private bodyValidator?;
+    private queryValidator?;
+    readonly apiDef: ApiDef<API>;
+    private postCallActions;
+    protected constructor(apiDef: ApiDef<API>, tag?: string);
+    setMiddlewares(...middlewares: ServerApi_Middleware[]): this;
+    addPostCallAction(sideEffect: () => Promise<any>): this;
+    addMiddlewares(...middlewares: ServerApi_Middleware[]): this;
+    addMiddleware(middleware: ServerApi_Middleware): this;
+    addHeaderToLog(...headersToLog: string[]): void;
+    setBodyValidator(bodyValidator: ValidatorTypeResolver<API['B']>): void;
+    setQueryValidator(queryValidator: ValidatorTypeResolver<API['P']>): void;
+    getUrl(): string;
+    dontPrintResponse(): void;
+    dontPrintRequest(): void;
+    setMaxResponsePrintSize(printResponseMaxSizeBytes: number): void;
+    route(router: ExpressRouter, prefixUrl: string): void;
+    private callWrapper;
+    private performPostCallActions;
+    call: (req: ExpressRequest, res: ExpressResponse) => Promise<void>;
+    protected abstract process(): Promise<API['R']>;
+}
+export declare abstract class ServerApi_Get<API extends QueryApi<any, any, any, any, HttpMethod_Query>> extends ServerApi<API> {
+    protected constructor(apiDef: ApiDef<API>);
+}
+export declare abstract class ServerApi_Post<API extends BodyApi<any, any, any, any, HttpMethod_Body>> extends ServerApi<API> {
+    protected constructor(apiDef: ApiDef<API>);
+}
+export declare class ServerApi_Redirect<API extends TypedApi<any, any, any, any>> extends ServerApi<any> {
+    private readonly responseCode;
+    private readonly redirectUrl;
+    constructor(apiDef: ApiDef<API>, responseCode: number, redirectUrl: string);
+    protected process(): Promise<void>;
+}
+export declare class _ServerQueryApi<API extends QueryApi<any, any, any, any, HttpMethod_Query>> extends ServerApi_Get<API> {
+    private readonly action;
+    constructor(apiDef: ApiDef<API>, action: (params: API['P']) => Promise<API['R']>);
+    protected process(): Promise<API['R']>;
+}
+export declare class _ServerBodyApi<API extends BodyApi<any, any, any, any, HttpMethod_Body>> extends ServerApi_Post<API> {
+    private readonly action;
+    constructor(apiDef: ApiDef<API>, action: (params: API['B']) => Promise<API['R']>);
+    protected process(): Promise<API['R']>;
+}
+export declare class ApiResponse {
+    private api;
+    private readonly res;
+    private consumed;
+    private headers?;
+    constructor(api: ServerApi<any>, res: ExpressResponse);
+    setHeader(key: string, value: string): void;
+    addHeader(key: string, value: string): void;
+    isConsumed(): boolean;
+    private consume;
+    stream(responseCode: number, stream: Stream, _headers?: {}): void;
+    private printHeaders;
+    private printResponse;
+    code(responseCode: number, _headers?: any): void;
+    text(responseCode: number, response?: string, _headers?: any): void;
+    html(responseCode: number, response?: string, _headers?: any): void;
+    json(responseCode: number, response?: object | string, _headers?: any): void;
+    private _json;
+    end(responseCode: number, response?: object | string, _headers?: any): void;
+    redirect(responseCode: number, url: string, _headers?: TypedMap<string>): void;
+    exception(exception: ApiException, _headers?: any): void;
+    serverError(error: Error & {
+        cause?: Error;
+    }, _headers?: any): void;
+}

package/modules/server/server-api.js

@@ -0,0 +1,362 @@
+/*
+ * 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.
+ */
+/**
+ * Created by tacb0ss on 11/07/2018.
+ */
+import { _keys, ApiException, BadImplementationException, composeUrl, currentTimeMillis, dispatch_onApplicationException, isErrorOfType, Logger, LogLevel, MimeType_json, MUSTNeverHappenException, Promise_all_sequentially, tsValidate, ValidationException } from '@nu-art/ts-common';
+import { parse } from 'url';
+import { HttpServer } from './HttpServer.js';
+import { MemKey_HttpRequest, MemKey_HttpRequestBody, MemKey_HttpRequestHeaders, MemKey_HttpRequestMethod, MemKey_HttpRequestPath, MemKey_HttpRequestQuery, MemKey_HttpRequestUrl, MemKey_HttpResponse } from './consts.js';
+import { MemKey, MemStorage } from '@nu-art/ts-common/mem-storage/MemStorage';
+export const MemKey_ServerApi = new MemKey('server-api', true);
+export class ServerApi extends Logger {
+    static isDebug;
+    printResponse = true;
+    printRequest = true;
+    headersToLog = [];
+    url;
+    middlewares;
+    bodyValidator;
+    queryValidator;
+    apiDef;
+    postCallActions = [];
+    // readonly method: HttpMethod;
+    // readonly relativePath: string;
+    constructor(apiDef, tag) {
+        super(tag || apiDef.path);
+        this.setMinLevel(ServerApi.isDebug ? LogLevel.Debug : LogLevel.Info);
+        this.apiDef = apiDef;
+    }
+    setMiddlewares(...middlewares) {
+        this.middlewares = middlewares;
+        return this;
+    }
+    addPostCallAction(sideEffect) {
+        this.postCallActions.push(sideEffect);
+        return this;
+    }
+    addMiddlewares(...middlewares) {
+        (this.middlewares || (this.middlewares = [])).push(...middlewares);
+        return this;
+    }
+    addMiddleware(middleware) {
+        (this.middlewares || (this.middlewares = [])).push(middleware);
+        return this;
+    }
+    addHeaderToLog(...headersToLog) {
+        this.headersToLog.push(...headersToLog);
+    }
+    setBodyValidator(bodyValidator) {
+        this.bodyValidator = bodyValidator;
+    }
+    setQueryValidator(queryValidator) {
+        this.queryValidator = queryValidator;
+    }
+    getUrl() {
+        return this.url;
+    }
+    dontPrintResponse() {
+        // @ts-ignore
+        this.printResponse = false;
+    }
+    dontPrintRequest() {
+        // @ts-ignore
+        this.printRequest = false;
+    }
+    setMaxResponsePrintSize(printResponseMaxSizeBytes) {
+        // @ts-ignore
+        this.printResponse = printResponseMaxSizeBytes > -1;
+    }
+    route(router, prefixUrl) {
+        let path = this.apiDef.path;
+        if (!path.startsWith('/'))
+            path = `/${path}`;
+        const fullPath = `${prefixUrl ? prefixUrl : ''}${path}`;
+        this.setTag(fullPath);
+        router[this.apiDef.method](fullPath, this.callWrapper);
+        this.url = `${HttpServer.getBaseUrl()}${fullPath}`;
+    }
+    callWrapper = async (req, res) => {
+        await this.call(req, res);
+        await this.performPostCallActions();
+    };
+    performPostCallActions = async () => {
+        try {
+            await Promise_all_sequentially(this.postCallActions);
+        }
+        catch (e) {
+            this.logError('Error while performing post call actions', e);
+        }
+        finally {
+            this.postCallActions = [];
+        }
+    };
+    call = async (req, res) => {
+        return new MemStorage().init(async () => {
+            const startedAt = currentTimeMillis();
+            const response = new ApiResponse(this, res);
+            this.logInfo(`Intercepted Url: ${req.path}`);
+            if (this.headersToLog.length > 0) {
+                const headers = {};
+                for (const headerName of this.headersToLog) {
+                    headers[headerName] = req.header(headerName);
+                }
+                this.logDebug(`-- Headers: `, headers);
+            }
+            const reqQuery = parse(req.url, true).query;
+            if (reqQuery && typeof reqQuery === 'object' && Object.keys(reqQuery).length)
+                this.logVerbose(`-- Url Params: `, reqQuery);
+            else
+                this.logVerbose(`-- No Params`);
+            const body = req.body;
+            if (body && ((typeof body === 'object')))
+                if (!this.printRequest)
+                    this.logVerbose(`-- Body (Object):  - Not Printing --`);
+                else
+                    this.logVerbose(`-- Body (Object): `, body);
+            else if (body && body.length)
+                if (!this.printRequest)
+                    this.logVerbose(`-- Body (String):  - Not Printing --`);
+                else
+                    this.logVerbose(`-- Body (String): `, body);
+            else
+                this.logVerbose(`-- No Body`);
+            MemKey_ServerApi.set(this);
+            MemKey_HttpRequest.set(req);
+            MemKey_HttpResponse.set(response);
+            MemKey_HttpRequestHeaders.set(req.headers);
+            MemKey_HttpRequestQuery.set(reqQuery);
+            MemKey_HttpRequestUrl.set(req.url);
+            MemKey_HttpRequestMethod.set(this.apiDef.method);
+            MemKey_HttpRequestPath.set(req.path);
+            MemKey_HttpRequestBody.set(body);
+            try {
+                this.bodyValidator && tsValidate(body, this.bodyValidator);
+                this.queryValidator && tsValidate(reqQuery, this.queryValidator);
+                if (this.middlewares)
+                    await Promise_all_sequentially(this.middlewares);
+                const toReturn = await this.process();
+                if (response.isConsumed())
+                    return;
+                if (!toReturn)
+                    return await response.end(200);
+                // TODO need to handle stream and buffers
+                // if (Buffer.isBuffer(toReturn))
+                // 	return response.stream(200, toReturn as Buffer);
+                const responseType = typeof toReturn;
+                if (responseType === 'object')
+                    return await response.json(200, toReturn);
+                if (responseType === 'string' && toReturn.toLowerCase().startsWith('<html'))
+                    return await response.html(200, toReturn);
+                return await response.text(200, toReturn);
+            }
+            catch (err) {
+                let e = err;
+                if (typeof e === 'string')
+                    e = new BadImplementationException(`String was thrown: ${e}`);
+                if (!(e instanceof Error) && typeof e === 'object')
+                    e = new BadImplementationException(`Object instance was thrown: ${JSON.stringify(e)}`);
+                try {
+                    this.logErrorBold(e);
+                }
+                catch (e2) {
+                    this.logErrorBold('Error while handling error on request...', e2);
+                    this.logErrorBold(`Original error thrown: ${JSON.stringify(e)}`);
+                    this.logErrorBold(`-- Someone was stupid... you MUST only throw an Error and not objects or strings!! --`);
+                }
+                if (isErrorOfType(e, ValidationException))
+                    e = new ApiException(400, 'Validator exception', e);
+                if (!isErrorOfType(e, ApiException))
+                    e = new ApiException(500, 'Unexpected server error', e);
+                const apiException = isErrorOfType(e, ApiException);
+                if (!apiException)
+                    throw new MUSTNeverHappenException('MUST NEVER REACH HERE!!!');
+                this.logErrorBold(e.responseBody);
+                try {
+                    await dispatch_onApplicationException.dispatchModuleAsync(e, HttpServer);
+                }
+                catch (e) {
+                    this.logError('Error while handing server error', e);
+                }
+                if (apiException.responseCode === 500)
+                    return response.serverError(apiException);
+                return response.exception(apiException);
+            }
+            finally {
+                this.logInfo(`Url Complete in: ${req.path} - ${currentTimeMillis() - startedAt}ms`);
+            }
+        });
+    };
+}
+export class ServerApi_Get extends ServerApi {
+    constructor(apiDef) {
+        super(apiDef);
+    }
+}
+export class ServerApi_Post extends ServerApi {
+    constructor(apiDef) {
+        super(apiDef);
+    }
+}
+export class ServerApi_Redirect extends ServerApi {
+    responseCode;
+    redirectUrl;
+    constructor(apiDef, responseCode, redirectUrl) {
+        super(apiDef);
+        this.responseCode = responseCode;
+        this.redirectUrl = redirectUrl;
+    }
+    async process() {
+        const url = `${composeUrl(`${HttpServer.getBaseUrl()}${this.redirectUrl}`, MemKey_HttpRequestQuery.get())}`;
+        MemKey_HttpResponse.get().redirect(this.responseCode, url);
+    }
+}
+export class _ServerQueryApi extends ServerApi_Get {
+    action;
+    constructor(apiDef, action) {
+        super(apiDef);
+        this.action = action;
+    }
+    async process() {
+        return this.action(MemKey_HttpRequestQuery.get());
+    }
+}
+export class _ServerBodyApi extends ServerApi_Post {
+    action;
+    constructor(apiDef, action) {
+        super(apiDef);
+        this.action = action;
+    }
+    async process() {
+        return this.action(MemKey_HttpRequestBody.get());
+    }
+}
+function mergeHeaders(headers, _headers) {
+    if (!headers && !_headers)
+        return;
+    return { ...headers ?? {}, ..._headers ?? {} };
+}
+export class ApiResponse {
+    api;
+    res;
+    consumed = false;
+    headers;
+    constructor(api, res) {
+        this.api = api;
+        this.res = res;
+    }
+    setHeader(key, value) {
+        (this.headers || (this.headers = {}))[key] = value;
+    }
+    addHeader(key, value) {
+        (this.headers || (this.headers = {}))[key] = `${this.headers[key] ? `${this.headers[key]};` : ''}${value}`;
+    }
+    isConsumed() {
+        return this.consumed;
+    }
+    consume() {
+        if (this.consumed) {
+            this.api.logError('This API was already satisfied!!', new Error());
+            return;
+        }
+        this.consumed = true;
+    }
+    stream(responseCode, stream, _headers) {
+        const headers = mergeHeaders(this.headers, _headers);
+        this.consume();
+        this.printHeaders(headers);
+        this.res.set(headers);
+        this.res.writeHead(responseCode);
+        stream.pipe(this.res, { end: false });
+        stream.on('end', () => {
+            this.res.end();
+        });
+    }
+    printHeaders(_headers) {
+        const headers = mergeHeaders(this.headers, _headers);
+        if (!headers || _keys(headers).length === 0)
+            return this.api.logVerbose(` -- No response headers`);
+        if (!this.api.printResponse)
+            return this.api.logVerbose(` -- Response (Headers): -- Not Printing --`);
+        this.api.logVerbose(` -- Response (Headers): `, headers);
+    }
+    printResponse(response) {
+        if (!response)
+            return this.api.logVerbose(` -- No response body`);
+        if (!this.api.printResponse)
+            return this.api.logVerbose(` -- Response: -- Not Printing --`);
+        this.api.logVerbose(` -- Response:`, response);
+    }
+    code(responseCode, _headers) {
+        const headers = mergeHeaders(this.headers, _headers);
+        this.printHeaders(headers);
+        this.end(responseCode, '', headers);
+    }
+    text(responseCode, response, _headers) {
+        const headers = mergeHeaders(this.headers, _headers) || {};
+        headers['content-type'] = 'text/plain';
+        this.end(responseCode, response, headers);
+    }
+    html(responseCode, response, _headers) {
+        const headers = mergeHeaders(this.headers, _headers) || {};
+        headers['content-type'] = 'text/html';
+        this.end(responseCode, response, headers);
+    }
+    json(responseCode, response, _headers) {
+        this._json(responseCode, response, _headers);
+    }
+    _json(responseCode, response, _headers) {
+        const headers = mergeHeaders(this.headers, _headers) || {};
+        headers['content-type'] = MimeType_json;
+        this.end(responseCode, response, headers);
+    }
+    end(responseCode, response, _headers) {
+        this.consume();
+        const headers = mergeHeaders(this.headers, _headers);
+        this.printHeaders(headers);
+        this.printResponse(response);
+        this.res.set(headers);
+        this.res.writeHead(responseCode);
+        this.res.end(typeof response !== 'string' ? JSON.stringify(response, null, 2) : response);
+    }
+    redirect(responseCode, url, _headers) {
+        const headers = mergeHeaders(this.headers, _headers) || {};
+        this.consume();
+        _keys(headers).reduce((res, headerKey) => {
+            res.setHeader(headerKey, headers[headerKey]);
+            return res;
+        }, this.res);
+        this.res.redirect(responseCode, url);
+    }
+    exception(exception, _headers) {
+        const headers = mergeHeaders(this.headers, _headers);
+        const responseBody = exception.responseBody;
+        if (!ServerApi.isDebug)
+            delete responseBody.debugMessage;
+        this._json(exception.responseCode, responseBody, headers);
+    }
+    serverError(error, _headers) {
+        const headers = mergeHeaders(this.headers, _headers);
+        const stack = error.cause ? error.cause.stack : error.stack;
+        const message = (error.cause ? error.cause.message : error.message) || '';
+        this.text(500, ServerApi.isDebug && stack ? stack : message, headers);
+    }
+}

package/modules/server/server-errors.d.ts

@@ -0,0 +1,4 @@
+import { StringMap } from '@nu-art/ts-common';
+import { HttpErrorHandler } from '../../utils/types.js';
+export type AppPropsResolver = () => Promise<StringMap>;
+export declare function DefaultApiErrorMessageComposer(headersToAttach?: string[], propsResolver?: AppPropsResolver): HttpErrorHandler;

package/modules/server/server-errors.js

@@ -0,0 +1,79 @@
+/*
+ * 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 { MemKey_HttpRequestBody, MemKey_HttpRequestHeaders, MemKey_HttpRequestQuery, MemKey_HttpRequestUrl } from './consts.js';
+import { __stringify, _keys, ApiException, isErrorOfType, StaticLogger } from '@nu-art/ts-common';
+const _propsResolver = async () => {
+    return {};
+};
+export function DefaultApiErrorMessageComposer(headersToAttach = [], propsResolver = _propsResolver) {
+    return async (error) => {
+        const headers = MemKey_HttpRequestHeaders.get();
+        const query = MemKey_HttpRequestQuery.get();
+        const url = MemKey_HttpRequestUrl.get();
+        const body = MemKey_HttpRequestBody.get();
+        const props = await propsResolver();
+        StaticLogger.logInfo('props: ', props);
+        let slackMessage = '';
+        slackMessage += `${error ? error.responseCode : '000'} - ${url}   \n\n`;
+        const propsAsString = _keys(props).reduce((toRet, key) => {
+            return `${toRet}    ${key}: ${props[key]}\n`;
+        }, '');
+        if (props && Object.keys(props).length > 0)
+            slackMessage += `App Data:\n${propsAsString}\n`;
+        if (error) {
+            const cause = error.cause || error;
+            if (cause && cause.stack) {
+                slackMessage += `${cause.stack
+                    .replace(/\/srv\/dist\//g, '@')
+                    .replace(/\/srv\/node_modules/g, '')
+                    .replace(/\\n/g, `\n`)
+                    .replace(/\\"/g, `"`)
+                    .replace(/\\t/g, '')
+                    .replace(/\/@nu-art/g, '')}\n`;
+                slackMessage += '--------------------------------------------------------------------------------------\n';
+            }
+        }
+        const _headers = headers && _keys(headers).reduce((toRet, key) => {
+            if (headersToAttach.includes(key))
+                toRet[key] = headers[key];
+            return toRet;
+        }, {});
+        if (_headers && Object.keys(_headers).length > 0)
+            slackMessage += `Headers: ${__stringify(_headers)}\n`;
+        else
+            slackMessage += 'Headers: -- No Included Headers --\n';
+        if (query) {
+            if (query && Object.keys(query).length > 0)
+                slackMessage += `Query: ${__stringify(query, true)}\n`;
+            else
+                slackMessage += 'Query: -- No Query --\n';
+        }
+        if (body) {
+            if (body && Object.keys(body).length > 0)
+                slackMessage += `Body: ${__stringify(body)}\n`;
+            else
+                slackMessage += 'Body: -- No Body --\n';
+        }
+        if (isErrorOfType(error.cause || error, ApiException)?.responseBody)
+            slackMessage += `Error: ${__stringify(isErrorOfType(error.cause || error, ApiException).responseBody.error, true)}`;
+        return slackMessage;
+    };
+}

package/modules/sync-env/ModuleBE_SyncEnv.d.ts

@@ -0,0 +1,36 @@
+import { Module, TypedMap } from '@nu-art/ts-common';
+import { Request_FetchFirebaseBackup, Request_FetchFromEnv, Request_GetMetadata, Response_FetchBackupMetadata } from '@nu-art/thunderstorm-shared';
+type Config = {
+    urlMap: TypedMap<string>;
+    sessionMap: TypedMap<TypedMap<string>>;
+    maxBatch: number;
+    shouldBackupBeforeSync?: boolean;
+    allowCleanSync?: boolean;
+    allowSyncEnv?: boolean;
+    allowedEnvsToSyncFrom?: string[];
+};
+export interface OnSyncEnvCompleted {
+    __onSyncEnvCompleted: (env: string, baseUrl: string, requiredHeaders: TypedMap<string>) => void;
+}
+declare class ModuleBE_SyncEnv_Class extends Module<Config> {
+    constructor();
+    init(): void;
+    fetchBackupMetadata: (queryParams: Request_GetMetadata) => Promise<Response_FetchBackupMetadata>;
+    pushToEnv(body: {
+        env: 'dev' | 'prod';
+        moduleName: string;
+        items: any[];
+    }): Promise<void>;
+    createBackup: () => Promise<{
+        pathToBackup: string;
+        backupId: string;
+    } | undefined>;
+    getLatestBackupId: () => Promise<{
+        latestBackupId: string;
+    }>;
+    syncFromEnvBackup: (body: Request_FetchFromEnv) => Promise<void>;
+    private getBackupInfo;
+    syncFirebaseFromBackup: (queryParams: Request_FetchFirebaseBackup) => Promise<void>;
+}
+export declare const ModuleBE_SyncEnv: ModuleBE_SyncEnv_Class;
+export {};