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

package/helpers/server.d.ts

@@ -1,9 +1,35 @@
 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>;
+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[]) => never | 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,103 +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) {
+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) {
-            next(e);
-            return;
-        }
-        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 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,11 +1,10 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { type KeyPairSyncResult } from 'crypto';
+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 type TeaGatewayMessage = Record<string, any>;
 export default class TeaGatewayHelper {

package/helpers/teapot-helper.js

@@ -1,21 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const crypto = require("crypto");
-const crypto_1 = 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), {
@@ -29,7 +55,7 @@ class TeaGatewayHelper {
         }, signature);
     }
     static generateKeys(passphrase) {
-        return (0, crypto_1.generateKeyPairSync)('ed25519', {
+        return (0, node_crypto_1.generateKeyPairSync)('ed25519', {
             modulusLength: 2048,
             publicKeyEncoding: {
                 type: 'spki',

package/helpers/websocket-helper.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type * as http from 'http';
 import type * as https from 'https';
-export declare function initWebsocket(server: http.Server, secureServer: https.Server): Promise<void>;
+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 { type 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").interfaces.Newable<any> | import("inversify").interfaces.Abstract<any>) => (proto: any, key: string) => void;
-    lazyInjectNamed: (serviceIdentifier: string | symbol | import("inversify").interfaces.Newable<any> | import("inversify").interfaces.Abstract<any>, named: string) => (proto: any, key: string) => void;
-    lazyInjectTagged: (serviceIdentifier: string | symbol | import("inversify").interfaces.Newable<any> | import("inversify").interfaces.Abstract<any>, key: string, value: any) => (proto: any, propertyName: string) => void;
-    lazyMultiInject: (serviceIdentifier: string | symbol | import("inversify").interfaces.Newable<any> | import("inversify").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;