@expressive-tea/core 2.0.0

package/decorators/router.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = Route;
+exports.Get = Get;
+exports.Post = Post;
+exports.Put = Put;
+exports.Patch = Patch;
+exports.Delete = Delete;
+exports.Param = Param;
+exports.Middleware = Middleware;
+exports.View = View;
+const commons_1 = require("@expressive-tea/commons");
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
+const decorators_1 = require("../helpers/decorators");
+const server_1 = require("../helpers/server");
+const commons_2 = require("@expressive-tea/commons");
+const route_1 = require("../mixins/route");
+/**
+ * @module Decorators/Router
+ */
+/**
+ * Route Controller Decorator assign a router point into the module mount-point placeholder and is used just to create
+ * a bucket to contains all the endpoints defined by method of the Controller.  If mount-point is not defined automati-
+ * cally this must considerate mounted on root, but is mandatory define the Controller with this decorator in order
+ * to allow Expressive Tea Setting up the Controller as part of a Module.
+ *
+ * @decorator {ClassDecorator} Route - Assign a route to controller endpoints.
+ * @template TBase - The base constructor type being decorated
+ * @param {string} mountpoint - Register the url part to mount the Controller (default: '/')
+ * @returns {(target: TBase) => RouterizedClass<TBase>} Decorator function that returns a routerized class
+ * @summary Generate a Placeholder endpoint root for controller routes.
+ *
+ * @example
+ * {REPLACE-AT}Route('/users')
+ * class UserController {
+ *   {REPLACE-AT}Get('/')
+ *   getUsers() { return ['user1', 'user2']; }
+ * }
+ *
+ * @since 1.0.0
+ */
+function Route(mountpoint = '/') {
+    return (RouterClass) => {
+        return (0, route_1.Routerize)(RouterClass, mountpoint);
+    };
+}
+/**
+ * Define a GET Endpoint response over the controller router and can define in which route should be responds and
+ * by default this is responding to everything on the controller root path.
+ * @decorator {MethodDecorator} Get - Create an GET Response over the designed route.
+ * @summary Define a GET Controller Endpoint on Controller.
+ * @param {string} route URL Part to mount create a handler.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}Get() // This Response to all GET Requests for controller route.
+ *   methodError() {}
+ *
+ *   {REPLACE-AT}Get('/data') // This Response to "/data" GET Requests for controller route.
+ *   methodData() {}
+ * }
+ *
+ */
+function Get(route = '*') {
+    return (0, server_1.generateRoute)(route, 'get');
+}
+/**
+ * Define a POST Endpoint response over the controller router and can define in which route should be responds and
+ * by default this is responding to everything on the controller root path.
+ * @decorator {MethodDecorator} POST - Create an POST Response over the designed route.
+ * @summary Define a POST Controller Endpoint on Controller.
+ * @param {string} route URL Part to mount create a handler.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}Post() // This Response to all GET Requests for controller route.
+ *   methodError() {}
+ *
+ *   {REPLACE-AT}Post('/data') // This Response to "/data" GET Requests for controller route.
+ *   methodData() {}
+ * }
+ *
+ */
+function Post(route = '*') {
+    return (0, server_1.generateRoute)(route, 'post');
+}
+/**
+ * Define a PUT Endpoint response over the controller router and can define in which route should be responds and
+ * by default this is responding to everything on the controller root path.
+ * @decorator {MethodDecorator} Put - Create an PUT Response over the designed route.
+ * @summary Define a PUT Controller Endpoint on Controller.
+ * @param {string} route URL Part to mount create a handler.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}Put() // This Response to all PUT Requests for controller route.
+ *   methodError() {}
+ *
+ *   {REPLACE-AT}Put('/data') // This Response to "/data" PUT Requests for controller route.
+ *   methodData() {}
+ * }
+ *
+ */
+function Put(route = '*') {
+    return (0, server_1.generateRoute)(route, 'put');
+}
+/**
+ * Define a PATCH Endpoint response over the controller router and can define in which route should be responds and
+ * by default this is responding to everything on the controller root path.
+ * @decorator {MethodDecorator} Patch - Create an PATCH Response over the designed route.
+ * @summary Define a PATCH Controller Endpoint on Controller.
+ * @param {string} route URL Part to mount create a handler.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}Patch() // This Response to all PATCH Requests for controller route.
+ *   methodError() {}
+ *
+ *   {REPLACE-AT}Patch('/data') // This Response to "/data" PATCH Requests for controller route.
+ *   methodData() {}
+ * }
+ *
+ */
+function Patch(route = '*') {
+    return (0, server_1.generateRoute)(route, 'patch');
+}
+/**
+ * Define a DELETE Endpoint response over the controller router and can define in which route should be responds and
+ * by default this is responding to everything on the controller root path.
+ * @decorator {MethodDecorator} Delete - Create an DELETE Response over the designed route.
+ * @summary Define a DELETE Controller Endpoint on Controller.
+ * @param {string} route URL Part to mount create a handler.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}Delete() // This Response to all DELETE Requests for controller route.
+ *   methodError() {}
+ *
+ *   {REPLACE-AT}Delete('/data') // This Response to "/data" DELETE Requests for controller route.
+ *   methodData() {}
+ * }
+ *
+ */
+function Delete(route = '*') {
+    return (0, server_1.generateRoute)(route, 'delete');
+}
+/**
+ * Define a Route path parameter transformation method as mentioned on Express this is just call by controller endpoints
+ * route paths and it helps to define logic on each route path parameters. Example, you can require transform userId
+ * parameter and added to request object.
+ *
+ * The method to response this must follow the Express callback notation (Request, Response, Next, paramValue) which
+ * also must be use Next method to allow continue the process flow from Express.
+ * @decorator {MethodDecorator} Param - Create a transformation middleware for router parameters.
+ * @summary Define a Parameter transformation on router path..
+ * @param {string} route URL Part to mount create a handler.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}Param('userId') // This Response to all GET Requests for controller route.
+ *   async methodError(req, res, next, param, id) {
+ *     const user = await User.find(id)
+ *     try {
+ *       if(!user) throw new Error('User not Found');
+ *
+ *       req.user = user;
+ *       next();
+ *     } catch(e) {
+ *       next(e);
+ *     }
+ *   }
+ *
+ *   {REPLACE-AT}Get('/:userId') // This Response to "/:userId" GET Requests for controller route.
+ *   methodData(req, res) {
+ *    res.json(req.user);
+ *   }
+ * }
+ *
+ */
+function Param(route = '*') {
+    return (0, server_1.generateRoute)(route, 'param');
+}
+/**
+ * Middleware Decorator is following the middleware functionality inheritance from Express framework itself and follow
+ * the same rules, that execute any code before response the request and can change the current request or response
+ * object, and requires use next callback to pass control to next middleware.
+ *
+ * This define the middlewares at Controller and Controller methods level, for application levels please see the
+ * Plug Decorator which can be useful to declare at that level..
+ * @decorator {MethodDecorator|ClassDecorator} Middleware - Attach a middleware definition on the root route or endpoint
+ * routes.
+ * @summary Assign a middleware to the Controller or Method route path flow.
+ * @example
+ * {REPLACE-AT}Middleware((req, res, next) {
+ *     req.controllerName = 'Example';
+ *     next();
+ *  })
+ * class ExampleController {
+ *   {REPLACE-AT}Get('/someResponse')
+ *   {REPLACE-AT}Middleware((req, res, next) {
+ *     req.methodName = 'someResponse';
+ *     next();
+ *   })
+ *   someRespone(req, res) {
+ *     res.send(`${req.controllerName}:${req.methodName}`);
+ *   }
+ * }
+ *
+ * @param {Function} middleware Register a middleware over router.
+ */
+function Middleware(middleware) {
+    return (target, property, descriptor) => {
+        if (property) {
+            routeMiddleware(target, descriptor, middleware);
+        }
+        else {
+            rootMiddleware(target, middleware);
+        }
+    };
+}
+/**
+ * Will generate a GET route to respond rendering a view template setting up before; the controller method <b>MUST</b>
+ * return an object in order to fulfilled the local variables into the view.
+ * @decorator {MethodDecorator}  View - Create a Vew Response over the designed route.
+ * @summary Define a View response endpoint on Controller.
+ * @param {string} viewName - View render layout name defined by configuration.
+ * @param {string} route - URL Part to mount create a handler.
+ * @return {object} Controller must return and object as local variables for the view.
+ * @example
+ * {REPLACE-AT}Route('/')
+ * class GenericController {
+ *   {REPLACE-AT}View('login', '/view') // This Response to all GET Requests for controller route.
+ *   methodError() {}
+ * }
+ *
+ */
+function View(viewName, route) {
+    route = route !== null && route !== void 0 ? route : `/${viewName}`;
+    return (target, propertyKey, descriptor) => {
+        (0, decorators_1.addAnnotation)('view', target, propertyKey, viewName);
+        (0, server_1.router)('get', route, target, descriptor.value, propertyKey);
+    };
+}
+function rootMiddleware(target, middleware) {
+    const existedRoutesHandlers = commons_1.Metadata.get(commons_2.ROUTER_MIDDLEWARES_KEY, target) || [];
+    existedRoutesHandlers.unshift(middleware);
+    commons_1.Metadata.set(commons_2.ROUTER_MIDDLEWARES_KEY, existedRoutesHandlers, target);
+}
+function routeMiddleware(_, descriptor, middleware) {
+    descriptor.value.$middlewares = descriptor.value.$middlewares || [];
+    descriptor.value.$middlewares.unshift(middleware);
+}

package/decorators/server.d.ts

@@ -0,0 +1,92 @@
+import { type Express } from 'express';
+import { type BOOT_STAGES } from '@expressive-tea/commons';
+import { type ExpressiveTeaPotSettings, type ExpressiveTeaServerProps, type ExpressiveTeaStaticFileServer, type ExpressiveTeaCupSettings } from '@expressive-tea/commons';
+import { Newable } from 'inversify';
+/**
+ * Plug Class Decorator create a simple plugin to execute in one of the public stages defined on BOOT_STAGES, might
+ * be useful to attach a simple Express Server configuration.
+ *
+ * @decorator {ClassDecorator} Plug - Simple Plugin Decorator.
+ * @summary This Decorators is add plugin initialization to one of the selected stages.
+ * @param {ExpressiveTeaModuleProps} options
+ * @param {BOOT_STAGES} stage   Boot Stage where the plugin should run or initialize.
+ * @param {string} name         Plugin Name (recommended short names)
+ * @param {Function} method     A Function to  initialize the plugin, it will get a express application as argument.
+ * @param {boolean} required    A Flag to let know if this is a hard requirement.
+ * @example
+ * {REPLACE-AT}Plug(BOOT_STAGES.BOOT_DEPENDENCIES, 'test', s => console.log, true)
+ * class Example extends Boot {}
+ */
+export declare function Plug(stage: BOOT_STAGES, name: string, method: (server?: Express, ...extraArgs: unknown[]) => Promise<void> | void, required?: boolean): (target: any) => void;
+/**
+ * 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
+ * since is allowing multi Boot Stage configuration and check other plugin dependencies.
+ *
+ * @decorator {ClassDecorator} Pour - Use Expressive Tea plugin definition instance.
+ * @summary Attach an Expressive Tea Definition Instance.
+ * @param Plugin - A Plugin Class which extends @expressive-tea/plugin/Plugin Class.
+ * @param pluginArgs any[] - Arguments passed directly to the Plugin constructor.
+ * @version 1.1.0
+ * @link https://www.npmjs.com/package/@expressive-tea/plugin Expressive Tea Plugin
+ */
+export declare function Pour(Plugin: Newable<any>, ...pluginArgs: any[]): (target: any) => void;
+/**
+ * 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.
+ * @decorator {ClassDecorator} ServerSettings - Declares Server Settings.
+ * @summary Declare Server Properties.
+ * @param {ExpressiveTeaModuleProps} options
+ */
+export declare function ServerSettings(options?: ExpressiveTeaServerProps): (target: any) => any;
+/**
+ * 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
+ * response, this module will instead call next() to move on to the next middleware, allowing for stacking
+ * and fall-backs. Check it out {@link https://expressjs.com/en/4x/api.html#express.static Express Static} to more
+ * information.
+ * @summary Static File Server
+ * @param {string} root - Root directory
+ * @param {string} [virtual=null] - Virtual Path
+ * @param {object} [options={}] - Static Server Options
+ * @decorator {ClassDecorator} Static - Create an Static mount static file server  on root directory
+ * with virtual path if defined.
+ */
+export declare function Static(root: string, virtual?: string | null, options?: ExpressiveTeaStaticFileServer): (target: any) => void;
+/**
+ * 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
+ * principle of app.set you should understand that is only apply the special settings mentioned above.
+ * @summary Express Setting Directive
+ * @param {string} name - Express Directive Setting Name
+ * @param {*} settings - Setting Arguments
+ * @decorator {ClassDecorator} ExpressDirective - Set a Express App Setting.
+ */
+export declare function ExpressDirective(name: string, ...settings: any[]): (target: any) => void;
+/**
+ * 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.
+ */
+export declare function Setting(): (target: any, propertyName: string) => any;
+/**
+ * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
+ * and register modules.
+ * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
+ * @summary This register the Module Classes created by the user.
+ * @param Modules
+ */
+export declare function Modules(Modules: any[]): (target: any) => void;
+export declare function Proxies(proxyContainers: any[]): (target: any) => void;
+/**
+ * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
+ * method with a Module Class.
+ * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
+ * @summary <b>ONLY</b> Decorate Start Method, this register the Module Classes created by the user.
+ * @param {Class} Module
+ * @deprecated Use the new decorator Modules that allow add modules into registered modules.
+ */
+export declare function RegisterModule(Module: any): (_: any, __: any) => never;
+export declare function Teapot(teapotSettings: ExpressiveTeaPotSettings): (target: object) => void;
+export declare function Teacup(teacupSettings: ExpressiveTeaCupSettings): (target: object) => void;

package/decorators/server.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 commons_2 = require("@expressive-tea/commons");
+const DependencyInjection_1 = require("../services/DependencyInjection");
+/**
+ * Define the Main Plugins Properties.
+ * @typedef {Object} ExpressiveTeaPluginProps
+ * @property {string} name - Define a Plugin Name
+ * @property {number} priority - Define a Plugin Priority.
+ * @summary Plugin Properties
+ */
+/**
+ * Declare an annotation only usable at Class Level Declaration
+ * @typedef {Function} ClassDecorator()
+ * @summary Class Decorator
+ * @example
+ * {REPLACE-AT}Decorator
+ * class Decorated {}
+ */
+/**
+ * Declare an annotation only usable at Method Class Level Declaration
+ * @typedef {Function} MethodDecorator
+ * @summary Method Decorator
+ * @example
+ * class Decorated {
+ *   {REPLACE-AT}MethodDecorator()
+ *   decoratedMethod(){}
+ * }
+ *
+ */
+/**
+ * Declare an annotation only usable at Property Class Level Declaration
+ * @typedef {Function} PropertyDecorator
+ * @summary Property Decorator
+ * @example
+ * class Decorated {
+ *   {REPLACE-AT}PropertyDecorator()
+ *   decoratedProperty:string = '';
+ * }
+ */
+/**
+ * Declare an annotation only usable at Property Class Level Declaration
+ * @module Decorators/Server
+ */
+function getStages(target) {
+    return commons_1.Metadata.get(commons_2.BOOT_STAGES_KEY, target) || {};
+}
+function getRegisteredPlugins(target) {
+    return commons_1.Metadata.get(commons_2.PLUGINS_KEY, target) || [];
+}
+function getStage(stage, target) {
+    const stages = getStages(target);
+    if (!stages[stage]) {
+        stages[stage] = [];
+    }
+    return stages[stage];
+}
+function setStage(stage, value, target) {
+    const stages = getStages(target);
+    stages[stage] = value;
+    commons_1.Metadata.set(commons_2.BOOT_STAGES_KEY, stages, target);
+}
+function setPlugins(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
+ * be useful to attach a simple Express Server configuration.
+ *
+ * @decorator {ClassDecorator} Plug - Simple Plugin Decorator.
+ * @summary This Decorators is add plugin initialization to one of the selected stages.
+ * @param {ExpressiveTeaModuleProps} options
+ * @param {BOOT_STAGES} stage   Boot Stage where the plugin should run or initialize.
+ * @param {string} name         Plugin Name (recommended short names)
+ * @param {Function} method     A Function to  initialize the plugin, it will get a express application as argument.
+ * @param {boolean} required    A Flag to let know if this is a hard requirement.
+ * @example
+ * {REPLACE-AT}Plug(BOOT_STAGES.BOOT_DEPENDENCIES, 'test', s => console.log, true)
+ * class Example extends Boot {}
+ */
+function Plug(stage, name, method, required = false) {
+    return (target) => {
+        const selectedStage = getStage(stage, target);
+        selectedStage.unshift({ method, required, name });
+        setStage(stage, selectedStage, target);
+    };
+}
+/**
+ * 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
+ * since is allowing multi Boot Stage configuration and check other plugin dependencies.
+ *
+ * @decorator {ClassDecorator} Pour - Use Expressive Tea plugin definition instance.
+ * @summary Attach an Expressive Tea Definition Instance.
+ * @param Plugin - A Plugin Class which extends @expressive-tea/plugin/Plugin Class.
+ * @param pluginArgs any[] - Arguments passed directly to the Plugin constructor.
+ * @version 1.1.0
+ * @link https://www.npmjs.com/package/@expressive-tea/plugin Expressive Tea Plugin
+ */
+function Pour(Plugin, ...pluginArgs) {
+    return (target) => {
+        const stages = getStages(target);
+        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));
+        commons_2.BOOT_STAGES_LIST.forEach(STAGE => {
+            setStage(STAGE, (stages[STAGE] || []).concat(instance.getRegisteredStage(STAGE)), target);
+        });
+        setPlugins((0, utilities_1.orderBy)(plugins, ['priority'], ['asc']), target);
+    };
+}
+/**
+ * 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.
+ * @decorator {ClassDecorator} ServerSettings - Declares Server Settings.
+ * @summary Declare Server Properties.
+ * @param {ExpressiveTeaModuleProps} options
+ */
+function ServerSettings(options = {}) {
+    return (target) => {
+        Settings_1.default.getInstance(target).merge(options);
+        return target;
+    };
+}
+/**
+ * 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
+ * response, this module will instead call next() to move on to the next middleware, allowing for stacking
+ * and fall-backs. Check it out {@link https://expressjs.com/en/4x/api.html#express.static Express Static} to more
+ * information.
+ * @summary Static File Server
+ * @param {string} root - Root directory
+ * @param {string} [virtual=null] - Virtual Path
+ * @param {object} [options={}] - Static Server Options
+ * @decorator {ClassDecorator} Static - Create an Static mount static file server  on root directory
+ * with virtual path if defined.
+ */
+function Static(root, virtual = null, options = {}) {
+    return (target) => {
+        if ((0, utilities_1.isNil)(root)) {
+            throw new Error('Root must be defined');
+        }
+        const registeredStatics = commons_1.Metadata.get(commons_2.REGISTERED_STATIC_KEY, target) || [];
+        registeredStatics.unshift({ root, options, virtual });
+        commons_1.Metadata.set(commons_2.REGISTERED_STATIC_KEY, registeredStatics, target);
+    };
+}
+/**
+ * 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
+ * principle of app.set you should understand that is only apply the special settings mentioned above.
+ * @summary Express Setting Directive
+ * @param {string} name - Express Directive Setting Name
+ * @param {*} settings - Setting Arguments
+ * @decorator {ClassDecorator} ExpressDirective - Set a Express App Setting.
+ */
+function ExpressDirective(name, ...settings) {
+    return (target) => {
+        if (!commons_2.EXPRESS_DIRECTIVES.includes(name)) {
+            throw new Error(`Directive Name ${name} is not valid express behavior setting`);
+        }
+        const registeredDirectives = commons_1.Metadata.get(commons_2.REGISTERED_DIRECTIVES_KEY, target) || [];
+        registeredDirectives.unshift({ name, settings });
+        commons_1.Metadata.set(commons_2.REGISTERED_DIRECTIVES_KEY, registeredDirectives, target);
+    };
+}
+/**
+ * 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.
+ */
+function Setting() {
+    return (target, propertyName) => {
+        Object.defineProperty(target, propertyName, {
+            configurable: false,
+            get: () => Settings_1.default.getInstance(target).get(propertyName)
+        });
+    };
+}
+/**
+ * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
+ * and register modules.
+ * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
+ * @summary This register the Module Classes created by the user.
+ * @param Modules
+ */
+function Modules(Modules) {
+    return (target) => {
+        for (const Module of Modules) {
+            const registeredModules = commons_1.Metadata.get(commons_2.REGISTERED_MODULE_KEY, target, 'start') || [];
+            registeredModules.unshift(Module);
+            commons_1.Metadata.set(commons_2.REGISTERED_MODULE_KEY, registeredModules, target, 'start');
+        }
+    };
+}
+function Proxies(proxyContainers) {
+    return (target) => {
+        for (const proxyContainer of proxyContainers) {
+            const registeredProxyContainers = commons_1.Metadata.get(commons_2.ROUTER_PROXIES_KEY, target) || [];
+            registeredProxyContainers.unshift(proxyContainer);
+            commons_1.Metadata.set(commons_2.ROUTER_PROXIES_KEY, registeredProxyContainers, target);
+        }
+    };
+}
+/**
+ * Register Module Method Decorator this Method Decorator is used at bootstrap level and should decorate the start
+ * method with a Module Class.
+ * @decorator {MethodDecorator} RegisterModule - Register a Expressive Tea module to application.
+ * @summary <b>ONLY</b> Decorate Start Method, this register the Module Classes created by the user.
+ * @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 (_, __) => {
+        throw new Error('RegisterModule is deprecated, use the new decorator Modules that allow add modules into registered modules.');
+    };
+}
+function Teapot(teapotSettings) {
+    return (target) => {
+        commons_1.Metadata.set(commons_2.ASSIGN_TEAPOT_KEY, true, target, 'isTeapotActive');
+        commons_1.Metadata.set(commons_2.ASSIGN_TEAPOT_KEY, teapotSettings, target);
+    };
+}
+function Teacup(teacupSettings) {
+    return (target) => {
+        commons_1.Metadata.set(commons_2.ASSIGN_TEACUP_KEY, true, target, 'isTeacupActive');
+        commons_1.Metadata.set(commons_2.ASSIGN_TEACUP_KEY, teacupSettings, target);
+    };
+}

package/engines/constants/constants.d.ts

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

package/engines/constants/constants.js

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