@nu-art/thunderstorm-backend 0.400.5

package/modules/proxy/RemoteProxyCaller.js

@@ -0,0 +1,82 @@
+/*
+ * 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, composeUrl, ImplementationMissingException, MimeType_json, Module, } from '@nu-art/ts-common';
+import { promisifyRequest } from '../../utils/promisify-request.js';
+import { HeaderKey_ContentType } from '../../shared.js';
+export class RemoteProxyCaller extends Module {
+    init() {
+        if (!this.config)
+            throw new ImplementationMissingException('MUST specify config for this module!!');
+        if (!this.config.proxyId)
+            throw new ImplementationMissingException('MUST specify the proxyId for the proxy caller!!');
+        if (!this.config.url)
+            throw new ImplementationMissingException('MUST specify the url for the remote server!!');
+        if (!this.config.secret)
+            throw new ImplementationMissingException('MUST specify the secret for the remote server!!');
+        if (!this.config.secretHeaderName)
+            this.config.secretHeaderName = 'x-secret';
+        if (!this.config.proxyHeaderName)
+            this.config.proxyHeaderName = 'x-proxy';
+    }
+    executeGetRequest = async (url, _params, _headers) => {
+        const proxyRequest = {
+            headers: {
+                ..._headers,
+                [this.config.secretHeaderName]: this.config.secret,
+                [this.config.proxyHeaderName]: this.config.proxyId,
+            },
+            uri: `${composeUrl(`${this.config.url}${url}`, _params)}`,
+            method: 'GET',
+            json: true
+        };
+        return await this.executeRequest(proxyRequest);
+    };
+    executePostRequest = async (url, body, _headers) => {
+        const proxyRequest = {
+            headers: {
+                ..._headers,
+                [HeaderKey_ContentType]: MimeType_json,
+                [this.config.secretHeaderName]: this.config.secret,
+                [this.config.proxyHeaderName]: this.config.proxyId,
+            },
+            json: true,
+            uri: `${composeUrl(`${this.config.url}${url}`)}`,
+            body: body,
+            method: 'POST'
+        };
+        return this.executeRequest(proxyRequest);
+    };
+    executeRequest = async (proxyRequest) => {
+        const response = await promisifyRequest(proxyRequest, false);
+        if (proxyRequest.headers)
+            delete proxyRequest.headers[this.config.secretHeaderName];
+        if (response.statusCode !== 200) {
+            const errorResponse = response.body;
+            if (!errorResponse)
+                throw new ApiException(500, `Extraneous error ${__stringify(response)}, Proxy Request: ${__stringify(proxyRequest, true)}`);
+            const e = new ApiException(response.statusCode, `Redirect proxy error: ${errorResponse.debugMessage} \n Proxy Request: ${__stringify(proxyRequest, true)}`);
+            if (errorResponse.error)
+                e.setErrorBody(errorResponse.error);
+            throw e;
+        }
+        return response.toJSON().body;
+    };
+}

package/modules/proxy/assert-secret-middleware.d.ts

@@ -0,0 +1,2 @@
+import { ServerApi_Middleware } from '../../utils/types.js';
+export declare const AssertSecretMiddleware: ServerApi_Middleware;

package/modules/proxy/assert-secret-middleware.js

@@ -0,0 +1,24 @@
+/*
+ * 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_RemoteProxy } from './ModuleBE_RemoteProxy.js';
+export const AssertSecretMiddleware = async () => {
+    ModuleBE_RemoteProxy.assertSecret();
+};

package/modules/server/HeaderKey.d.ts

@@ -0,0 +1,8 @@
+export declare class HeaderKey {
+    private readonly key;
+    private readonly responseCode;
+    private processor;
+    constructor(key: string, responseCode?: number);
+    get(): string;
+    setProcessor(processor: (value: string) => string): this;
+}

package/modules/server/HeaderKey.js

@@ -0,0 +1,41 @@
+/*
+ * 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_HttpRequest } from './consts.js';
+import { ApiException } from '@nu-art/ts-common';
+export class HeaderKey {
+    key;
+    responseCode;
+    processor = (value) => value;
+    constructor(key, responseCode = 400) {
+        this.key = key.toLowerCase();
+        this.responseCode = responseCode;
+    }
+    get() {
+        const value = MemKey_HttpRequest.get().header(this.key);
+        if (!value)
+            throw new ApiException(this.responseCode, `Missing expected header: ${this.key}`);
+        return this.processor(value);
+    }
+    setProcessor(processor) {
+        this.processor = processor;
+        return this;
+    }
+}

package/modules/server/HttpServer.d.ts

@@ -0,0 +1,41 @@
+import { Module } from '@nu-art/ts-common';
+import { Express, ExpressRequestHandler, HttpErrorHandler } from '../../utils/types.js';
+import { Firebase_ExpressFunction, TBR_ExpressFunctionInterface } from '@nu-art/firebase-backend';
+type ConfigType = {
+    port: number;
+    baseUrl: string;
+    cors: {
+        origins?: string[];
+        methods?: string[];
+        headers: string[];
+        responseHeaders: string[];
+    };
+    ssl: {
+        key: string;
+        cert: string;
+    };
+    bodyParserLimit: number | string;
+};
+export type CustomOrigin = (origin: string | undefined, callback: (err: Error | null, origin?: string) => void) => (boolean | Promise<boolean>);
+export declare class HttpServer_Class extends Module<ConfigType> implements TBR_ExpressFunctionInterface {
+    private static readonly expressMiddleware;
+    errorMessageComposer: HttpErrorHandler;
+    readonly express: Express;
+    private server;
+    private socketId;
+    private customCorsOriginValidator;
+    constructor();
+    getExpress(): Express;
+    getExpressFunction(): Firebase_ExpressFunction;
+    setErrorMessageComposer(errorMessageComposer: HttpErrorHandler): void;
+    static addMiddleware(middleware: ExpressRequestHandler): typeof HttpServer_Class;
+    getBaseUrl(): string;
+    setCustomCorsOriginValidator(validator: CustomOrigin): void;
+    protected init(): Promise<void>;
+    private createServer;
+    startServer(): Promise<void>;
+    private connectImpl;
+    terminate(): Promise<void>;
+}
+export declare const HttpServer: HttpServer_Class;
+export {};

package/modules/server/HttpServer.js

@@ -0,0 +1,223 @@
+/*
+ * 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.
+ */
+/**
+ * Module dependencies.
+ */
+import { createServer as createHttpServer } from 'http';
+import { createServer as createHttpsServer } from 'https';
+import * as fs from 'fs';
+import { addItemToArray, LogLevel, Module } from '@nu-art/ts-common';
+import express from 'express';
+import { DefaultApiErrorMessageComposer } from './server-errors.js';
+import { Firebase_ExpressFunction } from '@nu-art/firebase-backend';
+import { ServerApi } from './server-api.js';
+import compression from 'compression';
+import cors from 'cors';
+const ALL_Methods = [
+    'GET',
+    'PUT',
+    'PATCH',
+    'POST',
+    'DELETE',
+    'OPTIONS'
+];
+const DefaultHeaders = [
+    'content-type',
+    'content-encoding',
+];
+export class HttpServer_Class extends Module {
+    static expressMiddleware = [];
+    errorMessageComposer = DefaultApiErrorMessageComposer();
+    express;
+    server;
+    socketId = 0;
+    customCorsOriginValidator;
+    constructor() {
+        super('http-server');
+        // this.express = express();
+    }
+    getExpress() {
+        if (this.express)
+            return this.express;
+        // Originally Express was created in the constructor, and this class is a singleton module, meaning Express is created in the import part of the file that starts Storm.
+        // Express now is initialized during the builder of Storm, instead of the import stage of the file.
+        // @ts-ignore
+        return this.express = express();
+    }
+    getExpressFunction() {
+        return new Firebase_ExpressFunction(this.getExpress());
+    }
+    setErrorMessageComposer(errorMessageComposer) {
+        this.errorMessageComposer = errorMessageComposer;
+    }
+    static addMiddleware(middleware) {
+        HttpServer_Class.expressMiddleware.push(middleware);
+        return this;
+    }
+    getBaseUrl() {
+        return this.config.baseUrl;
+    }
+    setCustomCorsOriginValidator(validator) {
+        this.customCorsOriginValidator = validator;
+    }
+    async init() {
+        this.setMinLevel(ServerApi.isDebug ? LogLevel.Verbose : LogLevel.Info);
+        const baseUrl = this.config.baseUrl;
+        if (baseUrl) {
+            if (baseUrl.endsWith('/'))
+                this.config.baseUrl = baseUrl.substring(0, baseUrl.length - 1);
+            this.config.baseUrl = baseUrl.replace(/\/\//g, '/');
+        }
+        this.getExpress().use((req, res, next) => {
+            if (req)
+                req.url = req.url.replace(/\/\//g, '/');
+            next();
+        });
+        const parserLimit = this.config.bodyParserLimit;
+        if (parserLimit)
+            this.getExpress().use(express.json({ limit: parserLimit }));
+        this.getExpress().use(compression());
+        for (const middleware of HttpServer_Class.expressMiddleware) {
+            this.getExpress().use(middleware);
+        }
+        const _cors = this.config.cors || {};
+        _cors.headers = DefaultHeaders.reduce((toRet, item) => {
+            if (!toRet.includes(item))
+                addItemToArray(toRet, item);
+            return toRet;
+        }, _cors.headers || []);
+        const resolveCorsOrigin = (origin) => {
+            let _origin;
+            if (!origin)
+                return;
+            if (typeof origin === 'string')
+                _origin = origin;
+            else
+                _origin = origin[0];
+            if (!_cors.origins)
+                return _origin;
+            for (const allowedOrigin of _cors.origins) {
+                if (allowedOrigin === _origin.toLowerCase() ||
+                    (allowedOrigin.includes('*') && new RegExp(`^${allowedOrigin.replace(/\*/g, '.*')}$`).test(_origin.toLowerCase()))) {
+                    return _origin;
+                }
+            }
+        };
+        this.getExpress().use(cors({
+            origin: async (origin, callback) => {
+                if (!origin)
+                    return callback(null);
+                const resolvedOrigin = resolveCorsOrigin(origin);
+                if (!resolvedOrigin)
+                    return callback(new Error(`CORS issue!!!\n Origin: '${origin}' does not exist in config: ${JSON.stringify(_cors.origins)}`), undefined);
+                if (this.customCorsOriginValidator && !(await this.customCorsOriginValidator?.(origin, callback))) {
+                    return callback(new Error(`CORS issue!!!\n Origin: '${origin}' is not valid`), undefined);
+                }
+                callback(null, resolvedOrigin);
+            },
+            methods: _cors.methods || ALL_Methods,
+            allowedHeaders: _cors.headers,
+            exposedHeaders: _cors.responseHeaders,
+        }));
+        this.getExpress().options('*', (req, res) => {
+            res.end();
+        });
+    }
+    createServer() {
+        const ssl = this.config.ssl;
+        if (!ssl) {
+            this.logDebug('starting HTTP server');
+            return createHttpServer(this.getExpress());
+        }
+        this.logDebug('starting HTTPS server');
+        let key = ssl.key;
+        if (!ssl.key.startsWith('-----BEGIN'))
+            key = fs.readFileSync(ssl.key, 'utf8');
+        let cert = ssl.cert;
+        if (!ssl.cert.startsWith('-----BEGIN'))
+            cert = fs.readFileSync(ssl.cert, 'utf8');
+        const options = {
+            key: key,
+            cert: cert,
+            rejectUnauthorized: false,
+            requestCert: false,
+        };
+        return createHttpsServer(options, this.getExpress());
+    }
+    async startServer() {
+        return new Promise((resolve, rejected) => {
+            this.connectImpl((err) => {
+                if (err)
+                    return rejected(err);
+                resolve();
+            });
+        });
+    }
+    connectImpl(onCompletion) {
+        this.server = this.createServer();
+        this.server.listen(this.config.port);
+        this.server.on('connection', (socket) => {
+            this.logInfo(`Got a new connection(${this.socketId++}): ${socket}`);
+            // Extend socket lifetime for demo purposes
+            // socket.setTimeout(4000);
+        });
+        this.server.on('error', (error) => {
+            switch (error.code) {
+                case 'EACCES':
+                    this.logErrorBold(`Server port: ${this.config.port} requires elevated privileges`);
+                    process.exit(1);
+                    break;
+                case 'EADDRINUSE':
+                    this.logErrorBold(`Unable to start server port(${this.config.port}) is already in use!`);
+                    onCompletion(error);
+                    break;
+                default:
+                    this.logErrorBold(`Error starting server... unknown state: ${error.code}`);
+                    onCompletion(error);
+                    return;
+            }
+            if (error.syscall !== 'listen') {
+                onCompletion(error);
+                return;
+            }
+        });
+        this.server.on('listening', () => {
+            const address = this.server.address();
+            // Explicit check has to be made due to address.port
+            if (!address) {
+                this.logDebug(`Exiting !!`);
+                process.exit(1);
+                return;
+            }
+            this.logDebug(`Server is listening on ${(typeof address === 'string' ? `pipe: ${JSON.stringify(address)}` : `port: ${address.port}`)}`);
+            onCompletion();
+        });
+    }
+    terminate() {
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.logInfo('Server is terminated!');
+                resolve();
+            });
+        });
+    }
+}
+export const HttpServer = new HttpServer_Class();

package/modules/server/consts.d.ts

@@ -0,0 +1,13 @@
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+import { QueryParams } from '@nu-art/thunderstorm-shared';
+import { IncomingHttpHeaders } from 'http';
+import { ExpressRequest } from '../../utils/types.js';
+import { ApiResponse } from './server-api.js';
+export declare const MemKey_HttpRequest: MemKey<ExpressRequest>;
+export declare const MemKey_HttpResponse: MemKey<ApiResponse>;
+export declare const MemKey_HttpRequestHeaders: MemKey<IncomingHttpHeaders>;
+export declare const MemKey_HttpRequestBody: MemKey<any>;
+export declare const MemKey_HttpRequestQuery: MemKey<QueryParams>;
+export declare const MemKey_HttpRequestUrl: MemKey<string>;
+export declare const MemKey_HttpRequestPath: MemKey<string>;
+export declare const MemKey_HttpRequestMethod: MemKey<any>;

package/modules/server/consts.js

@@ -0,0 +1,9 @@
+import { MemKey } from '@nu-art/ts-common/mem-storage/MemStorage';
+export const MemKey_HttpRequest = new MemKey('http-request', true);
+export const MemKey_HttpResponse = new MemKey('http-response', true);
+export const MemKey_HttpRequestHeaders = new MemKey('http-request--incoming-headers', true);
+export const MemKey_HttpRequestBody = new MemKey('http-request--incoming-body', true);
+export const MemKey_HttpRequestQuery = new MemKey('http-request--query', true);
+export const MemKey_HttpRequestUrl = new MemKey('http-request--url', true);
+export const MemKey_HttpRequestPath = new MemKey('http-request--original-url', true);
+export const MemKey_HttpRequestMethod = new MemKey('http-request--method', true);

package/modules/server/route-resolvers/RouteResolver_Dummy.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '@nu-art/ts-common';
+export declare class RouteResolver_Dummy extends Logger {
+    constructor();
+    resolveApi(): void;
+    printRoutes(): void;
+    resolveRoutes: () => never[];
+}

package/modules/server/route-resolvers/RouteResolver_Dummy.js

@@ -0,0 +1,34 @@
+/*
+ * 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 { Logger, LogLevel } from '@nu-art/ts-common';
+export class RouteResolver_Dummy extends Logger {
+    constructor() {
+        super();
+        this.setMinLevel(LogLevel.Debug);
+    }
+    resolveApi() {
+    }
+    printRoutes() {
+    }
+    resolveRoutes = () => {
+        return [];
+    };
+}

package/modules/server/route-resolvers/RouteResolver_ModulePath.d.ts

@@ -0,0 +1,22 @@
+import { Express } from 'express';
+import { ServerApi_Middleware } from '../../../utils/types.js';
+import { Logger } from '@nu-art/ts-common';
+import { ApiDef } from '@nu-art/thunderstorm-shared';
+export type HttpRoute = {
+    methods: string[];
+    path: string;
+};
+export type MiddlewareConfig = {
+    filter: (apiDef: ApiDef<any>) => boolean;
+    middlewares: ServerApi_Middleware[];
+};
+export declare class RouteResolver_ModulePath extends Logger {
+    readonly express: Express;
+    private middlewares;
+    private initialPath;
+    constructor(express: Express, initialPath: string);
+    resolveApi(): void;
+    printRoutes(): void;
+    addMiddleware(filter?: (apiDef: ApiDef<any>) => boolean, ...middlewares: ServerApi_Middleware[]): void;
+    resolveRoutes: () => HttpRoute[];
+}

package/modules/server/route-resolvers/RouteResolver_ModulePath.js

@@ -0,0 +1,84 @@
+/*
+ * 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 { asArray, Logger, LogLevel, MUSTNeverHappenException, RuntimeModules } from '@nu-art/ts-common';
+export class RouteResolver_ModulePath extends Logger {
+    express;
+    middlewares = [];
+    initialPath;
+    constructor(express, initialPath) {
+        super();
+        this.express = express;
+        this.initialPath = !process.env.GCLOUD_PROJECT ? initialPath : '';
+        this.setMinLevel(LogLevel.Debug);
+    }
+    resolveApi() {
+        const modules = RuntimeModules().filter((module) => !!module.useRoutes);
+        //Filter Api modules
+        const routes = [];
+        for (const module of modules) {
+            this.logInfo(module.getName());
+            const _routes = module.useRoutes();
+            routes.push(..._routes);
+        }
+        // console.log(routes);
+        routes.forEach(api => {
+            if (!api.addMiddlewares)
+                throw new MUSTNeverHappenException(`Missing api.middleware for`);
+            this.middlewares.filter(config => config.filter(api.apiDef) && api.addMiddlewares(...config.middlewares));
+            api.route(this.express, this.initialPath);
+        });
+        this.express.all('*', (req, res, next) => {
+            this.logErrorBold(`Received unknown url with path: '${req.path}' - url: '${req.url}'`);
+            res.status(404).send(`The requested URL '${req.url}' was not found on this server.`);
+        });
+    }
+    printRoutes() {
+        const routes = this.resolveRoutes();
+        routes.forEach(route => {
+            const methodString = JSON.stringify(route.methods).padEnd(11, ' ');
+            return this.logInfo(`${methodString} ${this.initialPath}${route.path}`);
+        });
+    }
+    addMiddleware(filter = () => true, ...middlewares) {
+        this.middlewares.push({ middlewares, filter });
+    }
+    resolveRoutes = () => {
+        const resolveStack = (_stack) => {
+            return _stack.map((layer) => {
+                if (layer.route && typeof layer.route.path === 'string') {
+                    let methods = Object.keys(layer.route.methods);
+                    if (methods.length > 20)
+                        methods = ['ALL'];
+                    return { methods: methods, path: layer.route.path };
+                }
+                if (layer.name === 'router')
+                    return resolveStack(layer.handle.stack);
+            }).filter(route => route);
+        };
+        const routes = resolveStack(this.express._router.stack);
+        return routes.reduce((toRet, route) => {
+            const toAdd = asArray(route);
+            toRet.push(...toAdd);
+            //addAllItemToArray(toRet, toAdd);
+            return toRet;
+        }, []);
+    };
+}

package/modules/server/route-resolvers/index.d.ts

@@ -0,0 +1,7 @@
+import { HttpRoute } from './RouteResolver_ModulePath.js';
+export * from './RouteResolver_ModulePath.js';
+export type RouteResolver = {
+    resolveApi: (urlPrefix?: string) => void;
+    printRoutes: (urlPrefix?: string) => void;
+    resolveRoutes: (urlPrefix?: string) => HttpRoute[];
+};

package/modules/server/route-resolvers/index.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 * from './RouteResolver_ModulePath.js';