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

package/classes/Settings.d.ts

@@ -14,9 +14,11 @@ import { ExpressiveTeaServerProps } from '../libs/interfaces';
  *
  * @class Settings
  * @param {ExpressiveTeaServerProps} [options={ port: 3000 }]
+ * @param {boolean} [isIsolated=false]
  * @summary Singleton Class to Store Server Settings
  */
 declare class Settings {
+    static isolatedContext: Map<any, Settings>;
     /**
      * Reset Singleton instance to the default values, all changes will be erased is not recommendable to use it
      * multiple times since all your options will be lost. Unless you have an option how to recover this is not
@@ -37,7 +39,7 @@ declare class Settings {
      * @memberof Settings
      * @summary Get Singleton Instance.
      */
-    static getInstance(): Settings;
+    static getInstance(ctx?: any): Settings;
     /**
      * Singleton Instance only for internal.
      *
@@ -55,7 +57,7 @@ declare class Settings {
      * @memberof Settings
      */
     private options;
-    constructor(options?: ExpressiveTeaServerProps);
+    constructor(options?: ExpressiveTeaServerProps, isIsolated?: boolean);
     /**
      * It will return the latest snapshot options registered at the time that this method is called, as Expressive Tea
      * is designed as async methods some time options should not be available.

package/classes/Settings.js

@@ -1,6 +1,11 @@
 "use strict";
+var Settings_1;
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const _ = require("lodash");
+const inversify_1 = require("inversify");
+const object_helper_1 = require("../helpers/object-helper");
+const server_1 = require("../helpers/server");
 /**
  * Declare the properties which the server will save into settings, is a semi dynamic object since is allowed to save
  * any property but is contains only one defined property to keep the port of the server.
@@ -16,15 +21,17 @@ const _ = require("lodash");
  *
  * @class Settings
  * @param {ExpressiveTeaServerProps} [options={ port: 3000 }]
+ * @param {boolean} [isIsolated=false]
  * @summary Singleton Class to Store Server Settings
  */
-class Settings {
-    constructor(options = { port: 3000, securePort: 4443 }) {
-        if (Settings.instance) {
-            return Settings.instance;
+let Settings = Settings_1 = class Settings {
+    constructor(options = { port: 3000, securePort: 4443 }, isIsolated = false) {
+        if (Settings_1.instance && !isIsolated) {
+            return Settings_1.instance;
         }
-        this.options = Object.assign({}, { port: 3000, securePort: 4443 }, options);
-        Settings.instance = this;
+        const settingsFile = (0, server_1.fileSettings)();
+        this.options = Object.assign({}, { port: 3000, securePort: 4443 }, settingsFile, options);
+        Settings_1.instance = this;
     }
     /**
      * Reset Singleton instance to the default values, all changes will be erased is not recommendable to use it
@@ -37,7 +44,7 @@ class Settings {
      * @memberof Settings
      */
     static reset() {
-        delete Settings.instance;
+        delete Settings_1.instance;
     }
     /**
      * Get Current Singleton Instance or Created if not exists. If a new instance is created it will created with default
@@ -48,8 +55,15 @@ class Settings {
      * @memberof Settings
      * @summary Get Singleton Instance.
      */
-    static getInstance() {
-        return Settings.instance || new Settings();
+    static getInstance(ctx) {
+        if (ctx) {
+            const context = (0, object_helper_1.nameOfClass)(ctx);
+            if (!Settings_1.isolatedContext.has(context)) {
+                Settings_1.isolatedContext.set(context, new Settings_1(null, true));
+            }
+            return Settings_1.isolatedContext.get(context);
+        }
+        return Settings_1.instance || new Settings_1();
     }
     /**
      * It will return the latest snapshot options registered at the time that this method is called, as Expressive Tea
@@ -96,5 +110,10 @@ class Settings {
     merge(options = { port: 3000, securePort: 4443 }) {
         this.options = Object.assign(this.options, options);
     }
-}
+};
+Settings.isolatedContext = new Map();
+Settings = Settings_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__metadata("design:paramtypes", [Object, Boolean])
+], Settings);
 exports.default = Settings;

package/decorators/annotations.d.ts

@@ -1,3 +1,4 @@
+import { ParameterDecorator } from '../libs/types';
 /**
  * Is passing directly to the decorated argument described <a href="http://expressjs.com/en/4x/api.html#req">here</a>.
  * @decorator {ParameterDecorator} request - Assign express Request instance to parameter.

package/decorators/module.js

@@ -30,7 +30,7 @@ const DependencyInjection_1 = require("../services/DependencyInjection");
  */
 function Module(options) {
     return (Module) => {
-        return class extends Module {
+        return class ExpressiveTeaModule extends Module {
             constructor(...args) {
                 super(...args);
                 this.router = (0, express_1.Router)();

package/decorators/router.d.ts

@@ -1,6 +1,6 @@
 import { Router } from 'express';
 import { ExpressiveTeaHandlerOptions } from '../libs/interfaces';
-import { ExpressMiddlewareHandler, MethodDecorator } from '../libs/types';
+import { ClassDecorator, ExpressMiddlewareHandler, MethodDecorator } from '../libs/types';
 /**
  * @module Decorators/Router
  */
@@ -17,8 +17,9 @@ import { ExpressMiddlewareHandler, MethodDecorator } from '../libs/types';
  * {REPLACE-AT}Route('/)
  * class Example {}
  */
-export declare function Route(mountpoint?: string): <T extends new (...args: any[]) => {}>(Route: T) => {
+export declare function Route(mountpoint?: string): <T extends new (...args: any[]) => any>(RouterClass: T) => {
     new (...args: any[]): {
+        [x: string]: any;
         readonly router: Router;
         readonly mountpoint: string;
         __mount(parent: Router): any;

package/decorators/router.js

@@ -4,7 +4,6 @@ exports.View = exports.Middleware = exports.Param = exports.Delete = exports.Pat
 const express_1 = require("express");
 const lodash_1 = require("lodash");
 const MetaData_1 = require("../classes/MetaData");
-const RequestExceptions_1 = require("../exceptions/RequestExceptions");
 const decorators_1 = require("../helpers/decorators");
 const server_1 = require("../helpers/server");
 const constants_1 = require("../libs/constants");
@@ -25,8 +24,8 @@ const constants_1 = require("../libs/constants");
  * class Example {}
  */
 function Route(mountpoint = '/') {
-    return (Route) => {
-        return class ExpressiveTeaRoute extends Route {
+    return (RouterClass) => {
+        return class ExpressiveTeaRoute extends RouterClass {
             constructor(...args) {
                 super(...args);
                 const handlers = MetaData_1.default.get(constants_1.ROUTER_HANDLERS_KEY, this) || [];
@@ -46,26 +45,12 @@ function Route(mountpoint = '/') {
                 const self = this;
                 const decoratedArguments = MetaData_1.default.get(constants_1.ARGUMENTS_KEY, options.target, options.propertyKey);
                 const annotations = MetaData_1.default.get(constants_1.ROUTER_ANNOTATIONS_KEY, options.target, options.propertyKey);
-                return async function exec(request, response, next) {
-                    try {
-                        let isNextUsed = false;
-                        const nextWrapper = () => (error) => {
-                            next(error);
-                            isNextUsed = true;
-                        };
-                        // TODO: Must be Depecrated in prior version.
-                        const result = await options.handler.apply(self, (0, server_1.mapArguments)(decoratedArguments, request, response, nextWrapper()));
-                        if (!response.headersSent && !isNextUsed) {
-                            (0, server_1.autoResponse)(request, response, annotations, result);
-                        }
-                    }
-                    catch (e) {
-                        if (e instanceof RequestExceptions_1.GenericRequestException) {
-                            return next(e);
-                        }
-                        next(new RequestExceptions_1.GenericRequestException(e.message || 'System Error'));
-                    }
-                };
+                return server_1.executeRequest.bind({
+                    options,
+                    decoratedArguments,
+                    annotations,
+                    self
+                });
             }
         };
     };

package/decorators/server.d.ts

@@ -1,6 +1,6 @@
 import { Express } from 'express';
 import { BOOT_STAGES } from '../libs/constants';
-import { ExpressiveTeaServerProps, ExpressiveTeaStaticFileServer } from '../libs/interfaces';
+import { ExpressiveTeaPotSettings, ExpressiveTeaServerProps, ExpressiveTeaStaticFileServer, ExpressiveTeaCupSettings } from '../libs/interfaces';
 /**
  * Plug Class Decorator create a simple plugin to execute in one of the public stages defined on BOOT_STAGES, might
  * be useful to attach a simple Express Server configuration.
@@ -25,7 +25,7 @@ export declare function Plug(stage: BOOT_STAGES, name: string, method: (server?:
  * @decorator {ClassDecorator} Pour - Use Expressive Tea plugin definition instance.
  * @summary Attach an Expressive Tea Definition Instance.
  * @param Plugin - A Plugin Class which extends @expressive-tea/plugin/Plugin Class.
- * @param pluginArgs - Plugin Constructor Arguments
+ * @param pluginArgs any[] - Arguments passed directly to the Plugin constructor.
  * @version 1.1.0
  * @link https://www.npmjs.com/package/@expressive-tea/plugin Expressive Tea Plugin
  */
@@ -36,7 +36,6 @@ export declare function Pour(Plugin: any, ...pluginArgs: any[]): (target: any) =
  * @decorator {ClassDecorator} ServerSettings - Declares Server Settings.
  * @summary Declare Server Properties.
  * @param {ExpressiveTeaModuleProps} options
- * @param {object} [port=3000] Select Port Number where the server should be listening.
  */
 export declare function ServerSettings(options?: ExpressiveTeaServerProps): (target: any) => any;
 /**
@@ -60,9 +59,9 @@ export declare function Static(root: string, virtual?: string | null, options?:
  * @summary Express Setting Directive
  * @param {string} name - Express Directive Setting Name
  * @param {*} settings - Setting Arguments
- * @decorator {ClassDecorator} ExpressDirecive - Set a Express App Setting.
+ * @decorator {ClassDecorator} ExpressDirective - Set a Express App Setting.
  */
-export declare function ExpressDirecive(name: string, ...settings: any[]): (target: any) => void;
+export declare function ExpressDirective(name: string, ...settings: any[]): (target: any) => void;
 /**
  * Setting Property Decorator Automatically assign a settings declared on Settings Service into the decorated property.
  * All properties will contains the settings value or undefined if current settings is not founded.
@@ -71,15 +70,6 @@ export declare function ExpressDirecive(name: string, ...settings: any[]): (targ
  * @param {string} settingName The Setting name tha
  */
 export declare function Setting(settingName: string): (target: any, propertyName: string) => any;
-/**
- * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
- * method with a Module Class.
- * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
- * @summary <b>ONLY</b> Decorate Start Method, this register the Module Classes created by the user.
- * @param {Class} Module
- */
-export declare function RegisterModule(Module: any): (target: any, property: any) => void;
-export declare function Proxies(proxyContainers: any[]): (target: any) => void;
 /**
  * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
  * and register modules.
@@ -88,3 +78,15 @@ export declare function Proxies(proxyContainers: any[]): (target: any) => void;
  * @param Modules
  */
 export declare function Modules(Modules: any[]): (target: any) => void;
+export declare function Proxies(proxyContainers: any[]): (target: any) => void;
+/**
+ * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
+ * method with a Module Class.
+ * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
+ * @summary <b>ONLY</b> Decorate Start Method, this register the Module Classes created by the user.
+ * @param {Class} Module
+ * @deprecated Use the new decorator Modules that allow add modules into registered modules.
+ */
+export declare function RegisterModule(Module: any): (target: any, property: any) => void;
+export declare function Teapot(teapotSettings: ExpressiveTeaPotSettings): (target: object) => void;
+export declare function Teacup(teacupSettings: ExpressiveTeaCupSettings): (target: object) => void;

package/decorators/server.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Modules = exports.Proxies = exports.RegisterModule = exports.Setting = exports.ExpressDirecive = exports.Static = exports.ServerSettings = exports.Pour = exports.Plug = void 0;
+exports.Teacup = exports.Teapot = exports.RegisterModule = exports.Proxies = exports.Modules = exports.Setting = exports.ExpressDirective = exports.Static = exports.ServerSettings = exports.Pour = exports.Plug = void 0;
 const lodash_1 = require("lodash");
 const MetaData_1 = require("../classes/MetaData");
 const Settings_1 = require("../classes/Settings");
@@ -97,7 +97,7 @@ exports.Plug = Plug;
  * @decorator {ClassDecorator} Pour - Use Expressive Tea plugin definition instance.
  * @summary Attach an Expressive Tea Definition Instance.
  * @param Plugin - A Plugin Class which extends @expressive-tea/plugin/Plugin Class.
- * @param pluginArgs - Plugin Constructor Arguments
+ * @param pluginArgs any[] - Arguments passed directly to the Plugin constructor.
  * @version 1.1.0
  * @link https://www.npmjs.com/package/@expressive-tea/plugin Expressive Tea Plugin
  */
@@ -105,7 +105,7 @@ function Pour(Plugin, ...pluginArgs) {
     return (target) => {
         const stages = getStages(target);
         const instance = new Plugin(...pluginArgs);
-        const plugins = instance.register(Settings_1.default.getInstance().getOptions(), getRegisteredPlugins(target));
+        const plugins = instance.register(Settings_1.default.getInstance(target).getOptions(), getRegisteredPlugins(target));
         constants_1.BOOT_STAGES_LIST.forEach(STAGE => {
             setStage(STAGE, (stages[STAGE] || []).concat(instance.getRegisteredStage(STAGE)), target);
         });
@@ -119,12 +119,10 @@ exports.Pour = Pour;
  * @decorator {ClassDecorator} ServerSettings - Declares Server Settings.
  * @summary Declare Server Properties.
  * @param {ExpressiveTeaModuleProps} options
- * @param {object} [port=3000] Select Port Number where the server should be listening.
  */
 function ServerSettings(options = {}) {
     return target => {
-        Settings_1.default.getInstance().merge(options);
-        // MetaData.set(BOOT_STAGES_KEY, STAGES_INIT, target);
+        Settings_1.default.getInstance(target).merge(options);
         return target;
     };
 }
@@ -160,9 +158,9 @@ exports.Static = Static;
  * @summary Express Setting Directive
  * @param {string} name - Express Directive Setting Name
  * @param {*} settings - Setting Arguments
- * @decorator {ClassDecorator} ExpressDirecive - Set a Express App Setting.
+ * @decorator {ClassDecorator} ExpressDirective - Set a Express App Setting.
  */
-function ExpressDirecive(name, ...settings) {
+function ExpressDirective(name, ...settings) {
     return target => {
         if (!constants_1.EXPRESS_DIRECTIVES.includes(name)) {
             throw new Error(`Directive Name ${name} is not valid express behavior setting`);
@@ -172,7 +170,7 @@ function ExpressDirecive(name, ...settings) {
         MetaData_1.default.set(constants_1.REGISTERED_DIRECTIVES_KEY, registeredDirectives, target);
     };
 }
-exports.ExpressDirecive = ExpressDirecive;
+exports.ExpressDirective = ExpressDirective;
 /**
  * Setting Property Decorator Automatically assign a settings declared on Settings Service into the decorated property.
  * All properties will contains the settings value or undefined if current settings is not founded.
@@ -184,29 +182,28 @@ function Setting(settingName) {
     return (target, propertyName) => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
-            get: () => Settings_1.default.getInstance().get(propertyName)
+            get: () => Settings_1.default.getInstance(target).get(propertyName)
         });
     };
 }
 exports.Setting = Setting;
 /**
- * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
- * method with a Module Class.
+ * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
+ * and register modules.
  * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
- * @summary <b>ONLY</b> Decorate Start Method, this register the Module Classes created by the user.
- * @param {Class} Module
+ * @summary This register the Module Classes created by the user.
+ * @param Modules
  */
-function RegisterModule(Module) {
-    return (target, property) => {
-        if (property !== 'start') {
-            throw new Error('Register Module needs to decorate ONLY start method');
+function Modules(Modules) {
+    return target => {
+        for (const Module of Modules) {
+            const registeredModules = MetaData_1.default.get(constants_1.REGISTERED_MODULE_KEY, target, 'start') || [];
+            registeredModules.unshift(Module);
+            MetaData_1.default.set(constants_1.REGISTERED_MODULE_KEY, registeredModules, target, 'start');
         }
-        const registeredModules = MetaData_1.default.get(constants_1.REGISTERED_MODULE_KEY, target, property) || [];
-        registeredModules.push(Module);
-        MetaData_1.default.set(constants_1.REGISTERED_MODULE_KEY, registeredModules, target, property);
     };
 }
-exports.RegisterModule = RegisterModule;
+exports.Modules = Modules;
 function Proxies(proxyContainers) {
     return target => {
         for (const proxyContainer of proxyContainers) {
@@ -218,19 +215,35 @@ function Proxies(proxyContainers) {
 }
 exports.Proxies = Proxies;
 /**
- * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
- * and register modules.
+ * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
+ * method with a Module Class.
  * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
- * @summary This register the Module Classes created by the user.
- * @param Modules
+ * @summary <b>ONLY</b> Decorate Start Method, this register the Module Classes created by the user.
+ * @param {Class} Module
+ * @deprecated Use the new decorator Modules that allow add modules into registered modules.
  */
-function Modules(Modules) {
-    return target => {
-        for (const Module of Modules) {
-            const registeredModules = MetaData_1.default.get(constants_1.REGISTERED_MODULE_KEY, target, 'start') || [];
-            registeredModules.unshift(Module);
-            MetaData_1.default.set(constants_1.REGISTERED_MODULE_KEY, registeredModules, target, 'start');
+function RegisterModule(Module) {
+    return (target, property) => {
+        if (property !== 'start') {
+            throw new Error('Register Module needs to decorate ONLY start method');
         }
+        const registeredModules = MetaData_1.default.get(constants_1.REGISTERED_MODULE_KEY, target, property) || [];
+        registeredModules.push(Module);
+        MetaData_1.default.set(constants_1.REGISTERED_MODULE_KEY, registeredModules, target, property);
     };
 }
-exports.Modules = Modules;
+exports.RegisterModule = RegisterModule;
+function Teapot(teapotSettings) {
+    return (target) => {
+        MetaData_1.default.set(constants_1.ASSIGN_TEAPOT_KEY, true, target, 'isTeapotActive');
+        MetaData_1.default.set(constants_1.ASSIGN_TEAPOT_KEY, teapotSettings, target);
+    };
+}
+exports.Teapot = Teapot;
+function Teacup(teacupSettings) {
+    return (target) => {
+        MetaData_1.default.set(constants_1.ASSIGN_TEACUP_KEY, true, target, 'isTeacupActive');
+        MetaData_1.default.set(constants_1.ASSIGN_TEACUP_KEY, teacupSettings, target);
+    };
+}
+exports.Teacup = Teacup;

package/engines/http/index.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as https from 'https';
+import { BOOT_STAGES } from '../../libs/constants';
+export default class HTTPEngine {
+    private readonly settings;
+    private readonly context;
+    private readonly server;
+    private readonly serverSecure?;
+    constructor(ctx: any, server: any, serverSecure: any, settings: any);
+    private listen;
+    start(): Promise<(http.Server | https.Server)[]>;
+    init(): Promise<void>;
+    resolveStages(stages: BOOT_STAGES[], ...extraArgs: any[]): Promise<void[]>;
+    resolveProxyContainers(): Promise<void>;
+}

package/engines/http/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const $P = require("bluebird");
+const inversify_1 = require("inversify");
+const boot_helper_1 = require("../../helpers/boot-helper");
+const constants_1 = require("../../libs/constants");
+const object_helper_1 = require("../../helpers/object-helper");
+const MetaData_1 = require("../../classes/MetaData");
+let HTTPEngine = class HTTPEngine {
+    constructor(ctx, server, serverSecure, settings) {
+        this.context = ctx;
+        this.server = server;
+        this.serverSecure = serverSecure;
+        this.settings = settings;
+    }
+    listen(server, port) {
+        return new $P((resolve, reject) => {
+            server.listen(port);
+            server.on('error', error => {
+                reject(error);
+            });
+            server.on('listening', () => {
+                console.log(`Running HTTP Server on [${port}]`);
+                resolve(server);
+            });
+        });
+    }
+    async start() {
+        return [
+            await this.listen(this.server, this.settings.get('port')),
+            (this.serverSecure) ? await this.listen(this.serverSecure, this.settings.get('securePort')) : null
+        ];
+    }
+    async init() {
+        await (0, boot_helper_1.resolveDirectives)(this.context, this.context.getApplication());
+        await (0, boot_helper_1.resolveStatic)(this.context, this.context.getApplication());
+    }
+    async resolveStages(stages, ...extraArgs) {
+        return $P.map(stages, s => {
+            return (0, boot_helper_1.resolveStage)(s, this.context, this.context.getApplication(), ...extraArgs);
+        });
+    }
+    async resolveProxyContainers() {
+        const ProxyContainers = MetaData_1.default.get(constants_1.ROUTER_PROXIES_KEY, (0, object_helper_1.getClass)(this.context)) || [];
+        for (const Container of ProxyContainers) {
+            (0, boot_helper_1.resolveProxy)(Container, this.context.getApplication());
+        }
+    }
+};
+HTTPEngine = 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])
+], HTTPEngine);
+exports.default = HTTPEngine;

package/engines/teacup/index.d.ts

@@ -0,0 +1,19 @@
+export default class TeacupEngine {
+    private readonly settings;
+    private readonly context;
+    private readonly server;
+    private readonly serverSecure?;
+    private teacupSettings;
+    private isActive;
+    private publicKey;
+    private privateKey;
+    private publicServerKey;
+    private serverSignature;
+    private clientSignature;
+    private client;
+    private header;
+    constructor(ctx: any, settings: any, server: any, serverSecure: any);
+    private handshaked;
+    private accepted;
+    start(): Promise<void>;
+}

package/engines/teacup/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const url = require("url");
+// tslint:disable-next-line:no-duplicate-imports
+const socket_io_client_1 = require("socket.io-client");
+const inversify_1 = require("inversify");
+const MetaData_1 = require("../../classes/MetaData");
+const constants_1 = require("../../libs/constants");
+const teapot_helper_1 = require("../../helpers/teapot-helper");
+const object_helper_1 = require("../../helpers/object-helper");
+let TeacupEngine = class TeacupEngine {
+    constructor(ctx, settings, server, serverSecure) {
+        this.server = server;
+        this.serverSecure = serverSecure;
+        this.settings = settings;
+        this.context = ctx;
+        this.teacupSettings = MetaData_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(this.context));
+        this.isActive = MetaData_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(this.context), 'isTeacupActive');
+        if (!this.isActive) {
+            return;
+        }
+        const scheme = url.parse(this.teacupSettings.serverUrl);
+        const { publicKey, privateKey } = teapot_helper_1.default.generateKeys(this.teacupSettings.clientKey);
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+        this.clientSignature = teapot_helper_1.default.sign(this.teacupSettings.clientKey, this.privateKey, this.teacupSettings.clientKey);
+        this.client = (0, socket_io_client_1.io)(`http://${scheme.host}`, {
+            path: '/teapot',
+            reconnection: true,
+            autoConnect: false
+        });
+    }
+    header() {
+        console.log(chalk.white.bold('Teacup Engine is initializing...'));
+        console.log(chalk `
+   {grey ( (}
+    {white.bold ) )}
+  {magenta.bold ........}
+  {magenta.bold |      |]}
+  {magenta.bold \\      /}    {yellow.bold [${this.teacupSettings.address}]}
+   {magenta.bold \`----'}
+
+{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.
+  `);
+    }
+    handshaked(data) {
+        try {
+            console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {yellow.bold Started Verification}`);
+            const serverPublicKey = Buffer.from(data.key, 'base64').toString('ascii');
+            const serverSignature = Buffer.from(data.signature, 'base64');
+            if (teapot_helper_1.default.verify(this.teacupSettings.clientKey, serverPublicKey, serverSignature)) {
+                console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {green.bold Verified}`);
+                this.publicServerKey = serverPublicKey;
+                this.serverSignature = serverSignature;
+                this.client.emit('handshake', {
+                    key: Buffer.from(this.publicKey).toString('base64'),
+                    signature: this.clientSignature.toString('base64')
+                });
+                return;
+            }
+            throw new Error('Fail to Verify Client on Teapod.');
+        }
+        catch (e) {
+            console.error(chalk `{cyan.bold [TEACUP]} - {red.bold TEAPOD}  {magenta.bold ${this.client.id}}: Failed with next message: ${e.message}`);
+            this.client.disconnect();
+        }
+    }
+    accepted() {
+        var _a;
+        console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {green.bold Registered} - {blue.bold <${this.teacupSettings.serverUrl}>} <-> {white.bold ${this.teacupSettings.mountTo}}`);
+        this.client.emit('register', teapot_helper_1.default.encrypt({
+            mountTo: this.teacupSettings.mountTo,
+            address: this.teacupSettings.address
+        }, this.serverSignature.slice(0, 32)));
+        const onClose = () => {
+            try {
+                this.client.close();
+            }
+            catch (_) { }
+        };
+        this.server.on('close', onClose);
+        (_a = this.serverSecure) === null || _a === void 0 ? void 0 : _a.on('close', onClose);
+    }
+    async start() {
+        if (!this.isActive) {
+            return;
+        }
+        this.header();
+        this.client.on('handshake', this.handshaked.bind(this));
+        this.client.on('accepted', this.accepted.bind(this));
+        this.client.on('error', console.log);
+        this.client.connect();
+    }
+};
+TeacupEngine = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)('context')),
+    tslib_1.__param(1, (0, inversify_1.inject)('settings')),
+    tslib_1.__param(2, (0, inversify_1.inject)('server')),
+    tslib_1.__param(3, (0, inversify_1.inject)('secureServer')),
+    tslib_1.__param(3, (0, inversify_1.optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object, Object, Object, Object])
+], TeacupEngine);
+exports.default = TeacupEngine;

package/engines/teapot/index.d.ts

@@ -0,0 +1,23 @@
+export default class TeapotEngine {
+    private readonly settings;
+    private readonly context;
+    private readonly server;
+    private readonly serverSecure?;
+    private clients;
+    private registeredRoute;
+    private teapotSettings;
+    private publicKey;
+    private privateKey;
+    private isActive;
+    private serverSignature;
+    private socketServer;
+    private static header;
+    private registerTeacup;
+    private acceptedHandshake;
+    private registered;
+    private removeFromRoutes;
+    private findClientInRoutes;
+    private disconnected;
+    constructor(ctx: any, server: any, serverSecure: any, settings: any);
+    start(): Promise<void>;
+}