@zerooneit/expressive-tea 1.2.3 → 1.3.0-beta.2

package/engines/teapot/index.js

@@ -0,0 +1,157 @@
+"use strict";
+var TeapotEngine_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const inversify_1 = require("inversify");
+const ProxyRoute_1 = require("../../classes/ProxyRoute");
+const MetaData_1 = require("../../classes/MetaData");
+const constants_1 = require("../../libs/constants");
+const teapot_helper_1 = require("../../helpers/teapot-helper");
+let TeapotEngine = TeapotEngine_1 = class TeapotEngine {
+    constructor(ctx, server, serverSecure, settings) {
+        this.clients = new Map();
+        this.registeredRoute = new Map();
+        this.settings = settings;
+        this.context = ctx;
+        this.server = server;
+        this.serverSecure = serverSecure;
+        this.isActive = MetaData_1.default.get(constants_1.ASSIGN_TEAPOT_KEY, this.context, 'isTeapotActive');
+        this.teapotSettings = MetaData_1.default.get(constants_1.ASSIGN_TEAPOT_KEY, this.context);
+        if (!this.isActive) {
+            return;
+        }
+        const { publicKey, privateKey } = teapot_helper_1.default.generateKeys(this.teapotSettings.serverKey);
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+        this.serverSignature = teapot_helper_1.default.sign(this.teapotSettings.clientKey, privateKey, this.teapotSettings.serverKey);
+        this.socketServer = require('socket.io')({
+            path: '/teapot',
+            wsEngine: require('eiows').Server,
+            cookie: false
+        });
+    }
+    static header(teapotSettings) {
+        console.log(chalk.white.bold('Teapot Engine is initializing...'));
+        console.log(chalk `
+             {white.bold ;,'}
+     {green _o_}    {white.bold ;:;'}
+ {blue.bold ,-.}{green '---\`}{blue.bold .__} {white.bold ; }
+{blue.bold ((j\`=====',-'}
+ {blue.bold \`-\\     /}
+    {blue.bold \`-=-'}
+
+{white Please assign the next} {white.bold Client Key:} {magenta.bold ${teapotSettings.clientKey}} {white to all your}
+{yellow.bold Teacups} {white and do not share the key with anyone}
+
+{yellow.bold NOTICE:}
+All Communication are encrypted to ensure intruder can not connected, however, please does not share any sensitive data like keys or passwords to avoid security issues.
+  `);
+    }
+    registerTeacup(teacup) {
+        console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {grey.bold Connected}`);
+        teacup.emit('handshake', {
+            key: Buffer.from(this.publicKey).toString('base64'),
+            signature: this.serverSignature.toString('base64')
+        });
+        teacup.on('handshake', this.acceptedHandshake.bind(teacup, this));
+        teacup.on('register', this.registered.bind(teacup, this));
+        teacup.on('disconnect', this.disconnected.bind(teacup, this));
+    }
+    acceptedHandshake(ctx, data) {
+        const self = this;
+        try {
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${self.id}}]: {yellow.bold Start Verification}`);
+            const clientPublicKey = Buffer.from(data.key, 'base64').toString('ascii');
+            const clientSignature = Buffer.from(data.signature, 'base64');
+            if (teapot_helper_1.default.verify(ctx.teapotSettings.clientKey, clientPublicKey, clientSignature)) {
+                console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${self.id}}]: {green.bold Verified correctly}`);
+                ctx.clients.set(self.id, {
+                    publicKey: clientPublicKey,
+                    signature: clientSignature
+                });
+                self.emit('accepted', teapot_helper_1.default.encrypt({
+                    signature: ctx.serverSignature.toString('base64')
+                }, clientSignature.slice(0, 32)));
+                return;
+            }
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${self.id}}]: Failed to verify and will be disconnected...`);
+            self.disconnect();
+        }
+        catch (e) {
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${self.id}}]: Failed wiht next message: ${e.message}`);
+            self.disconnect();
+        }
+    }
+    registered(ctx, data) {
+        const self = this;
+        try {
+            const message = teapot_helper_1.default.decrypt(data, ctx.serverSignature.slice(0, 32));
+            let proxyRoute;
+            if (ctx.registeredRoute.has(message.mountTo)) {
+                proxyRoute = ctx.registeredRoute.get(message.mountTo);
+                proxyRoute.registerServer(message.address, self.id);
+            }
+            else {
+                proxyRoute = new ProxyRoute_1.default(message.mountTo);
+                proxyRoute.registerServer(message.address, self.id);
+                ctx.registeredRoute.set(message.mountTo, proxyRoute);
+                ctx.context.getApplication().use(message.mountTo, (req, res, next) => {
+                    const router = proxyRoute.registerRoute();
+                    if (!proxyRoute.hasClients()) {
+                        return next();
+                    }
+                    return router(req, res, next);
+                });
+            }
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${self.id}}] {blue.bold <${message.address}>} <--> {white.bold ${message.mountTo}}`);
+        }
+        catch (e) {
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${self.id}}: Failed wiht next message: ${e.message}`);
+        }
+    }
+    removeFromRoutes(routes = [], id) {
+        routes.forEach(route => {
+            const proxyRoute = this.registeredRoute.get(route);
+            proxyRoute.unregisterServer(id);
+        });
+    }
+    findClientInRoutes(teacupId) {
+        const routes = [];
+        this.registeredRoute.forEach((proxyRoute, route) => {
+            if (proxyRoute.isClientOnRoute(teacupId)) {
+                routes.push(route);
+            }
+        });
+        return routes;
+    }
+    disconnected(ctx, reason) {
+        const self = this;
+        try {
+            const routes = ctx.findClientInRoutes(self.id);
+            ctx.removeFromRoutes(routes, self.id);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${self.id}}]: Got disconnected by ${reason}`);
+        }
+        catch (e) {
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${self.id}}: Failed wiht next message: ${e.message}`);
+        }
+    }
+    async start() {
+        if (!this.isActive) {
+            return;
+        }
+        TeapotEngine_1.header(this.teapotSettings);
+        this.socketServer.on('connection', this.registerTeacup.bind(this));
+        this.socketServer.listen(this.server);
+    }
+};
+TeapotEngine = TeapotEngine_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)('context')),
+    tslib_1.__param(1, (0, inversify_1.inject)('server')),
+    tslib_1.__param(2, (0, inversify_1.inject)('secureServer')),
+    tslib_1.__param(2, (0, inversify_1.optional)()),
+    tslib_1.__param(3, (0, inversify_1.inject)('settings')),
+    tslib_1.__metadata("design:paramtypes", [Object, Object, Object, Object])
+], TeapotEngine);
+exports.default = TeapotEngine;

package/engines/websocket/index.d.ts

@@ -0,0 +1,9 @@
+export default class WebsocketEngine {
+    private readonly settings;
+    private readonly server;
+    private readonly serverSecure?;
+    canStart: boolean;
+    isDetached: boolean;
+    constructor(server: any, serverSecure: any, settings: any);
+    init(): Promise<void>;
+}

package/engines/websocket/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const WebsocketService_1 = require("../../services/WebsocketService");
+const WebSocket = require("ws");
+const inversify_1 = require("inversify");
+let WebsocketEngine = class WebsocketEngine {
+    constructor(server, serverSecure, settings) {
+        this.canStart = false;
+        this.isDetached = false;
+        this.settings = settings;
+        this.server = server;
+        this.serverSecure = serverSecure;
+        this.canStart = this.settings.get('startWebsocket');
+        this.isDetached = this.settings.get('detachWebsocket');
+    }
+    async init() {
+        if (this.canStart) {
+            WebsocketService_1.default.init();
+            WebsocketService_1.default.getInstance().setWebSocket(new WebSocket.Server(this.isDetached ? { noServer: true } : { server: this.server }));
+            if (this.serverSecure) {
+                WebsocketService_1.default.getInstance().setSecureWebsocket(new WebSocket.Server(this.isDetached ? { noServer: true } : { server: this.serverSecure }));
+            }
+            WebsocketService_1.default.getInstance().setHttpServer(this.server);
+            WebsocketService_1.default.getInstance().setHttpServer(this.serverSecure);
+        }
+    }
+};
+WebsocketEngine = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)('server')),
+    tslib_1.__param(1, (0, inversify_1.inject)('secureServer')),
+    tslib_1.__param(1, (0, inversify_1.optional)()),
+    tslib_1.__param(2, (0, inversify_1.inject)('settings')),
+    tslib_1.__metadata("design:paramtypes", [Object, Object, Object])
+], WebsocketEngine);
+exports.default = WebsocketEngine;

package/helpers/boot-helper.d.ts

@@ -0,0 +1,7 @@
+import { BOOT_STAGES } from '../libs/constants';
+import { Express } from 'express';
+import Boot from '../classes/Boot';
+export declare function resolveStage(stage: BOOT_STAGES, ctx: Boot, server: Express, ...extraArgs: unknown[]): Promise<void>;
+export declare function resolveDirectives(instance: typeof Boot | Boot, server: Express): Promise<void>;
+export declare function resolveStatic(instance: typeof Boot | Boot, server: Express): Promise<void>;
+export declare function resolveProxy(ProxyContainer: any, server: Express): Promise<void>;

package/helpers/boot-helper.js

@@ -0,0 +1,78 @@
+"use strict";
+// tslint:disable:no-duplicate-imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProxy = exports.resolveStatic = exports.resolveDirectives = exports.resolveStage = void 0;
+const constants_1 = require("../libs/constants");
+const express = require("express");
+const MetaData_1 = require("../classes/MetaData");
+const object_helper_1 = require("./object-helper");
+const BootLoaderExceptions_1 = require("../exceptions/BootLoaderExceptions");
+async function resolveStage(stage, ctx, server, ...extraArgs) {
+    try {
+        await bootloaderResolve(stage, server, ctx, ...extraArgs);
+        if (stage === constants_1.BOOT_STAGES.APPLICATION) {
+            await resolveModules(ctx, server);
+        }
+    }
+    catch (e) {
+        if (checkIfStageFails(e)) {
+            throw e;
+        }
+    }
+}
+exports.resolveStage = resolveStage;
+async function resolveDirectives(instance, server) {
+    const registeredDirectives = MetaData_1.default.get(constants_1.REGISTERED_DIRECTIVES_KEY, (0, object_helper_1.getClass)(instance)) || [];
+    registeredDirectives.forEach((options) => {
+        server.set.call(server, options.name, ...options.settings);
+    });
+}
+exports.resolveDirectives = resolveDirectives;
+async function resolveStatic(instance, server) {
+    const registeredStatic = MetaData_1.default.get(constants_1.REGISTERED_STATIC_KEY, (0, object_helper_1.getClass)(instance)) || [];
+    registeredStatic.forEach((staticOptions) => {
+        if (staticOptions.virtual) {
+            server.use(staticOptions.virtual, express.static(staticOptions.root, staticOptions.options));
+        }
+        else {
+            server.use(express.static(staticOptions.root, staticOptions.options));
+        }
+    });
+}
+exports.resolveStatic = resolveStatic;
+async function resolveProxy(ProxyContainer, server) {
+    const proxyContainer = new ProxyContainer();
+    proxyContainer.__register(server);
+}
+exports.resolveProxy = resolveProxy;
+async function resolveModules(instance, server) {
+    const registeredModules = MetaData_1.default.get(constants_1.REGISTERED_MODULE_KEY, instance, 'start') || [];
+    registeredModules.forEach(Module => {
+        const moduleInstance = new Module();
+        moduleInstance.__register(server);
+    });
+}
+async function bootloaderResolve(STAGE, server, instance, ...args) {
+    const bootLoader = MetaData_1.default.get(constants_1.BOOT_STAGES_KEY, (0, object_helper_1.getClass)(instance)) || constants_1.STAGES_INIT;
+    for (const loader of bootLoader[STAGE] || []) {
+        try {
+            await selectLoaderType(loader, server, ...args);
+        }
+        catch (e) {
+            shouldFailIfRequire(e, loader);
+        }
+    }
+}
+async function selectLoaderType(loader, server, ...args) {
+    return loader.method(server, ...args);
+}
+function checkIfStageFails(e) {
+    return !(e instanceof BootLoaderExceptions_1.BootLoaderSoftExceptions);
+}
+function shouldFailIfRequire(e, loader) {
+    const failMessage = `Failed [${loader.name}]: ${e.message}`;
+    if (!loader || loader.required) {
+        throw new BootLoaderExceptions_1.BootLoaderRequiredExceptions(failMessage);
+    }
+    throw new BootLoaderExceptions_1.BootLoaderSoftExceptions(`${failMessage} and will be not enabled`);
+}

package/helpers/object-helper.d.ts

@@ -163,4 +163,5 @@ export declare function descriptorOf(target: any, propertyKey: string): Property
  * @ignore
  */
 export declare function prototypeOf(target: any): any;
+export declare function getOwnArgumentNames(fn: Function): string[];
 export declare function isAsyncFunction(fn: () => any): boolean;

package/helpers/object-helper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAsyncFunction = exports.prototypeOf = exports.descriptorOf = exports.nameOfSymbol = exports.nameOfClass = exports.nameOf = exports.ancestorsOf = exports.getInheritedClass = exports.isPromise = exports.isEmpty = exports.isClass = exports.isObject = exports.isDate = exports.isCollection = exports.isArrayOrArrayClass = exports.isArray = exports.isBoolean = exports.isNumber = exports.isString = exports.primitiveOf = exports.isPrimitiveOrPrimitiveClass = exports.getClassOrSymbol = exports.classOf = exports.getClass = exports.getConstructor = void 0;
+exports.isAsyncFunction = exports.getOwnArgumentNames = exports.prototypeOf = exports.descriptorOf = exports.nameOfSymbol = exports.nameOfClass = exports.nameOf = exports.ancestorsOf = exports.getInheritedClass = exports.isPromise = exports.isEmpty = exports.isClass = exports.isObject = exports.isDate = exports.isCollection = exports.isArrayOrArrayClass = exports.isArray = exports.isBoolean = exports.isNumber = exports.isString = exports.primitiveOf = exports.isPrimitiveOrPrimitiveClass = exports.getClassOrSymbol = exports.classOf = exports.getClass = exports.getConstructor = void 0;
 /* istanbul ignore file */
 /**
  * Get the provide constructor.
@@ -278,6 +278,14 @@ function prototypeOf(target) {
     return classOf(target) === target ? target.prototype : target;
 }
 exports.prototypeOf = prototypeOf;
+const argumentsRegExp = /\(([\s\S]*?)\)/;
+const replaceRegExp = /[ ,\n\r\t]+/;
+// tslint:disable-next-line:ban-types
+function getOwnArgumentNames(fn) {
+    const fnArguments = argumentsRegExp.exec(fn.toString())[1].trim();
+    return fnArguments && fnArguments.length ? fnArguments.split(replaceRegExp) : [];
+}
+exports.getOwnArgumentNames = getOwnArgumentNames;
 function isAsyncFunction(fn) {
     return fn.constructor.name === 'AsyncFunction' || fn.constructor.name.includes('__awaiter');
 }

package/helpers/server.d.ts

@@ -1,7 +1,9 @@
 import { NextFunction, Request, Response } from 'express';
 import { ExpressiveTeaAnnotations, ExpressiveTeaArgumentOptions } from '../libs/interfaces';
 export declare function autoResponse(request: Request, response: Response, annotations: ExpressiveTeaAnnotations[], responseResult?: any): void;
-export declare function mapArguments(decoratedArguments: ExpressiveTeaArgumentOptions[], request: Request, response: Response, next: NextFunction): unknown[];
-export declare function extractParameters(target: unknown, args?: string | string[]): any;
-export declare function generateRoute(route: string, verb: string): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
-export declare function router(verb: string, route: string, target: any, handler: (...args: any[]) => void | any | Promise<any>, propertyKey: string | symbol): void;
+export declare function executeRequest(request: Request, response: Response, next: NextFunction): Promise<void>;
+export declare function mapArguments(decoratedArguments: ExpressiveTeaArgumentOptions[], request: Request, response: Response, next: NextFunction, introspectedArgs?: string[]): unknown[];
+export declare function extractParameters(target: unknown, args?: string | string[], propertyName?: string | symbol): any;
+export declare function generateRoute(route: string, verb: string, ...settings: any): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+export declare function router(verb: string, route: string, target: any, handler: (...args: any[]) => void | any | Promise<any>, propertyKey: string | symbol, settings?: any): void;
+export declare function fileSettings(): any;

package/helpers/server.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.router = exports.generateRoute = exports.extractParameters = exports.mapArguments = exports.autoResponse = void 0;
+exports.fileSettings = exports.router = exports.generateRoute = exports.extractParameters = exports.mapArguments = exports.executeRequest = exports.autoResponse = void 0;
 const lodash_1 = require("lodash");
 const MetaData_1 = require("../classes/MetaData");
 const constants_1 = require("../libs/constants");
+const RequestExceptions_1 = require("../exceptions/RequestExceptions");
+const object_helper_1 = require("./object-helper");
+const fs = require("fs");
 function autoResponse(request, response, annotations, responseResult) {
     const view = (0, lodash_1.find)(annotations, { type: 'view' });
     if (view) {
@@ -12,10 +15,31 @@ function autoResponse(request, response, annotations, responseResult) {
     response.send((0, lodash_1.isNumber)(responseResult) ? responseResult.toString() : responseResult);
 }
 exports.autoResponse = autoResponse;
-function mapArguments(decoratedArguments, request, response, next) {
+async function executeRequest(request, response, next) {
+    try {
+        let isNextUsed = false;
+        const nextWrapper = () => (error) => {
+            next(error);
+            isNextUsed = true;
+        };
+        const result = await this.options.handler.apply(this.self, mapArguments(this.decoratedArguments, request, response, nextWrapper(), (0, object_helper_1.getOwnArgumentNames)(this.options.handler)));
+        if (!response.headersSent && !isNextUsed) {
+            autoResponse(request, response, this.annotations, result);
+        }
+    }
+    catch (e) {
+        if (e instanceof RequestExceptions_1.GenericRequestException) {
+            return next(e);
+        }
+        next(new RequestExceptions_1.GenericRequestException(e.message || 'System Error'));
+    }
+}
+exports.executeRequest = executeRequest;
+function mapArguments(decoratedArguments, request, response, next, introspectedArgs = []) {
     return (0, lodash_1.chain)(decoratedArguments)
         .sortBy('index')
         .map((argument) => {
+        const argumentKey = (0, lodash_1.get)(introspectedArgs, argument.index);
         switch (argument.type) {
             case constants_1.ARGUMENT_TYPES.REQUEST:
                 return request;
@@ -24,11 +48,11 @@ function mapArguments(decoratedArguments, request, response, next) {
             case constants_1.ARGUMENT_TYPES.NEXT:
                 return next;
             case constants_1.ARGUMENT_TYPES.QUERY:
-                return extractParameters(request.query, argument.arguments);
+                return extractParameters(request.query, argument.arguments, argumentKey);
             case constants_1.ARGUMENT_TYPES.BODY:
-                return extractParameters(request.body, argument.arguments);
+                return extractParameters(request.body, argument.arguments, argumentKey);
             case constants_1.ARGUMENT_TYPES.GET_PARAM:
-                return extractParameters(request.params, argument.arguments);
+                return extractParameters(request.params, argument.arguments, argumentKey);
             default:
                 return;
         }
@@ -37,26 +61,41 @@ function mapArguments(decoratedArguments, request, response, next) {
         .value();
 }
 exports.mapArguments = mapArguments;
-function extractParameters(target, args) {
+function extractParameters(target, args, propertyName) {
     if (!args && !target) {
         return;
     }
-    if (!args) {
-        return target;
+    if ((0, lodash_1.size)(args)) {
+        if (Array.isArray(args)) {
+            return (0, lodash_1.pick)(target, args);
+        }
+        return (0, lodash_1.get)(target, args);
     }
-    if (Array.isArray(args)) {
-        return (0, lodash_1.pick)(target, args);
+    if ((0, lodash_1.has)(target, propertyName)) {
+        return (0, lodash_1.get)(target, propertyName);
     }
-    return (0, lodash_1.get)(target, args);
+    return target;
 }
 exports.extractParameters = extractParameters;
-function generateRoute(route, verb) {
-    return (target, propertyKey, descriptor) => router(verb, route, target, descriptor.value, propertyKey);
+function generateRoute(route, verb, ...settings) {
+    return (target, propertyKey, descriptor) => router(verb, route, target, descriptor.value, propertyKey, settings);
 }
 exports.generateRoute = generateRoute;
-function router(verb, route, target, handler, propertyKey) {
+function router(verb, route, target, handler, propertyKey, settings) {
     const existedRoutesHandlers = MetaData_1.default.get(constants_1.ROUTER_HANDLERS_KEY, target) || [];
-    existedRoutesHandlers.unshift({ verb, route, handler, target, propertyKey });
+    existedRoutesHandlers.unshift({ verb, route, handler, target, propertyKey, settings });
     MetaData_1.default.set(constants_1.ROUTER_HANDLERS_KEY, existedRoutesHandlers, target);
 }
 exports.router = router;
+function fileSettings() {
+    try {
+        if (fs.existsSync('.expressive-tea')) {
+            const configString = fs.readFileSync('.expressive-tea');
+            return JSON.parse(configString.toString());
+        }
+    }
+    catch (e) {
+        return {};
+    }
+}
+exports.fileSettings = fileSettings;

package/helpers/teapot-helper.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { KeyPairSyncResult } from 'crypto';
+export interface EncryptedMessage {
+    iv: string;
+    message: string;
+}
+export interface TeaGatewayMessage {
+    [property: string]: any;
+}
+export default class TeaGatewayHelper {
+    static encrypt(data: TeaGatewayMessage, signature: Buffer): EncryptedMessage;
+    static decrypt(data: EncryptedMessage, signature: Buffer): TeaGatewayMessage;
+    static sign(data: string, privateKey: string, passphrase: string): Buffer;
+    static verify(data: string, publicKey: string, signature: Buffer): boolean;
+    static generateKeys(passphrase: string): KeyPairSyncResult<any, any>;
+}

package/helpers/teapot-helper.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("crypto");
+class TeaGatewayHelper {
+    static encrypt(data, signature) {
+        const iv = crypto.randomBytes(16);
+        const packet = JSON.stringify(data);
+        const cipher = crypto.createCipheriv('aes-256-ctr', signature, iv);
+        const encrypted = Buffer.concat([cipher.update(packet), cipher.final()]);
+        return { iv: iv.toString('hex'), message: encrypted.toString('base64') };
+    }
+    static decrypt(data, signature) {
+        const iv = Buffer.from(data.iv, 'hex');
+        const message = Buffer.from(data.message, 'base64');
+        const decipher = crypto.createDecipheriv('aes-256-ctr', signature, iv);
+        const decrypted = Buffer.concat([decipher.update(message), decipher.final()]);
+        return JSON.parse(decrypted.toString());
+    }
+    static sign(data, privateKey, passphrase) {
+        return crypto.sign('sha256', Buffer.from(data), {
+            key: privateKey,
+            passphrase
+        });
+    }
+    static verify(data, publicKey, signature) {
+        return crypto.verify('sha256', Buffer.from(data), {
+            key: publicKey
+        }, signature);
+    }
+    static generateKeys(passphrase) {
+        const { generateKeyPairSync } = require('crypto');
+        return generateKeyPairSync('rsa', {
+            modulusLength: 2048,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem'
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+                cipher: 'aes-256-cbc',
+                passphrase
+            }
+        });
+    }
+}
+exports.default = TeaGatewayHelper;

package/helpers/websocket-helper.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as https from 'https';
+export declare function initWebsocket(server: http.Server, secureServer: https.Server): Promise<void>;

package/helpers/websocket-helper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWebsocket = void 0;
+const WebsocketService_1 = require("../services/WebsocketService");
+const WebSocket = require("ws");
+const Settings_1 = require("../classes/Settings");
+async function initWebsocket(server, secureServer) {
+    const settings = Settings_1.default.getInstance();
+    const isDetached = settings.get('detachWebsocket');
+    if (settings.get('startWebsocket')) {
+        WebsocketService_1.default.init();
+        WebsocketService_1.default.getInstance().setWebSocket(new WebSocket.Server(isDetached ? { noServer: true } : { server }));
+        if (secureServer) {
+            WebsocketService_1.default.getInstance().setSecureWebsocket(new WebSocket.Server(isDetached ? { noServer: true } : { server: secureServer }));
+        }
+        WebsocketService_1.default.getInstance().setHttpServer(server);
+        WebsocketService_1.default.getInstance().setHttpServer(secureServer);
+    }
+}
+exports.initWebsocket = initWebsocket;

package/inversify.config.d.ts

@@ -0,0 +1,9 @@
+import { Container } from 'inversify';
+declare const container: Container;
+export declare const decorators: {
+    lazyInject: (serviceIdentifier: string | symbol | import("inversify/lib/interfaces/interfaces").interfaces.Newable<any> | import("inversify/lib/interfaces/interfaces").interfaces.Abstract<any>) => (proto: any, key: string) => void;
+    lazyInjectNamed: (serviceIdentifier: string | symbol | import("inversify/lib/interfaces/interfaces").interfaces.Newable<any> | import("inversify/lib/interfaces/interfaces").interfaces.Abstract<any>, named: string) => (proto: any, key: string) => void;
+    lazyInjectTagged: (serviceIdentifier: string | symbol | import("inversify/lib/interfaces/interfaces").interfaces.Newable<any> | import("inversify/lib/interfaces/interfaces").interfaces.Abstract<any>, key: string, value: any) => (proto: any, propertyName: string) => void;
+    lazyMultiInject: (serviceIdentifier: string | symbol | import("inversify/lib/interfaces/interfaces").interfaces.Newable<any> | import("inversify/lib/interfaces/interfaces").interfaces.Abstract<any>) => (proto: any, key: string) => void;
+};
+export default container;

package/inversify.config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorators = void 0;
+const inversify_1 = require("inversify");
+const inversify_inject_decorators_1 = require("inversify-inject-decorators");
+const container = new inversify_1.Container({ autoBindInjectable: true });
+exports.decorators = (0, inversify_inject_decorators_1.default)(container);
+exports.default = container;

package/libs/classNames.d.ts

@@ -0,0 +1 @@
+export declare const EXPRESSIVE_TEA_PROXY_CLASS = "ExpressiveTeaProxy";

package/libs/classNames.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPRESSIVE_TEA_PROXY_CLASS = void 0;
+exports.EXPRESSIVE_TEA_PROXY_CLASS = 'ExpressiveTeaProxy';

package/libs/constants.d.ts

@@ -50,6 +50,8 @@ export declare const EXPRESS_DIRECTIVES: string[];
 export declare const BOOT_STAGES_KEY = "boot:stage-settings";
 export declare const ROUTER_HANDLERS_KEY = "app:routes:handlers";
 export declare const ROUTER_MIDDLEWARES_KEY = "app:routes:middlewares";
+export declare const ROUTER_PROXIES_KEY = "app:routes:proxies";
+export declare const PROXY_SETTING_KEY = "app:proxy:settings";
 export declare const REGISTERED_MODEL_KEY = "app:models:registered";
 export declare const REGISTERED_MODULE_KEY = "app:modules:registered";
 export declare const PLUGINS_KEY = "boot:app-plugins";
@@ -57,8 +59,8 @@ export declare const REGISTERED_STATIC_KEY = "app:statics";
 export declare const REGISTERED_DIRECTIVES_KEY = "app:directives";
 export declare const ARGUMENTS_KEY = "app:routes:arguments";
 export declare const ROUTER_ANNOTATIONS_KEY = "app:routes:annotations";
-export declare const ROUTER_PROXIES_KEY = "app:routes:proxies";
-export declare const PROXY_SETTING_KEY = "app:proxy:settings";
+export declare const ASSIGN_TEAPOT_KEY = "app:gateway:teapot";
+export declare const ASSIGN_TEACUP_KEY = "app:gateway:teacup";
 export declare const ARGUMENT_TYPES: {
     BODY: symbol;
     GET_PARAM: symbol;

package/libs/constants.js

@@ -21,7 +21,7 @@
  * @summary Available Boot Stages
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROXY_PROPERTIES = exports.PROXY_METHODS = exports.ARGUMENT_TYPES = exports.PROXY_SETTING_KEY = exports.ROUTER_PROXIES_KEY = exports.ROUTER_ANNOTATIONS_KEY = exports.ARGUMENTS_KEY = exports.REGISTERED_DIRECTIVES_KEY = exports.REGISTERED_STATIC_KEY = exports.PLUGINS_KEY = exports.REGISTERED_MODULE_KEY = exports.REGISTERED_MODEL_KEY = exports.ROUTER_MIDDLEWARES_KEY = exports.ROUTER_HANDLERS_KEY = exports.BOOT_STAGES_KEY = exports.EXPRESS_DIRECTIVES = exports.STAGES_INIT = exports.BOOT_STAGES_LIST = exports.BOOT_ORDER = exports.BOOT_STAGES = void 0;
+exports.PROXY_PROPERTIES = exports.PROXY_METHODS = exports.ARGUMENT_TYPES = exports.ASSIGN_TEACUP_KEY = exports.ASSIGN_TEAPOT_KEY = exports.ROUTER_ANNOTATIONS_KEY = exports.ARGUMENTS_KEY = exports.REGISTERED_DIRECTIVES_KEY = exports.REGISTERED_STATIC_KEY = exports.PLUGINS_KEY = exports.REGISTERED_MODULE_KEY = exports.REGISTERED_MODEL_KEY = exports.PROXY_SETTING_KEY = exports.ROUTER_PROXIES_KEY = exports.ROUTER_MIDDLEWARES_KEY = exports.ROUTER_HANDLERS_KEY = exports.BOOT_STAGES_KEY = exports.EXPRESS_DIRECTIVES = exports.STAGES_INIT = exports.BOOT_STAGES_LIST = exports.BOOT_ORDER = exports.BOOT_STAGES = void 0;
 // tslint:enable:max-line-length
 var BOOT_STAGES;
 (function (BOOT_STAGES) {
@@ -46,9 +46,7 @@ var BOOT_STAGES;
 exports.BOOT_ORDER = [
     BOOT_STAGES.BOOT_DEPENDENCIES,
     BOOT_STAGES.INITIALIZE_MIDDLEWARES,
-    // BOOT_STAGES.APPLICATION,
-    // BOOT_STAGES.AFTER_APPLICATION_MIDDLEWARES,
-    // BOOT_STAGES.START
+    BOOT_STAGES.APPLICATION
 ];
 exports.BOOT_STAGES_LIST = [
     BOOT_STAGES.BOOT_DEPENDENCIES,
@@ -84,6 +82,8 @@ exports.EXPRESS_DIRECTIVES = [
 exports.BOOT_STAGES_KEY = 'boot:stage-settings';
 exports.ROUTER_HANDLERS_KEY = 'app:routes:handlers';
 exports.ROUTER_MIDDLEWARES_KEY = 'app:routes:middlewares';
+exports.ROUTER_PROXIES_KEY = 'app:routes:proxies';
+exports.PROXY_SETTING_KEY = 'app:proxy:settings';
 exports.REGISTERED_MODEL_KEY = 'app:models:registered';
 exports.REGISTERED_MODULE_KEY = 'app:modules:registered';
 exports.PLUGINS_KEY = 'boot:app-plugins';
@@ -91,8 +91,8 @@ exports.REGISTERED_STATIC_KEY = 'app:statics';
 exports.REGISTERED_DIRECTIVES_KEY = 'app:directives';
 exports.ARGUMENTS_KEY = 'app:routes:arguments';
 exports.ROUTER_ANNOTATIONS_KEY = 'app:routes:annotations';
-exports.ROUTER_PROXIES_KEY = 'app:routes:proxies';
-exports.PROXY_SETTING_KEY = 'app:proxy:settings';
+exports.ASSIGN_TEAPOT_KEY = 'app:gateway:teapot';
+exports.ASSIGN_TEACUP_KEY = 'app:gateway:teacup';
 exports.ARGUMENT_TYPES = {
     BODY: Symbol('BODY'),
     GET_PARAM: Symbol('GET_PARAM'),
@@ -113,6 +113,8 @@ var PROXY_METHODS;
     PROXY_METHODS["PROXY_REQ_OPT_DECORATOR"] = "proxyReqOptDecorator";
     PROXY_METHODS["PROXY_REQ_BODY_DECORATOR"] = "proxyReqBodyDecorator";
 })(PROXY_METHODS = exports.PROXY_METHODS || (exports.PROXY_METHODS = {}));
+// 'limit' | 'memoizeHost' | 'https' | 'preserveHostHdr' | 'parseReqBody' |
+// 'reqAsBuffer' | 'reqBodyEncoding' | 'timeout';
 var PROXY_PROPERTIES;
 (function (PROXY_PROPERTIES) {
     PROXY_PROPERTIES["LIMIT"] = "limit";