@zerooneit/expressive-tea 1.3.0-beta.4 → 1.3.0-beta.6

package/engines/teacup/index.js

@@ -2,15 +2,15 @@
 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 url_1 = require("url");
 const socket_io_client_1 = require("socket.io-client");
 const inversify_1 = require("inversify");
 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,83 +25,66 @@ 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 = new url_1.URL(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();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         this.client.on('handshake', this.handshaked.bind(this));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         this.client.on('accepted', this.accepted.bind(this));
         this.client.on('error', console.log);
         this.client.connect();
     }
+    static canRegister(ctx, settings) {
+        return Metadata_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(ctx), 'isTeacupActive');
+    }
 };
 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,22 @@
-export default class TeapotEngine {
-    private readonly settings;
-    private readonly context;
-    private readonly server;
-    private readonly serverSecure?;
-    private clients;
-    private registeredRoute;
+import ExpressiveTeaEngine from '../../classes/Engine';
+import Boot from '../../classes/Boot';
+import Settings from '../../classes/Settings';
+export default class TeapotEngine extends ExpressiveTeaEngine {
+    private readonly clients;
+    private readonly 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>;
+    static canRegister(ctx?: Boot, settings?: Settings): boolean;
 }

package/engines/teapot/index.js

@@ -4,11 +4,19 @@ 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");
+const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
+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 +36,46 @@ 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));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        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);
-            }
-            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);
-                });
+            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);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                this.context.getApplication().use(message.mountTo, teapot_helper_1.default.proxyResponse.bind(this, proxyRoute));
             }
-            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 +93,34 @@ 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);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         this.socketServer.on('connection', this.registerTeacup.bind(this));
-        this.socketServer.listen(this.server);
+    }
+    static canRegister(ctx, settings) {
+        return Metadata_1.default.get(constants_1.ASSIGN_TEAPOT_KEY, (0, object_helper_1.getClass)(ctx), 'isTeapotActive');
     }
 };
 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,9 @@
-export default class WebsocketEngine {
-    private readonly settings;
-    private readonly server;
-    private readonly serverSecure?;
+import ExpressiveTeaEngine from '../../classes/Engine';
+import Boot from '../../classes/Boot';
+import Settings from '../../classes/Settings';
+export default class WebsocketEngine extends ExpressiveTeaEngine {
     canStart: boolean;
     isDetached: boolean;
-    constructor(server: any, serverSecure: any, settings: any);
     init(): Promise<void>;
+    static canRegister(ctx?: Boot, settings?: Settings): boolean;
 }

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 }));
@@ -25,13 +24,11 @@ let WebsocketEngine = class WebsocketEngine {
             WebsocketService_1.default.getInstance().setHttpServer(this.serverSecure);
         }
     }
+    static canRegister(ctx, settings) {
+        return settings.get('startWebsocket');
+    }
 };
 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/exceptions/RequestExceptions.d.ts

@@ -25,7 +25,7 @@
 export declare class GenericRequestException extends Error {
     statusCode: number;
     message: string;
-    constructor(message: any, statusCode?: number);
+    constructor(message: string | never, statusCode?: number);
 }
 /**
  * Shortcut Exception for 400 HTTP Errors (Bad Request).

package/helpers/boot-helper.d.ts

@@ -1,6 +1,6 @@
 import { BOOT_STAGES } from '@expressive-tea/commons/constants';
-import { Express } from 'express';
-import Boot from '../classes/Boot';
+import { type Express } from 'express';
+import type 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>;

package/helpers/boot-helper.js

@@ -1,5 +1,4 @@
 "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("@expressive-tea/commons/constants");
@@ -24,7 +23,9 @@ 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);
+        // @ts-expect-error Settings can be any parameter
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        server.set(options.name, ...options.settings);
     });
 }
 exports.resolveDirectives = resolveDirectives;

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

@@ -1,9 +1,9 @@
-import { NextFunction, Request, Response } from 'express';
-import { ExpressiveTeaAnnotations, ExpressiveTeaArgumentOptions } from '@expressive-tea/commons/interfaces';
+import { type NextFunction, type Request, type Response } from 'express';
+import { type ExpressiveTeaAnnotations, type 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 router(verb: string, route: string, target: any, handler: (...args: any[]) => never | any | Promise<any>, propertyKey: string | symbol, settings?: any): void;
 export declare function fileSettings(): any;

package/helpers/server.js

@@ -10,7 +10,8 @@ const fs = require("fs");
 function autoResponse(request, response, annotations, responseResult) {
     const view = (0, lodash_1.find)(annotations, { type: 'view' });
     if (view) {
-        return response.render(view.arguments[0], responseResult);
+        response.render(view.arguments[0], responseResult);
+        return;
     }
     response.send((0, lodash_1.isNumber)(responseResult) ? responseResult.toString() : responseResult);
 }
@@ -22,14 +23,15 @@ 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);
         }
     }
     catch (e) {
         if (e instanceof RequestExceptions_1.GenericRequestException) {
-            return next(e);
+            next(e);
+            return;
         }
         next(new RequestExceptions_1.GenericRequestException(e.message || 'System Error'));
     }
@@ -39,7 +41,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,13 +49,13 @@ 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;
+                return undefined;
         }
     })
         .thru((args) => (0, lodash_1.size)(args) ? args : [request, response, next])
@@ -78,12 +79,13 @@ function extractParameters(target, args, propertyName) {
 }
 exports.extractParameters = extractParameters;
 function generateRoute(route, verb, ...settings) {
-    return (target, propertyKey, descriptor) => router(verb, route, target, descriptor.value, propertyKey, settings);
+    return (target, propertyKey, descriptor) => { router(verb, route, target, descriptor.value, propertyKey, 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,17 +1,19 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { KeyPairSyncResult } from 'crypto';
+import { type KeyPairSyncResult } from 'crypto';
+import { type NextFunction, type Request, type Response } from 'express';
+import type ProxyRoute from '../classes/ProxyRoute';
 export interface EncryptedMessage {
     iv: string;
     message: string;
 }
-export interface TeaGatewayMessage {
-    [property: string]: any;
-}
+export type TeaGatewayMessage = Record<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>;
+    static proxyResponse(proxyRoute: ProxyRoute, req: Request, res: Response, next: NextFunction): void;
+    static httpSchema(schema: string): "http:" | "https:";
 }

package/helpers/teapot-helper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto = require("crypto");
+const crypto_1 = require("crypto");
 class TeaGatewayHelper {
     static encrypt(data, signature) {
         const iv = crypto.randomBytes(16);
@@ -17,19 +18,18 @@ 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 (0, crypto_1.generateKeyPairSync)('ed25519', {
             modulusLength: 2048,
             publicKeyEncoding: {
                 type: 'spki',
@@ -43,5 +43,20 @@ class TeaGatewayHelper {
             }
         });
     }
+    static proxyResponse(proxyRoute, req, res, next) {
+        const router = proxyRoute.registerRoute();
+        if (!proxyRoute.hasClients()) {
+            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/helpers/websocket-helper.d.ts

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

package/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+import { type 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 });