@zerooneit/expressive-tea 1.3.0-beta.3 → 1.3.0-beta.5

package/classes/Boot.d.ts

@@ -1,14 +1,13 @@
 import 'reflect-metadata';
-import '../inversify.config';
 import { Express } from 'express';
-import Settings from '../classes/Settings';
 import { ExpressiveTeaApplication } from '@expressive-tea/commons/interfaces';
+import Settings from '../classes/Settings';
 /**
  * Expressive Tea Application interface is the response from an started application, contains the express application
  * and a node http server instance.
  * @typedef {Object} ExpressiveTeaApplication
  * @property {Express} application - Express Application Instance
- * @property {HTTPServer} server - HTTP Server Object
+ * @property { HTTPServer } server - HTTP Server Object
  * @summary Application Interface
  */
 /**

package/classes/Boot.js

@@ -1,27 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-require("../inversify.config");
-const $P = require("bluebird");
+const inversify_config_1 = require("../inversify.config");
 // tslint:disable-next-line:no-duplicate-imports
 const express = require("express");
+const constants_1 = require("@expressive-tea/commons/constants");
+const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
+const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
+const http_1 = require("../engines/http");
+const websocket_1 = require("../engines/websocket");
+const index_1 = require("../engines/teapot/index");
+const teacup_1 = require("../engines/teacup");
+const Engine_1 = require("../classes/Engine");
+const Settings_1 = require("../classes/Settings");
+const index_2 = require("../engines/socketio/index");
 const fs = require("fs");
 const http = require("http");
 const https = require("https");
-const Settings_1 = require("../classes/Settings");
-const constants_1 = require("@expressive-tea/commons/constants");
-const index_1 = require("../engines/http/index");
-const index_2 = require("../engines/websocket/index");
-const index_3 = require("../engines/teapot/index");
-const teacup_1 = require("../engines/teacup");
-// tslint:disable-next-line:no-duplicate-imports
-const inversify_config_1 = require("../inversify.config");
 /**
  * Expressive Tea Application interface is the response from an started application, contains the express application
  * and a node http server instance.
  * @typedef {Object} ExpressiveTeaApplication
  * @property {Express} application - Express Application Instance
- * @property {HTTPServer} server - HTTP Server Object
+ * @property { HTTPServer } server - HTTP Server Object
  * @summary Application Interface
  */
 /**
@@ -59,7 +60,7 @@ class Boot {
      * @returns {Promise<ExpressiveTeaApplication>}
      */
     async start() {
-        return new $P(async (resolver, rejector) => {
+        return new Promise(async (resolver, reject) => {
             try {
                 const localContainer = inversify_config_1.default.createChild();
                 const privateKey = this.settings.get('privateKey');
@@ -68,29 +69,33 @@ class Boot {
                 const secureServer = privateKey && certificate && https.createServer({
                     cert: fs.readFileSync(certificate).toString('utf-8'),
                     key: fs.readFileSync(privateKey).toString('utf-8')
-                }, this.server);
+                });
                 // Injectables
                 localContainer.bind('server').toConstantValue(server);
                 localContainer.bind('secureServer').toConstantValue(secureServer || undefined);
                 localContainer.bind('context').toConstantValue(this);
                 localContainer.bind('settings').toConstantValue(this.settings);
-                const httpEngine = localContainer.resolve(index_1.default);
-                const websocketEngine = localContainer.resolve(index_2.default);
-                const teapotEngine = localContainer.resolve(index_3.default);
-                const teacupEngine = localContainer.resolve(teacup_1.default);
-                await websocketEngine.init();
+                // Activation
+                const isActiveTeapot = Metadata_1.default.get(constants_1.ASSIGN_TEAPOT_KEY, (0, object_helper_1.getClass)(this), 'isTeapotActive');
+                const isActiveTeacup = Metadata_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(this), 'isTeacupActive');
+                const isActiveWebsockets = this.settings.get('startWebsocket');
+                // Resolve Engines
+                const httpEngine = localContainer.resolve(http_1.default);
+                const availableEngines = [
+                    localContainer.resolve(index_2.default),
+                    ...isActiveWebsockets ? [localContainer.resolve(websocket_1.default)] : [],
+                    ...isActiveTeapot ? [localContainer.resolve(index_1.default)] : [],
+                    ...isActiveTeacup ? [localContainer.resolve(teacup_1.default)] : [],
+                ];
+                // Initialize Engines
+                await Engine_1.default.exec(availableEngines, 'init');
                 await httpEngine.init();
-                await httpEngine.resolveProxyContainers();
-                await httpEngine.resolveStages(constants_1.BOOT_ORDER);
-                await httpEngine.resolveStages([constants_1.BOOT_STAGES.AFTER_APPLICATION_MIDDLEWARES, constants_1.BOOT_STAGES.ON_HTTP_CREATION], server, secureServer);
-                const listenerServers = await httpEngine.start();
-                await httpEngine.resolveStages([constants_1.BOOT_STAGES.START], ...listenerServers);
-                await teapotEngine.start();
-                await teacupEngine.start();
+                await httpEngine.start();
+                await Engine_1.default.exec(availableEngines, 'start');
                 resolver({ application: this.server, server, secureServer });
             }
             catch (e) {
-                return rejector(e);
+                return reject(e);
             }
         });
     }

package/classes/Engine.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import Settings from './Settings';
+import Boot from './Boot';
+import http from 'http';
+import https from 'https';
+export default class ExpressiveTeaEngine {
+    protected readonly settings: Settings;
+    protected readonly context: Boot;
+    protected readonly server: http.Server;
+    protected readonly serverSecure?: https.Server;
+    constructor(ctx: any, server: any, serverSecure: any, settings: any);
+    static exec(availableEngines: ExpressiveTeaEngine[], method: string): any;
+}

package/classes/Engine.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+let ExpressiveTeaEngine = class ExpressiveTeaEngine {
+    constructor(ctx, server, serverSecure, settings) {
+        this.settings = settings;
+        this.context = ctx;
+        this.server = server;
+        this.serverSecure = serverSecure;
+    }
+    static exec(availableEngines, method) {
+        return Promise.all(availableEngines
+            // tslint:disable-next-line:no-string-literal
+            .filter(engine => typeof engine[method] === 'function')
+            // tslint:disable-next-line:no-string-literal
+            .map(engine => engine[method]()));
+    }
+};
+ExpressiveTeaEngine = 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])
+], ExpressiveTeaEngine);
+exports.default = ExpressiveTeaEngine;

package/engines/constants/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SOCKET_IO_INSTANCE_KEY = "SOCKETIO:INSTANCE";
+export declare const SOCKET_IO_SECURE_INSTANCE_KEY = "SOCKETIO:INSTANCE:SECURE";

package/engines/constants/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOCKET_IO_SECURE_INSTANCE_KEY = exports.SOCKET_IO_INSTANCE_KEY = void 0;
+exports.SOCKET_IO_INSTANCE_KEY = 'SOCKETIO:INSTANCE';
+exports.SOCKET_IO_SECURE_INSTANCE_KEY = 'SOCKETIO:INSTANCE:SECURE';

package/engines/http/index.d.ts

@@ -3,12 +3,8 @@
 import * as http from 'http';
 import * as https from 'https';
 import { BOOT_STAGES } from '@expressive-tea/commons/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);
+import ExpressiveTeaEngine from '../../classes/Engine';
+export default class HTTPEngine extends ExpressiveTeaEngine {
     private listen;
     start(): Promise<(http.Server | https.Server)[]>;
     init(): Promise<void>;

package/engines/http/index.js

@@ -1,21 +1,16 @@
 "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("@expressive-tea/commons/constants");
 const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
 const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-let HTTPEngine = class HTTPEngine {
-    constructor(ctx, server, serverSecure, settings) {
-        this.context = ctx;
-        this.server = server;
-        this.serverSecure = serverSecure;
-        this.settings = settings;
-    }
+const Engine_1 = require("../../classes/Engine");
+let HTTPEngine = class HTTPEngine extends Engine_1.default {
     listen(server, port) {
-        return new $P((resolve, reject) => {
+        return new Promise((resolve, reject) => {
+            console.log('Listening on port', port, server.listen);
             server.listen(port);
             server.on('error', error => {
                 reject(error);
@@ -27,19 +22,24 @@ let HTTPEngine = class HTTPEngine {
         });
     }
     async start() {
-        return [
+        console.log(`Starting Server Test`);
+        const listenerServers = [
             await this.listen(this.server, this.settings.get('port')),
             (this.serverSecure) ? await this.listen(this.serverSecure, this.settings.get('securePort')) : null
         ];
+        await this.resolveStages([constants_1.BOOT_STAGES.START], ...listenerServers);
+        return listenerServers;
     }
     async init() {
         await (0, boot_helper_1.resolveDirectives)(this.context, this.context.getApplication());
         await (0, boot_helper_1.resolveStatic)(this.context, this.context.getApplication());
+        // HTTP Engine Resolve Stages
+        await this.resolveProxyContainers();
+        await this.resolveStages(constants_1.BOOT_ORDER);
+        await this.resolveStages([constants_1.BOOT_STAGES.AFTER_APPLICATION_MIDDLEWARES, constants_1.BOOT_STAGES.ON_HTTP_CREATION], this.server, this.serverSecure);
     }
     async resolveStages(stages, ...extraArgs) {
-        return $P.map(stages, s => {
-            return (0, boot_helper_1.resolveStage)(s, this.context, this.context.getApplication(), ...extraArgs);
-        });
+        return Promise.all(stages.map(s => (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)) || [];
@@ -49,12 +49,6 @@ let HTTPEngine = class HTTPEngine {
     }
 };
 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])
+    (0, inversify_1.injectable)()
 ], HTTPEngine);
 exports.default = HTTPEngine;

package/engines/socketio/index.d.ts

@@ -0,0 +1,6 @@
+import ExpressiveTeaEngine from '../../classes/Engine';
+export default class SocketIOEngine extends ExpressiveTeaEngine {
+    private io;
+    private ioSecure;
+    init(): Promise<void>;
+}

package/engines/socketio/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const socket_io_1 = require("socket.io");
+const Engine_1 = require("../../classes/Engine");
+const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
+const constants_1 = require("../constants/constants");
+class SocketIOEngine extends Engine_1.default {
+    async init() {
+        const commonConfig = {
+            path: '/exp-tea/',
+            transports: ['websocket', 'polling']
+        };
+        this.io = this.server && new socket_io_1.Server(this.server, Object.assign({}, commonConfig));
+        this.ioSecure = this.serverSecure && new socket_io_1.Server(this.serverSecure, Object.assign({}, commonConfig));
+        Metadata_1.default.set(constants_1.SOCKET_IO_INSTANCE_KEY, this.io, this.context);
+        Metadata_1.default.set(constants_1.SOCKET_IO_SECURE_INSTANCE_KEY, this.ioSecure, this.context);
+    }
+}
+exports.default = SocketIOEngine;
+;

package/engines/teacup/index.d.ts

@@ -1,10 +1,6 @@
-export default class TeacupEngine {
-    private readonly settings;
-    private readonly context;
-    private readonly server;
-    private readonly serverSecure?;
+import ExpressiveTeaEngine from '../../classes/Engine';
+export default class TeacupEngine extends ExpressiveTeaEngine {
     private teacupSettings;
-    private isActive;
     private publicKey;
     private privateKey;
     private publicServerKey;
@@ -12,7 +8,6 @@ export default class TeacupEngine {
     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

@@ -10,7 +10,8 @@ const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
 const constants_1 = require("@expressive-tea/commons/constants");
 const teapot_helper_1 = require("../../helpers/teapot-helper");
 const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
-let TeacupEngine = class TeacupEngine {
+const Engine_1 = require("../../classes/Engine");
+let TeacupEngine = class TeacupEngine extends Engine_1.default {
     header() {
         console.log(chalk.white.bold('Teacup Engine is initializing...'));
         console.log(chalk `
@@ -25,69 +26,53 @@ let TeacupEngine = class TeacupEngine {
 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.
   `);
     }
-    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
-        });
-    }
-    handshaked(data) {
+    handshaked(key, signature, isSecure, cb) {
         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;
+            console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {yellow.bold Server Verification Started}`);
+            if (!teapot_helper_1.default.verify(this.teacupSettings.clientKey, key.toString('ascii'), signature)) {
+                throw new Error('Fail to Verify Client on Teapod.');
             }
-            throw new Error('Fail to Verify Client on Teapod.');
+            console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {green.bold Server Has Been Verified}`);
+            this.publicServerKey = key;
+            this.serverSignature = signature;
+            cb(Buffer.from(this.publicKey), this.clientSignature);
         }
         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() {
+    accepted(cb) {
         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({
+        const encryptedMessage = teapot_helper_1.default.encrypt({
             mountTo: this.teacupSettings.mountTo,
             address: this.teacupSettings.address
-        }, this.serverSignature.slice(0, 32)));
+        }, this.serverSignature.slice(0, 32));
+        cb(encryptedMessage);
         const onClose = () => {
             try {
                 this.client.close();
             }
-            catch (_) { }
+            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.teacupSettings = Metadata_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(this.context));
+        const scheme = url.parse(this.teacupSettings.serverUrl);
+        const { publicKey, privateKey } = teapot_helper_1.default.generateKeys(this.teacupSettings.clientKey);
+        const protocol = teapot_helper_1.default.httpSchema(scheme.protocol);
+        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)(`${protocol}//${scheme.host}/teapot`, {
+            path: '/exp-tea/',
+            reconnection: true,
+            autoConnect: false
+        });
         this.header();
         this.client.on('handshake', this.handshaked.bind(this));
         this.client.on('accepted', this.accepted.bind(this));
@@ -96,12 +81,6 @@ All Communication are encrypted to ensure intruder can not connected, however, p
     }
 };
 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])
+    (0, inversify_1.injectable)()
 ], TeacupEngine);
 exports.default = TeacupEngine;

package/engines/teapot/index.d.ts

@@ -1,23 +1,19 @@
-export default class TeapotEngine {
-    private readonly settings;
-    private readonly context;
-    private readonly server;
-    private readonly serverSecure?;
+import ExpressiveTeaEngine from '../../classes/Engine';
+export default class TeapotEngine extends ExpressiveTeaEngine {
     private clients;
     private registeredRoute;
     private teapotSettings;
     private publicKey;
     private privateKey;
-    private isActive;
     private serverSignature;
     private socketServer;
     private static header;
     private registerTeacup;
-    private acceptedHandshake;
+    private clientVerification;
     private registered;
     private removeFromRoutes;
     private findClientInRoutes;
     private disconnected;
-    constructor(ctx: any, server: any, serverSecure: any, settings: any);
+    init(): Promise<void>;
     start(): Promise<void>;
 }

package/engines/teapot/index.js

@@ -4,11 +4,18 @@ 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("@expressive-tea/commons/classes/Metadata");
 const constants_1 = require("@expressive-tea/commons/constants");
+const ProxyRoute_1 = require("../../classes/ProxyRoute");
+const Engine_1 = require("../../classes/Engine");
 const teapot_helper_1 = require("../../helpers/teapot-helper");
-let TeapotEngine = TeapotEngine_1 = class TeapotEngine {
+const constants_2 = require("../constants/constants");
+let TeapotEngine = TeapotEngine_1 = class TeapotEngine extends Engine_1.default {
+    constructor() {
+        super(...arguments);
+        this.clients = new Map();
+        this.registeredRoute = new Map();
+    }
     static header(teapotSettings) {
         console.log(chalk.white.bold('Teapot Engine is initializing...'));
         console.log(chalk `
@@ -28,64 +35,44 @@ All Communication are encrypted to ensure intruder can not connected, however, p
     }
     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));
+        teacup.emit('handshake', Buffer.from(this.publicKey), this.serverSignature, Boolean(this.serverSecure), this.clientVerification.bind(this, teacup));
+        teacup.on('disconnect', this.disconnected.bind(this, teacup));
     }
-    acceptedHandshake(ctx, data) {
-        const self = this;
+    clientVerification(teacup, userPublicKey, userSignature) {
+        console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {yellow.bold Client Verification Started}`);
+        console.log('userKey', userPublicKey.toString('base64'));
+        console.log('userSignature', userSignature.toString('base64'));
         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;
+            if (!teapot_helper_1.default.verify(this.teapotSettings.clientKey, userPublicKey.toString('ascii'), userSignature)) {
+                console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${teacup.id}}]: Failed to verify and will be disconnected...`);
+                return teacup.disconnect();
             }
-            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${self.id}}]: Failed to verify and will be disconnected...`);
-            self.disconnect();
+            this.clients.set(teacup.id, {
+                publicKey: userPublicKey,
+                signature: userSignature
+            });
+            teacup.emit('accepted', this.registered.bind(this, teacup));
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {green.bold Client Verified}`);
         }
         catch (e) {
-            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${self.id}}]: Failed wiht next message: ${e.message}`);
-            self.disconnect();
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${teacup.id}}]: Failed wiht next message: ${e.message}`);
+            teacup.disconnect();
         }
     }
-    registered(ctx, data) {
-        const self = this;
+    registered(teacup, encryptedMessage) {
         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);
+            const message = teapot_helper_1.default.decrypt(encryptedMessage, this.serverSignature.slice(0, 32));
+            const isRegistered = this.registeredRoute.has(message.mountTo);
+            const proxyRoute = isRegistered ? this.registeredRoute.get(message.mountTo) : new ProxyRoute_1.default(message.mountTo);
+            proxyRoute.registerServer(message.address, teacup.id);
+            if (!isRegistered) {
+                this.registeredRoute.set(message.mountTo, proxyRoute);
+                this.context.getApplication().use(message.mountTo, teapot_helper_1.default.proxyResponse.bind(this, proxyRoute));
             }
-            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}}`);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.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}`);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${e.message}`);
         }
     }
     removeFromRoutes(routes = [], id) {
@@ -103,54 +90,30 @@ All Communication are encrypted to ensure intruder can not connected, however, p
         });
         return routes;
     }
-    disconnected(ctx, reason) {
-        const self = this;
+    disconnected(teacup, reason) {
         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}`);
+            const routes = this.findClientInRoutes(teacup.id);
+            this.removeFromRoutes(routes, teacup.id);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.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}`);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${e.message}`);
         }
     }
-    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');
+    async init() {
         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',
-            cookie: false
-        });
     }
     async start() {
-        if (!this.isActive) {
-            return;
-        }
+        this.socketServer = Metadata_1.default.get(constants_2.SOCKET_IO_INSTANCE_KEY, this.context).of('/teapot');
         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])
+    (0, inversify_1.injectable)()
 ], TeapotEngine);
 exports.default = TeapotEngine;

package/engines/websocket/index.d.ts

@@ -1,9 +1,6 @@
-export default class WebsocketEngine {
-    private readonly settings;
-    private readonly server;
-    private readonly serverSecure?;
+import ExpressiveTeaEngine from '../../classes/Engine';
+export default class WebsocketEngine extends ExpressiveTeaEngine {
     canStart: boolean;
     isDetached: boolean;
-    constructor(server: any, serverSecure: any, settings: any);
     init(): Promise<void>;
 }

package/engines/websocket/index.js

@@ -4,17 +4,16 @@ 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) {
+const Engine_1 = require("../../classes/Engine");
+let WebsocketEngine = class WebsocketEngine extends Engine_1.default {
+    constructor() {
+        super(...arguments);
         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() {
+        this.canStart = this.settings.get('startWebsocket');
+        this.isDetached = this.settings.get('detachWebsocket');
         if (this.canStart) {
             WebsocketService_1.default.init();
             WebsocketService_1.default.getInstance().setWebSocket(new WebSocket.Server(this.isDetached ? { noServer: true } : { server: this.server }));
@@ -27,11 +26,6 @@ let WebsocketEngine = class WebsocketEngine {
     }
 };
 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])
+    (0, inversify_1.injectable)()
 ], WebsocketEngine);
 exports.default = WebsocketEngine;

package/helpers/promise-helper.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<unknown>;

package/helpers/promise-helper.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.delay = delay;

package/helpers/server.d.ts

@@ -2,8 +2,8 @@ import { NextFunction, Request, Response } from 'express';
 import { ExpressiveTeaAnnotations, ExpressiveTeaArgumentOptions } from '@expressive-tea/commons/interfaces';
 export declare function autoResponse(request: Request, response: Response, annotations: ExpressiveTeaAnnotations[], responseResult?: any): 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 mapArguments(decoratedArguments: ExpressiveTeaArgumentOptions[], request: Request, response: Response, next: NextFunction, introspectedArgs?: string[]): any[];
+export declare function extractParameters(target: unknown, args?: string | string[], propertyName?: string): 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

@@ -22,7 +22,7 @@ async function executeRequest(request, response, next) {
             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)));
+        const result = await this.options.handler.apply(this.self, mapArguments(this.decoratedArguments, request, response, nextWrapper(), this.options.introspectedArgs));
         if (!response.headersSent && !isNextUsed) {
             autoResponse(request, response, this.annotations, result);
         }
@@ -39,7 +39,6 @@ function mapArguments(decoratedArguments, request, response, next, introspectedA
     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;
@@ -48,11 +47,11 @@ function mapArguments(decoratedArguments, request, response, next, introspectedA
             case constants_1.ARGUMENT_TYPES.NEXT:
                 return next;
             case constants_1.ARGUMENT_TYPES.QUERY:
-                return extractParameters(request.query, argument.arguments, argumentKey);
+                return extractParameters(request.query, argument.arguments, (0, lodash_1.get)(introspectedArgs, argument.index));
             case constants_1.ARGUMENT_TYPES.BODY:
-                return extractParameters(request.body, argument.arguments, argumentKey);
+                return extractParameters(request.body, argument.arguments, (0, lodash_1.get)(introspectedArgs, argument.index));
             case constants_1.ARGUMENT_TYPES.GET_PARAM:
-                return extractParameters(request.params, argument.arguments, argumentKey);
+                return extractParameters(request.params, argument.arguments, (0, lodash_1.get)(introspectedArgs, argument.index));
             default:
                 return;
         }
@@ -82,8 +81,9 @@ function generateRoute(route, verb, ...settings) {
 }
 exports.generateRoute = generateRoute;
 function router(verb, route, target, handler, propertyKey, settings) {
+    const introspectedArgs = (0, object_helper_1.getOwnArgumentNames)(handler);
     const existedRoutesHandlers = Metadata_1.default.get(constants_1.ROUTER_HANDLERS_KEY, target) || [];
-    existedRoutesHandlers.unshift({ verb, route, handler, target, propertyKey, settings });
+    existedRoutesHandlers.unshift({ verb, route, handler, target, propertyKey, settings, introspectedArgs });
     Metadata_1.default.set(constants_1.ROUTER_HANDLERS_KEY, existedRoutesHandlers, target);
 }
 exports.router = router;

package/helpers/teapot-helper.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { KeyPairSyncResult } from 'crypto';
+import { NextFunction, Request, Response } from 'express';
+import ProxyRoute from '../classes/ProxyRoute';
 export interface EncryptedMessage {
     iv: string;
     message: string;
@@ -14,4 +16,6 @@ export default class TeaGatewayHelper {
     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>;
+    static proxyResponse(proxyRoute: ProxyRoute, req: Request, res: Response, next: NextFunction): void;
+    static httpSchema(schema: string): "http:" | "https:";
 }

package/helpers/teapot-helper.js

@@ -17,19 +17,19 @@ class TeaGatewayHelper {
         return JSON.parse(decrypted.toString());
     }
     static sign(data, privateKey, passphrase) {
-        return crypto.sign('sha256', Buffer.from(data), {
+        return crypto.sign(null, Buffer.from(data), {
             key: privateKey,
             passphrase
         });
     }
     static verify(data, publicKey, signature) {
-        return crypto.verify('sha256', Buffer.from(data), {
+        return crypto.verify(null, Buffer.from(data), {
             key: publicKey
         }, signature);
     }
     static generateKeys(passphrase) {
         const { generateKeyPairSync } = require('crypto');
-        return generateKeyPairSync('rsa', {
+        return generateKeyPairSync('ed25519', {
             modulusLength: 2048,
             publicKeyEncoding: {
                 type: 'spki',
@@ -43,5 +43,18 @@ class TeaGatewayHelper {
             }
         });
     }
+    static proxyResponse(proxyRoute, req, res, next) {
+        const router = proxyRoute.registerRoute();
+        if (!proxyRoute.hasClients())
+            return next();
+        return router(req, res, next);
+    }
+    static httpSchema(schema) {
+        if (schema.includes('teapot'))
+            return 'http:';
+        if (schema.includes('teapots'))
+            return 'https:';
+        throw new Error(`Invalid Schema: ${schema}`);
+    }
 }
 exports.default = TeaGatewayHelper;

package/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+import { ExpressiveTeaHandlerOptions } from '@expressive-tea/commons/interfaces';
+export interface ExpressiveTeaHandlerOptionsWithInstrospectedArgs extends ExpressiveTeaHandlerOptions {
+    introspectedArgs: string[];
+}

package/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@zerooneit/expressive-tea",
-  "version": "1.3.0-beta.3",
+  "version": "1.3.0-beta.5",
   "description": "A REST API  over Express and Typescript",
   "main": "classes/Boot.js",
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=16.0.0"
   },
   "scripts": {
-    "test": "npm run linter && jest --clearCache && jest --coverage  --ci --detectOpenHandles --forceExit --silent --runInBand",
-    "test:dev": "npm run linter && jest --clearCache && jest --detectOpenHandles --forceExit",
+    "test": "yarn run linter && jest --clearCache && jest --coverage  --ci --detectOpenHandles --forceExit --silent",
+    "test:dev": "yarn run linter && jest --clearCache && jest --detectOpenHandles --forceExit",
     "linter": "tslint -c tslint.json -p tsconfig.json",
     "build:dev": "tsc --project tsconfig.json --watch",
     "build": "tsc --project tsconfig.json",
     "clean:build": "trash '**/*.js' '**/*.d.ts' '**/*.js.map' '**/*.d.ts.map' '!node_modules/**/*' '!docs/**/*' '!coverage/**/*' '!gulpfile.js' '!tasks/*.js' '!jest.config.js' '!tools/**/*'",
-    "publish:prepare": "npm run clean:build && npm run build",
-    "postpublish": "npm run clean:build",
-    "prepublishOnly": "npm test && npm run publish:prepare"
+    "publish:prepare": "yarn run clean:build && yarn run build",
+    "postpublish": "yarn run clean:build",
+    "prepublishOnly": "yarn test && yarn run publish:prepare"
   },
   "publishConfig": {
     "access": "public"
@@ -25,45 +25,42 @@
   ],
   "license": "Apache-2.0",
   "devDependencies": {
-    "@expressive-tea/commons": "1.0.0",
-    "@expressive-tea/plugin": "1.0.2",
-    "@types/bluebird": "3.5.38",
-    "@types/express": "4.17.15",
+    "@expressive-tea/commons": "^1.0.1",
+    "@expressive-tea/plugin": "1.0.3",
+    "@types/express": "4.17.17",
     "@types/express-http-proxy": "1.6.3",
-    "@types/express-serve-static-core": "4.17.32",
-    "@types/jest": "29.2.5",
-    "@types/lodash": "4.14.191",
-    "@types/node": "18.11.18",
+    "@types/express-serve-static-core": "4.17.34",
+    "@types/jest": "29.5.1",
+    "@types/lodash": "4.14.194",
+    "@types/node": "20.1.0",
     "@types/reflect-metadata": "0.1.0",
     "@types/socket.io": "3.0.2",
     "@types/socket.io-client": "3.0.0",
     "@types/ws": "8.5.4",
     "http-terminator": "3.2.0",
-    "jest": "29.3.1",
+    "jest": "29.5.0",
     "jest-express": "1.12.0",
-    "jest-junit": "15.0.0",
+    "jest-junit": "16.0.0",
     "reflect-metadata": "0.1.13",
-    "rimraf": "4.0.4",
+    "rimraf": "5.0.0",
     "supertest": "6.3.3",
     "toast-jsdoc": "1.0.2",
     "trash-cli": "5.0.0",
-    "ts-jest": "29.0.5",
+    "ts-jest": "29.1.0",
     "ts-node": "10.9.1",
     "tslint": "6.1.3",
-    "typescript": "4.9.4"
+    "typescript": "5.0.4"
   },
   "dependencies": {
-    "bluebird": "3.7.2",
-    "eiows": "^4.1.2",
     "express": "4.18.2",
     "express-http-proxy": "1.6.3",
     "inversify": "6.0.1",
     "inversify-inject-decorators": "3.1.0",
     "lodash": "4.17.21",
-    "socket.io": "4.5.4",
-    "socket.io-client": "4.5.4",
+    "socket.io": "4.6.1",
+    "socket.io-client": "4.6.1",
     "url-scheme": "1.0.5",
-    "ws": "8.12.0"
+    "ws": "8.13.0"
   },
   "repository": {
     "type": "git",
@@ -111,6 +108,8 @@
   },
   "resolutions": {
     "set-value": "4.1.0",
-    "glob-parent": "6.0.2"
-  }
+    "glob-parent": "6.0.2",
+    "engine.io": "6.4.2"
+  },
+  "packageManager": "yarn@3.5.1"
 }

package/.circleci/config.yml

@@ -1,58 +0,0 @@
-# Use the latest 2.1 version of CircleCI pipeline process engine.
-# See: https://circleci.com/docs/2.0/configuration-reference
-version: 2.1
-
-orbs:
-  # The Node.js orb contains a set of prepackaged CircleCI configuration you can utilize
-  # Orbs reduce the amount of configuration required for common tasks.
-  # See the orb documentation here: https://circleci.com/developer/orbs/orb/circleci/node
-  node: circleci/node@4.7
-
-jobs:
-  # Below is the definition of your job to build and test your app, you can rename and customize it as you want.
-  build-and-test:
-    # These next lines define a Docker executor: https://circleci.com/docs/2.0/executor-types/
-    # You can specify an image from Dockerhub or use one of our Convenience Images from CircleCI's Developer Hub.
-    # A list of available CircleCI Docker Convenience Images are available here: https://circleci.com/developer/images/image/cimg/node
-    docker:
-      - image: cimg/node:16.10
-    # Then run your tests!
-    # CircleCI will report the results back to your VCS provider.
-    steps:
-      # Checkout the code as the first step.
-      - checkout
-      # Next, the node orb's install-packages step will install the dependencies from a package.json.
-      # The orb install-packages step will also automatically cache them for faster future runs.
-      - restore_cache:
-          keys:
-            - expressive-tea-{{ checksum "package.json" }}
-            - expressive-tea-
-
-      - node/install-packages:
-          # If you are using yarn, change the line below from "npm" to "yarn"
-          pkg-manager: yarn
-      - save_cache:
-          paths:
-            - node_modules
-          key: expressive-tea-{{ checksum "package.json" }}
-      - run:
-          name: Expressive Tea Tests
-          command: npm test
-          environment:
-            JEST_JUNIT_OUTPUT_DIR: "./coverage"
-            JUNIT_REPORT_NAME: "junit.xml"
-      - store_test_results:
-          path: ./coverage
-      - store_artifacts:
-          path: ./coverage
-
-workflows:
-  # Below is the definition of your workflow.
-  # Inside the workflow, you provide the jobs you want to run, e.g this workflow runs the build-and-test job above.
-  # CircleCI will run this workflow on every commit.
-  # For more details on extending your workflow, see the configuration docs: https://circleci.com/docs/2.0/configuration-reference/#workflows
-  Testing:
-    jobs:
-      - build-and-test
-      # For running simple node tests, you could optionally use the node/test job from the orb to replicate and replace the job above in fewer lines.
-      # - node/test