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

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, statusCode?: number);
 }
 /**
  * Shortcut Exception for 400 HTTP Errors (Bad Request).
@@ -48,7 +48,7 @@ export declare class GenericRequestException extends Error {
  * }
  */
 export declare class BadRequestException extends GenericRequestException {
-    constructor(message?: string | never);
+    constructor(message?: string);
 }
 /**
  * Shortcut Exception for 401 HTTP Errors (Unauthorized Request).
@@ -71,5 +71,5 @@ export declare class BadRequestException extends GenericRequestException {
  * }
  */
 export declare class UnauthorizedException extends GenericRequestException {
-    constructor(message?: string | never);
+    constructor(message?: string);
 }

package/helpers/boot-helper.d.ts

@@ -1,7 +1,7 @@
-import { BOOT_STAGES } from '@expressive-tea/commons/constants';
-import { Express } from 'express';
-import Boot from '../classes/Boot';
+import { BOOT_STAGES } from '@expressive-tea/commons';
+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>;
-export declare function resolveProxy(ProxyContainer: any, server: Express): Promise<void>;
+export declare function resolveDirectives(instance: typeof Boot | Boot, server: Express): void;
+export declare function resolveStatic(instance: typeof Boot | Boot, server: Express): void;
+export declare function resolveProxy(ProxyContainer: any, server: Express): void;

package/helpers/boot-helper.js

@@ -1,17 +1,21 @@
 "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");
+exports.resolveStage = resolveStage;
+exports.resolveDirectives = resolveDirectives;
+exports.resolveStatic = resolveStatic;
+exports.resolveProxy = resolveProxy;
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return */
+const commons_1 = require("@expressive-tea/commons");
 const express = require("express");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
+const commons_2 = require("@expressive-tea/commons");
+const commons_3 = require("@expressive-tea/commons");
 const BootLoaderExceptions_1 = require("../exceptions/BootLoaderExceptions");
+const DependencyInjection_1 = require("../services/DependencyInjection");
 async function resolveStage(stage, ctx, server, ...extraArgs) {
     try {
         await bootloaderResolve(stage, server, ctx, ...extraArgs);
-        if (stage === constants_1.BOOT_STAGES.APPLICATION) {
-            await resolveModules(ctx, server);
+        if (stage === commons_1.BOOT_STAGES.APPLICATION) {
+            resolveModules(ctx, server);
         }
     }
     catch (e) {
@@ -20,16 +24,16 @@ async function resolveStage(stage, ctx, server, ...extraArgs) {
         }
     }
 }
-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)) || [];
+function resolveDirectives(instance, server) {
+    const registeredDirectives = commons_2.Metadata.get(commons_1.REGISTERED_DIRECTIVES_KEY, (0, commons_3.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;
-async function resolveStatic(instance, server) {
-    const registeredStatic = Metadata_1.default.get(constants_1.REGISTERED_STATIC_KEY, (0, object_helper_1.getClass)(instance)) || [];
+function resolveStatic(instance, server) {
+    const registeredStatic = commons_2.Metadata.get(commons_1.REGISTERED_STATIC_KEY, (0, commons_3.getClass)(instance)) || [];
     registeredStatic.forEach((staticOptions) => {
         if (staticOptions.virtual) {
             server.use(staticOptions.virtual, express.static(staticOptions.root, staticOptions.options));
@@ -39,21 +43,23 @@ async function resolveStatic(instance, server) {
         }
     });
 }
-exports.resolveStatic = resolveStatic;
-async function resolveProxy(ProxyContainer, server) {
+function resolveProxy(ProxyContainer, server) {
     const proxyContainer = new ProxyContainer();
     proxyContainer.__register(server);
 }
-exports.resolveProxy = resolveProxy;
-async function resolveModules(instance, server) {
-    const registeredModules = Metadata_1.default.get(constants_1.REGISTERED_MODULE_KEY, instance, 'start') || [];
-    registeredModules.forEach(Module => {
-        const moduleInstance = new Module();
+function resolveModules(instance, server) {
+    // Metadata is stored on the class by decorators, so we need to get the constructor
+    // If instance is already a class (typeof === 'function'), use it directly
+    // If instance is an object, get its constructor
+    const target = typeof instance === 'function' ? instance : instance.constructor;
+    const registeredModules = commons_2.Metadata.get(commons_1.REGISTERED_MODULE_KEY, target, 'start') || [];
+    for (const Module of registeredModules) {
+        const moduleInstance = (0, DependencyInjection_1.getInstanceOf)(Module);
         moduleInstance.__register(server);
-    });
+    }
 }
 async function bootloaderResolve(STAGE, server, instance, ...args) {
-    const bootLoader = Metadata_1.default.get(constants_1.BOOT_STAGES_KEY, (0, object_helper_1.getClass)(instance)) || constants_1.STAGES_INIT;
+    const bootLoader = commons_2.Metadata.get(commons_1.BOOT_STAGES_KEY, (0, commons_3.getClass)(instance)) || commons_1.STAGES_INIT;
     for (const loader of bootLoader[STAGE] || []) {
         try {
             await selectLoaderType(loader, server, ...args);
@@ -63,7 +69,7 @@ async function bootloaderResolve(STAGE, server, instance, ...args) {
         }
     }
 }
-async function selectLoaderType(loader, server, ...args) {
+function selectLoaderType(loader, server, ...args) {
     return loader.method(server, ...args);
 }
 function checkIfStageFails(e) {

package/helpers/decorators.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAnnotation = void 0;
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const constants_1 = require("@expressive-tea/commons/constants");
+exports.addAnnotation = addAnnotation;
+const commons_1 = require("@expressive-tea/commons");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const commons_2 = require("@expressive-tea/commons");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function addAnnotation(type, target, propertyKey, ...args) {
-    const annotations = Metadata_1.default.get(constants_1.ROUTER_ANNOTATIONS_KEY, target, propertyKey) || [];
+    const annotations = commons_1.Metadata.get(commons_2.ROUTER_ANNOTATIONS_KEY, target, propertyKey) || [];
     annotations.unshift({
         arguments: args,
         type
     });
-    Metadata_1.default.set(constants_1.ROUTER_ANNOTATIONS_KEY, annotations, target, propertyKey);
+    commons_1.Metadata.set(commons_2.ROUTER_ANNOTATIONS_KEY, annotations, target, propertyKey);
 }
-exports.addAnnotation = addAnnotation;

package/helpers/promise-helper.d.ts

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

package/helpers/promise-helper.js

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

package/helpers/server.d.ts

@@ -1,9 +1,35 @@
-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>;
+import { type NextFunction, type Request, type Response } from 'express';
+import { type ExpressiveTeaAnnotations, type ExpressiveTeaArgumentOptions } from '@expressive-tea/commons';
+import { type ExpressiveTeaHandlerOptionsWithInstrospectedArgs } from '../interfaces';
+import { TFunction } from '../types/core';
+import { type ExpressiveTeaServerProps } from '@expressive-tea/commons';
+interface ExecuteRequestContext {
+    options: ExpressiveTeaHandlerOptionsWithInstrospectedArgs;
+    decoratedArguments: ExpressiveTeaArgumentOptions[];
+    annotations: ExpressiveTeaAnnotations[];
+    self: any;
+}
+export interface FileSettingsResult {
+    config: ExpressiveTeaServerProps;
+    source: string | null;
+}
+export declare function autoResponse(_: any, response: Response, annotations: ExpressiveTeaAnnotations[], responseResult?: any): void;
+export declare function executeRequest(this: ExecuteRequestContext, request: Request, response: Response, next: NextFunction): Promise<void>;
 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;
+export declare function router(verb: string, route: string, target: any, handler: TFunction, propertyKey: string | symbol, settings?: any): void;
+/**
+ * Load configuration from .expressive-tea files.
+ *
+ * Supports YAML (.yaml, .yml) and JSON formats with priority order:
+ * 1. .expressive-tea.yaml (highest)
+ * 2. .expressive-tea.yml
+ * 3. .expressive-tea (JSON, lowest)
+ *
+ * @returns Configuration object and source file path
+ * @throws {Error} If config file is invalid (JSON/YAML parse error)
+ * @since 2.0.1
+ */
+export declare function fileSettings(): FileSettingsResult;
+export {};

package/helpers/server.js

@@ -1,101 +1,141 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileSettings = exports.router = exports.generateRoute = exports.extractParameters = exports.mapArguments = exports.executeRequest = exports.autoResponse = void 0;
-const lodash_1 = require("lodash");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const constants_1 = require("@expressive-tea/commons/constants");
-const RequestExceptions_1 = require("../exceptions/RequestExceptions");
-const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
-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);
+exports.autoResponse = autoResponse;
+exports.executeRequest = executeRequest;
+exports.mapArguments = mapArguments;
+exports.extractParameters = extractParameters;
+exports.generateRoute = generateRoute;
+exports.router = router;
+exports.fileSettings = fileSettings;
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return */
+const utilities_1 = require("../libs/utilities");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
+const commons_3 = require("@expressive-tea/commons");
+const fs = require("node:fs");
+const yaml = require("js-yaml");
+const path = require("node:path");
+function autoResponse(_, response, annotations, responseResult) {
+    const view = (0, utilities_1.find)(annotations, { type: 'view' });
+    if (view && view.arguments) {
+        response.render(view.arguments[0], responseResult);
+        return;
     }
-    response.send((0, lodash_1.isNumber)(responseResult) ? responseResult.toString() : responseResult);
+    response.send((0, utilities_1.isNumber)(responseResult) ? responseResult.toString() : responseResult);
 }
-exports.autoResponse = autoResponse;
 async function executeRequest(request, response, next) {
-    try {
-        let isNextUsed = false;
-        const nextWrapper = () => (error) => {
-            next(error);
+    let isNextUsed = false;
+    const nextWrapper = (error) => {
+        if (error) {
             isNextUsed = true;
-        };
-        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);
+            return next(error);
         }
+        isNextUsed = true;
+        next();
+    };
+    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(new RequestExceptions_1.GenericRequestException(e.message || 'System Error'));
-    }
+    // Express 5 handles async rejections automatically
 }
-exports.executeRequest = executeRequest;
 function mapArguments(decoratedArguments, request, response, next, introspectedArgs = []) {
-    return (0, lodash_1.chain)(decoratedArguments)
+    return (0, utilities_1.chain)(decoratedArguments)
         .sortBy('index')
         .map((argument) => {
         switch (argument.type) {
-            case constants_1.ARGUMENT_TYPES.REQUEST:
+            case commons_2.ARGUMENT_TYPES.REQUEST:
                 return request;
-            case constants_1.ARGUMENT_TYPES.RESPONSE:
+            case commons_2.ARGUMENT_TYPES.RESPONSE:
                 return response;
-            case constants_1.ARGUMENT_TYPES.NEXT:
+            case commons_2.ARGUMENT_TYPES.NEXT:
                 return next;
-            case constants_1.ARGUMENT_TYPES.QUERY:
-                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, (0, lodash_1.get)(introspectedArgs, argument.index));
-            case constants_1.ARGUMENT_TYPES.GET_PARAM:
-                return extractParameters(request.params, argument.arguments, (0, lodash_1.get)(introspectedArgs, argument.index));
+            case commons_2.ARGUMENT_TYPES.QUERY:
+                return extractParameters(request.query, argument.arguments, (0, utilities_1.get)(introspectedArgs, argument.index));
+            case commons_2.ARGUMENT_TYPES.BODY:
+                return extractParameters(request.body, argument.arguments, (0, utilities_1.get)(introspectedArgs, argument.index));
+            case commons_2.ARGUMENT_TYPES.GET_PARAM:
+                return extractParameters(request.params, argument.arguments, (0, utilities_1.get)(introspectedArgs, argument.index));
             default:
-                return;
+                return undefined;
         }
     })
-        .thru((args) => (0, lodash_1.size)(args) ? args : [request, response, next])
+        .thru((args) => (0, utilities_1.size)(args) ? args : [request, response, next])
         .value();
 }
-exports.mapArguments = mapArguments;
 function extractParameters(target, args, propertyName) {
     if (!args && !target) {
         return;
     }
-    if ((0, lodash_1.size)(args)) {
+    if (args && (0, utilities_1.size)(args)) {
         if (Array.isArray(args)) {
-            return (0, lodash_1.pick)(target, args);
+            return (0, utilities_1.pick)(target, args);
         }
-        return (0, lodash_1.get)(target, args);
+        return (0, utilities_1.get)(target, args);
     }
-    if ((0, lodash_1.has)(target, propertyName)) {
-        return (0, lodash_1.get)(target, propertyName);
+    if (propertyName && (0, utilities_1.has)(target, propertyName)) {
+        return (0, utilities_1.get)(target, propertyName);
     }
     return target;
 }
-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) || [];
+    const introspectedArgs = (0, commons_3.getOwnArgumentNames)(handler);
+    const existedRoutesHandlers = commons_1.Metadata.get(commons_2.ROUTER_HANDLERS_KEY, target) || [];
     existedRoutesHandlers.unshift({ verb, route, handler, target, propertyKey, settings, introspectedArgs });
-    Metadata_1.default.set(constants_1.ROUTER_HANDLERS_KEY, existedRoutesHandlers, target);
+    commons_1.Metadata.set(commons_2.ROUTER_HANDLERS_KEY, existedRoutesHandlers, target);
 }
-exports.router = router;
+/**
+ * Load configuration from .expressive-tea files.
+ *
+ * Supports YAML (.yaml, .yml) and JSON formats with priority order:
+ * 1. .expressive-tea.yaml (highest)
+ * 2. .expressive-tea.yml
+ * 3. .expressive-tea (JSON, lowest)
+ *
+ * @returns Configuration object and source file path
+ * @throws {Error} If config file is invalid (JSON/YAML parse error)
+ * @since 2.0.1
+ */
 function fileSettings() {
-    try {
-        if (fs.existsSync('.expressive-tea')) {
-            const configString = fs.readFileSync('.expressive-tea');
-            return JSON.parse(configString.toString());
+    const cwd = process.cwd();
+    // Priority order: YAML > YML > JSON
+    const configFiles = [
+        { path: '.expressive-tea.yaml', type: 'yaml' },
+        { path: '.expressive-tea.yml', type: 'yaml' },
+        { path: '.expressive-tea', type: 'json' }
+    ];
+    for (const file of configFiles) {
+        const filePath = path.join(cwd, file.path);
+        if (fs.existsSync(filePath)) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                let config;
+                if (file.type === 'yaml') {
+                    const parsed = yaml.load(content);
+                    // yaml.load returns undefined for empty strings and null for whitespace/comments
+                    // Treat empty YAML files as empty configuration objects
+                    config = (parsed !== null && parsed !== void 0 ? parsed : {});
+                }
+                else {
+                    config = JSON.parse(content);
+                }
+                // Debug log which file was loaded
+                console.debug(`[Expressive Tea] Loaded configuration from: ${file.path}`);
+                return { config, source: file.path };
+            }
+            catch (error) {
+                const errorMsg = file.type === 'yaml'
+                    ? `Invalid YAML in ${file.path}: ${error.message}`
+                    : `Invalid JSON in ${file.path}: ${error.message}`;
+                throw new Error(errorMsg);
+            }
         }
     }
-    catch (e) {
-        return {};
-    }
+    // No config file found
+    return { config: {}, source: null };
 }
-exports.fileSettings = fileSettings;

package/helpers/teapot-helper.d.ts

@@ -1,15 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { KeyPairSyncResult } from 'crypto';
-import { NextFunction, Request, Response } from 'express';
-import ProxyRoute from '../classes/ProxyRoute';
+import { type KeyPairSyncResult } from 'node:crypto';
+import { type NextFunction, type Request, type Response } from 'express';
+import type ProxyRoute from '../classes/ProxyRoute';
 export interface EncryptedMessage {
     iv: string;
     message: string;
+    authTag: 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;

package/helpers/teapot-helper.js

@@ -1,20 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const crypto = require("crypto");
+const crypto = require("node:crypto");
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return */
+const node_crypto_1 = require("node:crypto");
 class TeaGatewayHelper {
     static encrypt(data, signature) {
         const iv = crypto.randomBytes(16);
         const packet = JSON.stringify(data);
-        const cipher = crypto.createCipheriv('aes-256-ctr', signature, iv);
+        // HKDF key derivation - separate encryption key from signature
+        const derivedKey = Buffer.from(crypto.hkdfSync('sha256', signature, Buffer.alloc(32), 'expressive-tea-encryption', 32));
+        // AES-256-GCM - authenticated encryption
+        const cipher = crypto.createCipheriv('aes-256-gcm', derivedKey, iv);
         const encrypted = Buffer.concat([cipher.update(packet), cipher.final()]);
-        return { iv: iv.toString('hex'), message: encrypted.toString('base64') };
+        const authTag = cipher.getAuthTag();
+        return {
+            iv: iv.toString('hex'),
+            message: encrypted.toString('base64'),
+            authTag: authTag.toString('hex')
+        };
     }
     static decrypt(data, signature) {
+        // Input validation
+        if (!data || !data.iv || !data.message || !data.authTag) {
+            throw new Error('Invalid encrypted message format');
+        }
+        if (!signature || signature.length !== 64) {
+            throw new Error('Invalid signature');
+        }
         const iv = Buffer.from(data.iv, 'hex');
         const message = Buffer.from(data.message, 'base64');
-        const decipher = crypto.createDecipheriv('aes-256-ctr', signature, iv);
-        const decrypted = Buffer.concat([decipher.update(message), decipher.final()]);
-        return JSON.parse(decrypted.toString());
+        const authTag = Buffer.from(data.authTag, 'hex');
+        // HKDF key derivation - same as encrypt
+        const derivedKey = Buffer.from(crypto.hkdfSync('sha256', signature, Buffer.alloc(32), 'expressive-tea-encryption', 32));
+        // AES-256-GCM with auth tag verification
+        const decipher = crypto.createDecipheriv('aes-256-gcm', derivedKey, iv);
+        decipher.setAuthTag(authTag);
+        try {
+            const decrypted = Buffer.concat([decipher.update(message), decipher.final()]);
+            return JSON.parse(decrypted.toString());
+        }
+        catch (_a) {
+            throw new Error('Decryption failed: message tampered or wrong key');
+        }
     }
     static sign(data, privateKey, passphrase) {
         return crypto.sign(null, Buffer.from(data), {
@@ -28,8 +55,7 @@ class TeaGatewayHelper {
         }, signature);
     }
     static generateKeys(passphrase) {
-        const { generateKeyPairSync } = require('crypto');
-        return generateKeyPairSync('ed25519', {
+        return (0, node_crypto_1.generateKeyPairSync)('ed25519', {
             modulusLength: 2048,
             publicKeyEncoding: {
                 type: 'spki',
@@ -45,9 +71,11 @@ class TeaGatewayHelper {
     }
     static proxyResponse(proxyRoute, req, res, next) {
         const router = proxyRoute.registerRoute();
-        if (!proxyRoute.hasClients())
-            return next();
-        return router(req, res, next);
+        if (!proxyRoute.hasClients()) {
+            next();
+            return;
+        }
+        router(req, res, next);
     }
     static httpSchema(schema) {
         if (schema.includes('teapot'))

package/helpers/websocket-helper.d.ts

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

package/helpers/websocket-helper.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initWebsocket = void 0;
+exports.initWebsocket = initWebsocket;
 const WebsocketService_1 = require("../services/WebsocketService");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 const WebSocket = require("ws");
 const Settings_1 = require("../classes/Settings");
-async function initWebsocket(server, secureServer) {
+function initWebsocket(server, secureServer) {
     const settings = Settings_1.default.getInstance();
     const isDetached = settings.get('detachWebsocket');
     if (settings.get('startWebsocket')) {
@@ -17,4 +18,3 @@ async function initWebsocket(server, secureServer) {
         WebsocketService_1.default.getInstance().setHttpServer(secureServer);
     }
 }
-exports.initWebsocket = initWebsocket;

package/interfaces/index.d.ts

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

package/inversify.config.d.ts

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

package/inversify.config.js

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