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

package/decorators/server.js

@@ -1,10 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Teacup = exports.Teapot = exports.RegisterModule = exports.Proxies = exports.Modules = exports.Setting = exports.ExpressDirective = exports.Static = exports.ServerSettings = exports.Pour = exports.Plug = void 0;
-const lodash_1 = require("lodash");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
+exports.Plug = Plug;
+exports.Pour = Pour;
+exports.ServerSettings = ServerSettings;
+exports.Static = Static;
+exports.ExpressDirective = ExpressDirective;
+exports.Setting = Setting;
+exports.Modules = Modules;
+exports.Proxies = Proxies;
+exports.RegisterModule = RegisterModule;
+exports.Teapot = Teapot;
+exports.Teacup = Teacup;
+const utilities_1 = require("../libs/utilities");
+const commons_1 = require("@expressive-tea/commons");
 const Settings_1 = require("../classes/Settings");
-const constants_1 = require("@expressive-tea/commons/constants");
+const commons_2 = require("@expressive-tea/commons");
+const DependencyInjection_1 = require("../services/DependencyInjection");
 /**
  * Define the Main Plugins Properties.
  * @typedef {Object} ExpressiveTeaPluginProps
@@ -46,10 +57,10 @@ const constants_1 = require("@expressive-tea/commons/constants");
  * @module Decorators/Server
  */
 function getStages(target) {
-    return Metadata_1.default.get(constants_1.BOOT_STAGES_KEY, target) || {};
+    return commons_1.Metadata.get(commons_2.BOOT_STAGES_KEY, target) || {};
 }
 function getRegisteredPlugins(target) {
-    return Metadata_1.default.get(constants_1.PLUGINS_KEY, target) || [];
+    return commons_1.Metadata.get(commons_2.PLUGINS_KEY, target) || [];
 }
 function getStage(stage, target) {
     const stages = getStages(target);
@@ -61,10 +72,10 @@ function getStage(stage, target) {
 function setStage(stage, value, target) {
     const stages = getStages(target);
     stages[stage] = value;
-    Metadata_1.default.set(constants_1.BOOT_STAGES_KEY, stages, target);
+    commons_1.Metadata.set(commons_2.BOOT_STAGES_KEY, stages, target);
 }
 function setPlugins(plugins, target) {
-    Metadata_1.default.set(constants_1.PLUGINS_KEY, plugins, target);
+    commons_1.Metadata.set(commons_2.PLUGINS_KEY, plugins, target);
 }
 /**
  * Plug Class Decorator create a simple plugin to execute in one of the public stages defined on BOOT_STAGES, might
@@ -88,7 +99,6 @@ function Plug(stage, name, method, required = false) {
         setStage(stage, selectedStage, target);
     };
 }
-exports.Plug = Plug;
 /**
  * Since version 1.1.0 Expressive Tea allow to use external plugins using the node
  * package @expressive-tea/plugin. This plugin engine allows to create more complex plugin configuration and provision
@@ -104,15 +114,17 @@ exports.Plug = Plug;
 function Pour(Plugin, ...pluginArgs) {
     return (target) => {
         const stages = getStages(target);
-        const instance = new Plugin(...pluginArgs);
+        DependencyInjection_1.default.Container.bind(Plugin)
+            .toDynamicValue(() => new Plugin(...pluginArgs))
+            .inSingletonScope();
+        const instance = DependencyInjection_1.default.Container.get(Plugin);
         const plugins = instance.register(Settings_1.default.getInstance(target).getOptions(), getRegisteredPlugins(target));
-        constants_1.BOOT_STAGES_LIST.forEach(STAGE => {
+        commons_2.BOOT_STAGES_LIST.forEach(STAGE => {
             setStage(STAGE, (stages[STAGE] || []).concat(instance.getRegisteredStage(STAGE)), target);
         });
-        setPlugins((0, lodash_1.orderBy)(plugins, ['priority'], ['asc']), target);
+        setPlugins((0, utilities_1.orderBy)(plugins, ['priority'], ['asc']), target);
     };
 }
-exports.Pour = Pour;
 /**
  * Server Settings Singleton Class Decorator this Provide the Configuration to the server or another component on
  * the projects,is working as a container to store user and library settings.
@@ -121,12 +133,11 @@ exports.Pour = Pour;
  * @param {ExpressiveTeaModuleProps} options
  */
 function ServerSettings(options = {}) {
-    return target => {
+    return (target) => {
         Settings_1.default.getInstance(target).merge(options);
         return target;
     };
 }
-exports.ServerSettings = ServerSettings;
 /**
  * Create a new middleware function to serve files from within a given root directory. The file to serve will be
  * determined by combining req.url with the provided root directory. When a file is not found, instead of sending a 404
@@ -141,16 +152,15 @@ exports.ServerSettings = ServerSettings;
  * with virtual path if defined.
  */
 function Static(root, virtual = null, options = {}) {
-    return target => {
-        if ((0, lodash_1.isNil)(root)) {
+    return (target) => {
+        if ((0, utilities_1.isNil)(root)) {
             throw new Error('Root must be defined');
         }
-        const registeredStatics = Metadata_1.default.get(constants_1.REGISTERED_STATIC_KEY, target) || [];
+        const registeredStatics = commons_1.Metadata.get(commons_2.REGISTERED_STATIC_KEY, target) || [];
         registeredStatics.unshift({ root, options, virtual });
-        Metadata_1.default.set(constants_1.REGISTERED_STATIC_KEY, registeredStatics, target);
+        commons_1.Metadata.set(commons_2.REGISTERED_STATIC_KEY, registeredStatics, target);
     };
 }
-exports.Static = Static;
 /**
  * Set or Update Express application settings, and allow to change the behavior of the server where is listed on the
  * next link {@link http://expressjs.com/en/4x/api.html#app.settings.table Express Settings} as this is using the same
@@ -161,24 +171,22 @@ exports.Static = Static;
  * @decorator {ClassDecorator} ExpressDirective - Set a Express App Setting.
  */
 function ExpressDirective(name, ...settings) {
-    return target => {
-        if (!constants_1.EXPRESS_DIRECTIVES.includes(name)) {
+    return (target) => {
+        if (!commons_2.EXPRESS_DIRECTIVES.includes(name)) {
             throw new Error(`Directive Name ${name} is not valid express behavior setting`);
         }
-        const registeredDirectives = Metadata_1.default.get(constants_1.REGISTERED_DIRECTIVES_KEY, target) || [];
+        const registeredDirectives = commons_1.Metadata.get(commons_2.REGISTERED_DIRECTIVES_KEY, target) || [];
         registeredDirectives.unshift({ name, settings });
-        Metadata_1.default.set(constants_1.REGISTERED_DIRECTIVES_KEY, registeredDirectives, target);
+        commons_1.Metadata.set(commons_2.REGISTERED_DIRECTIVES_KEY, registeredDirectives, target);
     };
 }
-exports.ExpressDirective = ExpressDirective;
 /**
  * Setting Property Decorator Automatically assign a settings declared on Settings Service into the decorated property.
  * All properties will contains the settings value or undefined if current settings is not founded.
  * @decorator {PropertyDecorator} Setting - Assign Server Settings to Property as default value.
  * @summary Automatically assign a settings declared on the Server Settings decorator to a class property.
- * @param {string} settingName The Setting name tha
  */
-function Setting(settingName) {
+function Setting() {
     return (target, propertyName) => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
@@ -186,7 +194,6 @@ function Setting(settingName) {
         });
     };
 }
-exports.Setting = Setting;
 /**
  * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
  * and register modules.
@@ -195,25 +202,23 @@ exports.Setting = Setting;
  * @param Modules
  */
 function Modules(Modules) {
-    return target => {
+    return (target) => {
         for (const Module of Modules) {
-            const registeredModules = Metadata_1.default.get(constants_1.REGISTERED_MODULE_KEY, target, 'start') || [];
+            const registeredModules = commons_1.Metadata.get(commons_2.REGISTERED_MODULE_KEY, target, 'start') || [];
             registeredModules.unshift(Module);
-            Metadata_1.default.set(constants_1.REGISTERED_MODULE_KEY, registeredModules, target, 'start');
+            commons_1.Metadata.set(commons_2.REGISTERED_MODULE_KEY, registeredModules, target, 'start');
         }
     };
 }
-exports.Modules = Modules;
 function Proxies(proxyContainers) {
-    return target => {
+    return (target) => {
         for (const proxyContainer of proxyContainers) {
-            const registeredProxyContainers = Metadata_1.default.get(constants_1.ROUTER_PROXIES_KEY, target) || [];
+            const registeredProxyContainers = commons_1.Metadata.get(commons_2.ROUTER_PROXIES_KEY, target) || [];
             registeredProxyContainers.unshift(proxyContainer);
-            Metadata_1.default.set(constants_1.ROUTER_PROXIES_KEY, registeredProxyContainers, target);
+            commons_1.Metadata.set(commons_2.ROUTER_PROXIES_KEY, registeredProxyContainers, target);
         }
     };
 }
-exports.Proxies = Proxies;
 /**
  * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
  * method with a Module Class.
@@ -222,28 +227,21 @@ exports.Proxies = Proxies;
  * @param {Class} Module
  * @deprecated Use the new decorator Modules that allow add modules into registered modules.
  */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function RegisterModule(Module) {
-    return (target, property) => {
-        if (property !== 'start') {
-            throw new Error('Register Module needs to decorate ONLY start method');
-        }
-        const registeredModules = Metadata_1.default.get(constants_1.REGISTERED_MODULE_KEY, target, property) || [];
-        registeredModules.push(Module);
-        Metadata_1.default.set(constants_1.REGISTERED_MODULE_KEY, registeredModules, target, property);
+    return (_, __) => {
+        throw new Error('RegisterModule is deprecated, use the new decorator Modules that allow add modules into registered modules.');
     };
 }
-exports.RegisterModule = RegisterModule;
 function Teapot(teapotSettings) {
     return (target) => {
-        Metadata_1.default.set(constants_1.ASSIGN_TEAPOT_KEY, true, target, 'isTeapotActive');
-        Metadata_1.default.set(constants_1.ASSIGN_TEAPOT_KEY, teapotSettings, target);
+        commons_1.Metadata.set(commons_2.ASSIGN_TEAPOT_KEY, true, target, 'isTeapotActive');
+        commons_1.Metadata.set(commons_2.ASSIGN_TEAPOT_KEY, teapotSettings, target);
     };
 }
-exports.Teapot = Teapot;
 function Teacup(teacupSettings) {
     return (target) => {
-        Metadata_1.default.set(constants_1.ASSIGN_TEACUP_KEY, true, target, 'isTeacupActive');
-        Metadata_1.default.set(constants_1.ASSIGN_TEACUP_KEY, teacupSettings, target);
+        commons_1.Metadata.set(commons_2.ASSIGN_TEACUP_KEY, true, target, 'isTeacupActive');
+        commons_1.Metadata.set(commons_2.ASSIGN_TEACUP_KEY, teacupSettings, target);
     };
 }
-exports.Teacup = Teacup;

package/engines/health/index.d.ts

@@ -0,0 +1,120 @@
+import ExpressiveTeaEngine from '../../classes/Engine';
+/**
+ * Health check status
+ * @since 2.0.0
+ */
+export type HealthStatus = 'pass' | 'fail' | 'warn';
+/**
+ * Individual health check result
+ * @since 2.0.0
+ */
+export interface HealthCheckResult {
+    /** Check status */
+    status: HealthStatus;
+    /** Optional details about the check */
+    details?: Record<string, any>;
+    /** Optional error message if failed */
+    error?: string;
+}
+/**
+ * Health check function
+ * @since 2.0.0
+ */
+export type HealthCheckFunction = () => Promise<HealthCheckResult> | HealthCheckResult;
+/**
+ * Health check definition
+ * @since 2.0.0
+ */
+export interface HealthCheck {
+    /** Unique name for this health check */
+    name: string;
+    /** The check function to execute */
+    check: HealthCheckFunction;
+    /** Whether this check is critical for readiness */
+    critical?: boolean;
+    /** Optional timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Health Check Engine
+ *
+ * Provides standardized health check endpoints for monitoring and orchestration:
+ * - `/health` - Detailed health status with all checks
+ * - `/health/live` - Liveness probe (always 200 if server is running)
+ * - `/health/ready` - Readiness probe (200 only if all critical checks pass)
+ *
+ * Compatible with Kubernetes liveness and readiness probes.
+ *
+ * @class HealthCheckEngine
+ * @extends ExpressiveTeaEngine
+ * @since 2.0.0
+ * @summary Standardized health check endpoints for monitoring
+ *
+ * @example
+ * // Enable health checks with custom checks
+ * @HealthCheck({
+ *   checks: [
+ *     {
+ *       name: 'database',
+ *       check: async () => {
+ *         const isConnected = await db.ping();
+ *         return { status: isConnected ? 'pass' : 'fail' };
+ *       },
+ *       critical: true,
+ *       timeout: 5000
+ *     },
+ *     {
+ *       name: 'cache',
+ *       check: async () => {
+ *         const isReady = await redis.ping();
+ *         return {
+ *           status: isReady ? 'pass' : 'warn',
+ *           details: { connected: isReady }
+ *         };
+ *       }
+ *     }
+ *   ]
+ * })
+ * class MyApp extends Boot {}
+ */
+export default class HealthCheckEngine extends ExpressiveTeaEngine {
+    private checks;
+    /**
+     * Register a health check
+     * @param check - Health check configuration
+     * @since 2.0.0
+     */
+    registerCheck(check: HealthCheck): void;
+    /**
+     * Execute a single health check with timeout
+     * @param check - Health check to execute
+     * @returns Check result
+     * @private
+     */
+    private executeCheck;
+    /**
+     * Initialize health check routes
+     * @since 2.0.0
+     */
+    init(): Promise<void>;
+    /**
+     * Start the health check engine
+     * @since 2.0.0
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the health check engine
+     * @since 2.0.0
+     */
+    stop(): Promise<void>;
+    /**
+     * Determine if this engine should be registered
+     *
+     * Health checks are enabled by default for all applications.
+     * To disable, set `enableHealthChecks: false` in ServerSettings.
+     *
+     * @returns true if health checks should be enabled
+     * @since 2.0.0
+     */
+    static canRegister(): boolean;
+}

package/engines/health/index.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+const Engine_1 = require("../../classes/Engine");
+/**
+ * Health Check Engine
+ *
+ * Provides standardized health check endpoints for monitoring and orchestration:
+ * - `/health` - Detailed health status with all checks
+ * - `/health/live` - Liveness probe (always 200 if server is running)
+ * - `/health/ready` - Readiness probe (200 only if all critical checks pass)
+ *
+ * Compatible with Kubernetes liveness and readiness probes.
+ *
+ * @class HealthCheckEngine
+ * @extends ExpressiveTeaEngine
+ * @since 2.0.0
+ * @summary Standardized health check endpoints for monitoring
+ *
+ * @example
+ * // Enable health checks with custom checks
+ * @HealthCheck({
+ *   checks: [
+ *     {
+ *       name: 'database',
+ *       check: async () => {
+ *         const isConnected = await db.ping();
+ *         return { status: isConnected ? 'pass' : 'fail' };
+ *       },
+ *       critical: true,
+ *       timeout: 5000
+ *     },
+ *     {
+ *       name: 'cache',
+ *       check: async () => {
+ *         const isReady = await redis.ping();
+ *         return {
+ *           status: isReady ? 'pass' : 'warn',
+ *           details: { connected: isReady }
+ *         };
+ *       }
+ *     }
+ *   ]
+ * })
+ * class MyApp extends Boot {}
+ */
+let HealthCheckEngine = class HealthCheckEngine extends Engine_1.default {
+    constructor() {
+        super(...arguments);
+        this.checks = [];
+    }
+    /**
+     * Register a health check
+     * @param check - Health check configuration
+     * @since 2.0.0
+     */
+    registerCheck(check) {
+        this.checks.push(check);
+    }
+    /**
+     * Execute a single health check with timeout
+     * @param check - Health check to execute
+     * @returns Check result
+     * @private
+     */
+    async executeCheck(check) {
+        const timeout = check.timeout || 5000;
+        try {
+            const result = await Promise.race([
+                Promise.resolve(check.check()),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Health check timeout')), timeout)),
+            ]);
+            return result;
+        }
+        catch (error) {
+            return {
+                status: 'fail',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Initialize health check routes
+     * @since 2.0.0
+     */
+    async init() {
+        const app = this.context.getApplication();
+        // Detailed health endpoint
+        app.get('/health', async (_req, res) => {
+            const results = {};
+            let overallStatus = 'pass';
+            // Execute all checks in parallel
+            await Promise.all(this.checks.map(async (check) => {
+                const result = await this.executeCheck(check);
+                results[check.name] = result;
+                // Update overall status
+                if (result.status === 'fail') {
+                    overallStatus = 'fail';
+                }
+                else if (result.status === 'warn' && overallStatus === 'pass') {
+                    overallStatus = 'warn';
+                }
+            }));
+            const statusCode = overallStatus === 'pass' ? 200 : overallStatus === 'warn' ? 200 : 503;
+            res.status(statusCode).json({
+                status: overallStatus,
+                timestamp: new Date().toISOString(),
+                checks: results,
+            });
+        });
+        // Liveness probe - always returns 200 if server is running
+        app.get('/health/live', (_req, res) => {
+            res.status(200).json({
+                status: 'pass',
+                timestamp: new Date().toISOString(),
+            });
+        });
+        // Readiness probe - returns 200 only if all critical checks pass
+        app.get('/health/ready', async (_req, res) => {
+            const criticalChecks = this.checks.filter((c) => c.critical);
+            if (criticalChecks.length === 0) {
+                // No critical checks, always ready
+                res.status(200).json({
+                    status: 'pass',
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            const results = {};
+            let isReady = true;
+            // Execute only critical checks
+            await Promise.all(criticalChecks.map(async (check) => {
+                const result = await this.executeCheck(check);
+                results[check.name] = result;
+                if (result.status === 'fail') {
+                    isReady = false;
+                }
+            }));
+            res.status(isReady ? 200 : 503).json({
+                status: isReady ? 'pass' : 'fail',
+                timestamp: new Date().toISOString(),
+                checks: results,
+            });
+        });
+    }
+    /**
+     * Start the health check engine
+     * @since 2.0.0
+     */
+    async start() {
+        // Nothing to start - routes are already registered
+    }
+    /**
+     * Stop the health check engine
+     * @since 2.0.0
+     */
+    async stop() {
+        // Clear checks on shutdown
+        this.checks = [];
+    }
+    /**
+     * Determine if this engine should be registered
+     *
+     * Health checks are enabled by default for all applications.
+     * To disable, set `enableHealthChecks: false` in ServerSettings.
+     *
+     * @returns true if health checks should be enabled
+     * @since 2.0.0
+     */
+    static canRegister() {
+        return true;
+    }
+};
+HealthCheckEngine = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
+], HealthCheckEngine);
+exports.default = HealthCheckEngine;

package/engines/http/index.d.ts

@@ -1,13 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import * as http from 'http';
-import * as https from 'https';
-import { BOOT_STAGES } from '@expressive-tea/commons/constants';
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { BOOT_STAGES } from '@expressive-tea/commons';
 import ExpressiveTeaEngine from '../../classes/Engine';
 export default class HTTPEngine extends ExpressiveTeaEngine {
     private listen;
     start(): Promise<(http.Server | https.Server)[]>;
     init(): Promise<void>;
-    resolveStages(stages: BOOT_STAGES[], ...extraArgs: any[]): Promise<void[]>;
-    resolveProxyContainers(): Promise<void>;
+    resolveStages(stages: BOOT_STAGES[], ...extraArgs: unknown[]): Promise<unknown[]>;
+    resolveProxyContainers(): void;
+    static canRegister(): boolean;
 }

package/engines/http/index.js

@@ -3,14 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 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");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
+const commons_3 = require("@expressive-tea/commons");
 const Engine_1 = require("../../classes/Engine");
 let HTTPEngine = class HTTPEngine extends Engine_1.default {
-    listen(server, port) {
+    async listen(server, port) {
         return new Promise((resolve, reject) => {
-            console.log('Listening on port', port, server.listen);
             server.listen(port);
             server.on('error', error => {
                 reject(error);
@@ -22,33 +21,39 @@ let HTTPEngine = class HTTPEngine extends Engine_1.default {
         });
     }
     async start() {
-        console.log(`Starting Server Test`);
-        const listenerServers = [
+        const servers = [
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             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);
+        const listenerServers = servers.filter((server) => server !== null);
+        await this.resolveStages([commons_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());
+        (0, boot_helper_1.resolveDirectives)(this.context, this.context.getApplication());
+        (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);
+        this.resolveProxyContainers();
+        await this.resolveStages(commons_1.BOOT_ORDER);
+        await this.resolveStages([commons_1.BOOT_STAGES.AFTER_APPLICATION_MIDDLEWARES, commons_1.BOOT_STAGES.ON_HTTP_CREATION], this.server, this.serverSecure);
     }
     async resolveStages(stages, ...extraArgs) {
-        return Promise.all(stages.map(s => (0, boot_helper_1.resolveStage)(s, this.context, this.context.getApplication(), ...extraArgs)));
+        return Promise.all(stages.map(async (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)) || [];
+    resolveProxyContainers() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const ProxyContainers = commons_3.Metadata.get(commons_1.ROUTER_PROXIES_KEY, (0, commons_2.getClass)(this.context)) || [];
         for (const Container of ProxyContainers) {
             (0, boot_helper_1.resolveProxy)(Container, this.context.getApplication());
         }
     }
+    static canRegister() {
+        return true;
+    }
 };
 HTTPEngine = tslib_1.__decorate([
-    (0, inversify_1.injectable)()
+    (0, inversify_1.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
 ], HTTPEngine);
 exports.default = HTTPEngine;

package/engines/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Core Engine Registration
+ *
+ * Automatically registers all core Expressive Tea engines with the EngineRegistry.
+ * Import this file to enable all core engines with proper dependency order.
+ *
+ * Engine Priority Order:
+ * - 0: HTTPEngine (base engine, no dependencies)
+ * - 5: HealthCheckEngine (health endpoints, depends on http)
+ * - 10: SocketIOEngine, WebsocketEngine (depend on http)
+ * - 20: TeapotEngine, TeacupEngine (depend on http, socketio)
+ *
+ * @example
+ * ```typescript
+ * import '@expressive-tea/core/engines'; // Registers all core engines
+ * import Boot from '@expressive-tea/core';
+ *
+ * class MyApp extends Boot {}
+ * ```
+ *
+ * @module engines
+ * @since 2.0.0
+ */
+import EngineRegistry from '../classes/EngineRegistry';
+import HTTPEngine from './http';
+import HealthCheckEngine from './health';
+import SocketIOEngine from './socketio';
+import WebsocketEngine from './websocket';
+import TeapotEngine from './teapot';
+import TeacupEngine from './teacup';
+export { HTTPEngine, HealthCheckEngine, SocketIOEngine, WebsocketEngine, TeapotEngine, TeacupEngine };
+export default EngineRegistry;