@zanobijs/core 1.2.0 → 2.0.0-beta.0

package/lib/cjs/exceptions/circularModuleImport.exception.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var runtime_exception = require('@zanobijs/common/exceptions/runtime.exception');
+var constant_message = require('./constant.message.js');
+
+/**
+ * Excepción lanzada cuando el grafo de `imports` entre módulos contiene un
+ * ciclo: un módulo importa, directa o indirectamente, a otro módulo que ya
+ * lo está importando a él.
+ *
+ * @remarks
+ * Esta clase extiende la base `RuntimeException` de @zanobijs/common
+ * para proporcionar detalles adicionales del error.
+ */
+class CircularModuleImportException extends runtime_exception.RuntimeException {
+    constructor(chain) {
+        super(constant_message.CIRCULAR_MODULE_IMPORT_ERROR(chain));
+    }
+}
+
+exports.CircularModuleImportException = CircularModuleImportException;

package/{exceptions → lib/cjs/exceptions}/constant.message.js

@@ -1,11 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROVIDER_INVALID_MODULE_ERROR = exports.CONTAINER_RESOLUTION_ENTITY_ERROR = exports.CONTAINER_RESOLUTION_ERROR = exports.MODULE_INVALID_ANNOTATION_ERROR = void 0;
+'use strict';
+
 const MODULE_INVALID_ANNOTATION_ERROR = () => 'The class must have an annotation @Module()';
-exports.MODULE_INVALID_ANNOTATION_ERROR = MODULE_INVALID_ANNOTATION_ERROR;
 const CONTAINER_RESOLUTION_ERROR = (entity, resolutionError) => `${resolutionError} please review '${entity}' and its dependencies.`;
-exports.CONTAINER_RESOLUTION_ERROR = CONTAINER_RESOLUTION_ERROR;
 const CONTAINER_RESOLUTION_ENTITY_ERROR = (entity) => `Please check that the entity '${entity}' exists and is registered in @modulo`;
-exports.CONTAINER_RESOLUTION_ENTITY_ERROR = CONTAINER_RESOLUTION_ENTITY_ERROR;
 const PROVIDER_INVALID_MODULE_ERROR = (entity, moduleName) => `Please check that ${entity} located in the @module ${moduleName} exists and is @Injectable().`;
+const MISSING_INJECT_TOKEN_ERROR = (token, targetName, moduleName) => `Cannot inject @Inject('${token}') into '${targetName}': the provider '${token}' is not registered in '${moduleName}' or any other previously loaded module.`;
+const CIRCULAR_MODULE_IMPORT_ERROR = (chain) => `Circular module import detected: ${chain}. A module cannot import, directly or indirectly, another module that already imports it.`;
+
+exports.CIRCULAR_MODULE_IMPORT_ERROR = CIRCULAR_MODULE_IMPORT_ERROR;
+exports.CONTAINER_RESOLUTION_ENTITY_ERROR = CONTAINER_RESOLUTION_ENTITY_ERROR;
+exports.CONTAINER_RESOLUTION_ERROR = CONTAINER_RESOLUTION_ERROR;
+exports.MISSING_INJECT_TOKEN_ERROR = MISSING_INJECT_TOKEN_ERROR;
+exports.MODULE_INVALID_ANNOTATION_ERROR = MODULE_INVALID_ANNOTATION_ERROR;
 exports.PROVIDER_INVALID_MODULE_ERROR = PROVIDER_INVALID_MODULE_ERROR;

package/{exceptions → lib/cjs/exceptions}/invalid.module.exception.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidModuleAnnotationException = void 0;
-const runtime_exception_1 = require("@zanobijs/common/exceptions/runtime.exception");
-const constant_message_1 = require("./constant.message");
+'use strict';
+
+var runtime_exception = require('@zanobijs/common/exceptions/runtime.exception');
+var constant_message = require('./constant.message.js');
+
 /**
  * Excepción lanzada cuando una clase Modulo no tiene el decorador `@Module`
  * de @zanobijs/common
@@ -11,9 +11,10 @@ const constant_message_1 = require("./constant.message");
  * Esta clase extiende la base `RuntimeException`de @zanobijs/common
  * para proporcionar detalles adicionales específicos a esquemas de módulos inválidos.
  */
-class InvalidModuleAnnotationException extends runtime_exception_1.RuntimeException {
+class InvalidModuleAnnotationException extends runtime_exception.RuntimeException {
     constructor(detail = '') {
-        super((0, constant_message_1.MODULE_INVALID_ANNOTATION_ERROR)(), detail);
+        super(constant_message.MODULE_INVALID_ANNOTATION_ERROR(), detail);
     }
 }
+
 exports.InvalidModuleAnnotationException = InvalidModuleAnnotationException;

package/lib/cjs/exceptions/invalidProvider.module.exception.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var runtime_exception = require('@zanobijs/common/exceptions/runtime.exception');
+var constant_message = require('./constant.message.js');
+
+/**
+ * Excepción lanzada cuando una clase Modulo no tiene un provedor definido correctamente
+ * de @zanobijs/common
+ *
+ * @remarks
+ * Esta clase extiende la base `RuntimeException`de @zanobijs/common
+ * para proporcionar detalles adicionales específicos a esquemas de módulos inválidos.
+ */
+class InvalidProviderModuleException extends runtime_exception.RuntimeException {
+    constructor(entity, moduleName, detail) {
+        super(constant_message.PROVIDER_INVALID_MODULE_ERROR(entity, moduleName), detail);
+    }
+}
+
+exports.InvalidProviderModuleException = InvalidProviderModuleException;

package/lib/cjs/exceptions/missingInjectToken.exception.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var runtime_exception = require('@zanobijs/common/exceptions/runtime.exception');
+var constant_message = require('./constant.message.js');
+
+/**
+ * Excepción lanzada cuando un `@Inject(token)` no encuentra su provider
+ * registrado, ni en el módulo actual ni en ninguno de los módulos importados.
+ *
+ * @remarks
+ * Esta clase extiende la base `RuntimeException` de @zanobijs/common
+ * para proporcionar detalles adicionales del error.
+ */
+class MissingInjectTokenException extends runtime_exception.RuntimeException {
+    constructor(token, targetName, moduleName) {
+        super(constant_message.MISSING_INJECT_TOKEN_ERROR(token, targetName, moduleName));
+    }
+}
+
+exports.MissingInjectTokenException = MissingInjectTokenException;

package/{exceptions → lib/cjs/exceptions}/resolution.exception.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerResolutionEntityException = exports.ContainerResolutionException = void 0;
-const runtime_exception_1 = require("@zanobijs/common/exceptions/runtime.exception");
-const constant_message_1 = require("./constant.message");
+'use strict';
+
+var runtime_exception = require('@zanobijs/common/exceptions/runtime.exception');
+var constant_message = require('./constant.message.js');
+
 /**
  * Excepción lanzada cuando se intenta obtener una dependencia
  * de un controlador o servicio y esta no fue registrada
@@ -16,12 +16,11 @@ const constant_message_1 = require("./constant.message");
  * private service1: Service1
  * @Module{... services:["otherService"]}
  */
-class ContainerResolutionException extends runtime_exception_1.RuntimeException {
+class ContainerResolutionException extends runtime_exception.RuntimeException {
     constructor(entity, resolutionError, detail) {
-        super((0, constant_message_1.CONTAINER_RESOLUTION_ERROR)(entity, resolutionError), detail);
+        super(constant_message.CONTAINER_RESOLUTION_ERROR(entity, resolutionError), detail);
     }
 }
-exports.ContainerResolutionException = ContainerResolutionException;
 /**
  * Excepción lanzada cuando se intenta obtener una entidad
  * (importar, controlador, servicio o exportar) que no fue
@@ -31,9 +30,11 @@ exports.ContainerResolutionException = ContainerResolutionException;
  * Esta clase extiende la base `RuntimeException`de @zanobijs/core
  * para proporcionar detalles adicionales del error.
  */
-class ContainerResolutionEntityException extends runtime_exception_1.RuntimeException {
+class ContainerResolutionEntityException extends runtime_exception.RuntimeException {
     constructor(entity, detail) {
-        super((0, constant_message_1.CONTAINER_RESOLUTION_ENTITY_ERROR)(entity), detail);
+        super(constant_message.CONTAINER_RESOLUTION_ENTITY_ERROR(entity), detail);
     }
 }
+
 exports.ContainerResolutionEntityException = ContainerResolutionEntityException;
+exports.ContainerResolutionException = ContainerResolutionException;

package/lib/cjs/factory.js

@@ -0,0 +1,213 @@
+'use strict';
+
+require('reflect-metadata');
+var awilix = require('awilix');
+var module$1 = require('./injector/module.js');
+var resolution_exception = require('./exceptions/resolution.exception.js');
+var circularModuleImport_exception = require('./exceptions/circularModuleImport.exception.js');
+var utils = require('@zanobijs/common/utils');
+
+/**
+ * Resuelve `className` desde `container` traduciendo los errores de `awilix`
+ * al vocabulario de excepciones de `ZanobiJS`. Compartido entre `Factory.get()`
+ * y `RequestScope.get()` para no duplicar el manejo de `AwilixResolutionError`.
+ * @throws {ContainerResolutionEntityException | ContainerResolutionException}
+ * Si `awilix` no logra resolver la entidad o alguna de sus dependencias.
+ * @throws Propaga sin modificar cualquier otro error (p. ej. uno lanzado por
+ * el propio constructor de la clase que se está resolviendo).
+ */
+function resolveEntity(container, className, logger) {
+    try {
+        return container.resolve(className);
+    }
+    catch (error) {
+        if (!(error instanceof awilix.AwilixResolutionError)) {
+            throw error;
+        }
+        logger.info('Error resolving entity: ', error.message + '\n');
+        const resolutionError = error.message.split('\n');
+        const classNameFound = resolutionError[0].match(/'([^']+)'/);
+        if (classNameFound?.[1] === className) {
+            throw new resolution_exception.ContainerResolutionEntityException(className, error.message);
+        }
+        throw new resolution_exception.ContainerResolutionException(className, resolutionError[0], error.message);
+    }
+}
+/**
+ * Handle atado a un scope de `awilix` puntual (una copia liviana del
+ * contenedor raíz, ver `Factory.createRequestScope`). Resuelve entidades
+ * `singleton` desde el contenedor raíz (reusadas, gratis) y entidades
+ * `request` desde este scope (instancia nueva, se descarta con él).
+ */
+class RequestScope {
+    container;
+    logger;
+    constructor(container, logger) {
+        this.container = container;
+        this.logger = logger;
+    }
+    /**
+     * Resuelve y devuelve una instancia del scope teniendo en cuenta el
+     * nombre de la entidad proporcionada.
+     * @param {string} className - Nombre de la entidad a resolver.
+     * @returns {T} - Instancia resuelta.
+     */
+    get(className) {
+        return resolveEntity(this.container, className, this.logger);
+    }
+}
+/**
+ * Factory es una clase que facilita la creación y configuración de
+ * contenedores de inyección de dependencias utilizando metadatos y
+ * la librería `awilix` para registrar y resolver entidades como:
+ * controladores y servicios.
+ */
+class Factory {
+    moduleHandler;
+    registeredClasses = {};
+    container;
+    logger;
+    options;
+    scannedModules = new Set();
+    processedModules = new Set();
+    constructor(appModule, options = {}) {
+        this.options = options;
+        this.evaluateOptions();
+        this.logger = utils.Logger();
+        this.moduleHandler = new module$1.Module();
+        this.scanProviderModule(appModule);
+        this.registerProviderScanedModules();
+        this.processClassModule(appModule);
+    }
+    /**
+     * Se encarga de escaenear modulo por modulo los proveedores con el fin de luego
+     * poder ser registrados e inyectados en quien depende de ese proveedor
+     * @param {TClass} module - Módulo desde el que se escanearan los proveedores.
+     * @param {TClass[]} path - Cadena de módulos ancestros en la recursión actual,
+     * usada para detectar ciclos de imports.
+     * @private
+     * @throws {CircularModuleImportException} Si `module` ya está en `path`.
+     */
+    scanProviderModule(module, path = []) {
+        if (path.includes(module)) {
+            throw new circularModuleImport_exception.CircularModuleImportException([...path, module].map((m) => m.name).join(' -> '));
+        }
+        /** Un mismo módulo puede llegar por varias ramas del grafo de imports
+         * (ej. un CommonModule importado por varios módulos de feature). No es
+         * un error: ya fue escaneado, no hay nada más que hacer aquí. */
+        if (this.scannedModules.has(module)) {
+            return;
+        }
+        this.scannedModules.add(module);
+        this.logger.debug('Factory - Scan Module:', module.name);
+        this.moduleHandler.setup(module);
+        this.moduleHandler.scan();
+        this.logger.debug('===================================================');
+        const importedModules = this.moduleHandler.getImports();
+        if (importedModules && importedModules.length) {
+            const nextPath = [...path, module];
+            importedModules.forEach((moduleImport) => {
+                this.scanProviderModule(moduleImport, nextPath);
+            });
+        }
+    }
+    /**
+     * Se encarga tomar la lista de proveedores y registralos para luego se resueltos
+     * cuando el usuario lo solicite
+     * @private
+     */
+    registerProviderScanedModules() {
+        this.moduleHandler.registerAllProviders();
+    }
+    /**
+     * Procesa modulo por modulos registrando los controladores, servicios y proveedores,
+     * estos se le irá inyectando sus dependecias resueltas para ser usados por el usuario
+     * @param {TClass} module - Módulo desde el que se registrarán las clases.
+     * @private
+     *
+     * @remarks
+     * No repite la detección de ciclos: `scanProviderModule` ya recorrió este
+     * mismo grafo de imports antes (misma metadata, mismas aristas) y habría
+     * lanzado `CircularModuleImportException` si existiera uno. Solo se
+     * deduplica por módulo (`processedModules`) para el caso de diamante.
+     */
+    processClassModule(module) {
+        if (this.processedModules.has(module)) {
+            return;
+        }
+        this.processedModules.add(module);
+        this.logger.debug('Factory - Process Class Module:', module.name);
+        this.moduleHandler.setup(module);
+        this.moduleHandler.initialize();
+        Object.assign(this.registeredClasses, this.moduleHandler.getRegisterClass());
+        this.logger.success('Factory - Process Class Module - Completion!!!', module.name);
+        const importedModules = this.moduleHandler.getImports();
+        if (importedModules && importedModules.length) {
+            importedModules.forEach((moduleImport) => {
+                this.processClassModule(moduleImport);
+            });
+        }
+        this.logger.debug('===================================================');
+    }
+    /**
+     * Crea el contenedor de inyección de dependencias y registra el listado de
+     * controladores, servicio y proveedores que se ha venido creando a parti de escaneos
+     * y registros de clases.
+     * @returns {Factory} - Instancia actual de la fábrica.
+     */
+    create() {
+        this.container = awilix.createContainer({
+            injectionMode: awilix.InjectionMode.CLASSIC,
+            strict: true,
+        });
+        this.container.register(this.registeredClasses);
+        this.logger.info('Factory - classes and providers registered in the container', Object.keys(this.registeredClasses));
+        return this;
+    }
+    /**
+     * Resuelve y devuelve una instancia del contenedor
+     * teniendo en cuenta el nombre de la entidad proporcionada.
+     * @param {string} className - Nombre de la entidad a resolver.
+     * @returns {T} - Instancia resuelta.
+     * @throws {ContainerResolutionEntityException | ContainerResolutionException}
+     * Si `awilix` no logra resolver la entidad o alguna de sus dependencias.
+     * @throws Propaga sin modificar cualquier otro error (p. ej. uno lanzado por
+     * el propio constructor de la clase que se está resolviendo).
+     */
+    get(className) {
+        return resolveEntity(this.container, className, this.logger);
+    }
+    /**
+     * Crea una copia liviana del contenedor raíz para usar durante una
+     * única invocación/petición (Lambda, Azure Function, request HTTP...).
+     *
+     * Las entidades `singleton` se reusan tal cual desde el contenedor raíz
+     * (cero costo). Las entidades con `lifetime: 'request'` (ver `@Injectable`)
+     * se resuelven de cero dentro de este scope y se descartan junto con él.
+     *
+     * @returns {RequestScope} - Handle atado a este scope puntual.
+     */
+    createRequestScope() {
+        const scope = this.container.createScope();
+        return new RequestScope(scope, this.logger);
+    }
+    /**
+     * Se encarga de evaluar las opciones para ver si o no aplica y realizar lo correspondiente
+     *
+     * `ZANOBIJS_LOGGER`/`ZANOBIJS_LOGGER_USER` son pensadas para poder prenderse/apagarse
+     * desde la configuración de despliegue (variables de entorno de Lambda/contenedor) sin
+     * tocar código ni redeployar. Por eso, si el operador ya las configuró externamente,
+     * NO se pisan — `options` solo aplica como default cuando la variable no existe.
+     */
+    evaluateOptions() {
+        if (process.env.ZANOBIJS_LOGGER === undefined) {
+            process.env.ZANOBIJS_LOGGER = String(this.options.activeLoggerSystem ?? false);
+        }
+        if (process.env.ZANOBIJS_LOGGER_USER === undefined) {
+            process.env.ZANOBIJS_LOGGER_USER = String(this.options.activeLoggerUser ?? false);
+        }
+    }
+}
+
+exports.Factory = Factory;
+exports.RequestScope = RequestScope;

package/lib/cjs/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var factory = require('./factory.js');
+var module$1 = require('./injector/module.js');
+var injector = require('./injector/injector.js');
+var constant_message = require('./exceptions/constant.message.js');
+var invalid_module_exception = require('./exceptions/invalid.module.exception.js');
+var invalidProvider_module_exception = require('./exceptions/invalidProvider.module.exception.js');
+var missingInjectToken_exception = require('./exceptions/missingInjectToken.exception.js');
+var circularModuleImport_exception = require('./exceptions/circularModuleImport.exception.js');
+var resolution_exception = require('./exceptions/resolution.exception.js');
+
+
+
+exports.Factory = factory.Factory;
+exports.RequestScope = factory.RequestScope;
+exports.Module = module$1.Module;
+exports.Injector = injector.Injector;
+exports.CIRCULAR_MODULE_IMPORT_ERROR = constant_message.CIRCULAR_MODULE_IMPORT_ERROR;
+exports.CONTAINER_RESOLUTION_ENTITY_ERROR = constant_message.CONTAINER_RESOLUTION_ENTITY_ERROR;
+exports.CONTAINER_RESOLUTION_ERROR = constant_message.CONTAINER_RESOLUTION_ERROR;
+exports.MISSING_INJECT_TOKEN_ERROR = constant_message.MISSING_INJECT_TOKEN_ERROR;
+exports.MODULE_INVALID_ANNOTATION_ERROR = constant_message.MODULE_INVALID_ANNOTATION_ERROR;
+exports.PROVIDER_INVALID_MODULE_ERROR = constant_message.PROVIDER_INVALID_MODULE_ERROR;
+exports.InvalidModuleAnnotationException = invalid_module_exception.InvalidModuleAnnotationException;
+exports.InvalidProviderModuleException = invalidProvider_module_exception.InvalidProviderModuleException;
+exports.MissingInjectTokenException = missingInjectToken_exception.MissingInjectTokenException;
+exports.CircularModuleImportException = circularModuleImport_exception.CircularModuleImportException;
+exports.ContainerResolutionEntityException = resolution_exception.ContainerResolutionEntityException;
+exports.ContainerResolutionException = resolution_exception.ContainerResolutionException;

package/lib/cjs/injector/injector.js

@@ -0,0 +1,141 @@
+'use strict';
+
+var metadata = require('../metadata.js');
+var utils = require('@zanobijs/common/utils');
+var shared_utils = require('@zanobijs/common/utils/shared.utils');
+var awilix = require('awilix');
+var missingInjectToken_exception = require('../exceptions/missingInjectToken.exception.js');
+
+/**
+ * Mapea el `lifetime` público de `ZanobiJS` al método fluido de `awilix`.
+ * `request` usa `Lifetime.SCOPED` de `awilix` internamente: sin un scope real
+ * creado (ver `Factory.createRequestScope`), se resuelve igual que `singleton`.
+ */
+const LIFETIME_METHOD = {
+    singleton: 'singleton',
+    request: 'scoped',
+    transient: 'transient',
+};
+/**
+ * La clase `Injector` es la encargada de manejar la inyección de dependencias
+ * solo para parametros tipo objecto { provider, useValue }
+ */
+class Injector {
+    module;
+    listProviders;
+    listProvidersClass;
+    metadata;
+    logger;
+    moduleName = '';
+    /**
+     * En Constructor de la clase Injector obtenermos las instancias
+     * de Metadata y Logger e inciamos el escaneo de proveedores.
+     * @param {Module} module - El módulo debe tener el decorador `@Module`
+     * para poderlo procesar.
+     */
+    constructor(module, listProviders, listProvidersClass) {
+        this.metadata = metadata.Metadata.getInstance();
+        this.logger = utils.Logger();
+        this.moduleName = module.name;
+        this.module = module;
+        this.listProviders = listProviders;
+        this.listProvidersClass = listProvidersClass;
+    }
+    /**
+     * Este método privado recorre el array de los servicios del modulo para
+     * buscar los proveedores tipo objeto a injectar y los almacena en una
+     * lista de proveedores.
+     * @private
+     */
+    scanProviders() {
+        this.logger.debug('Injector - Scan provider to module:', this.moduleName);
+        const { services } = this.metadata.getMetadataModule(this.module);
+        services.forEach((service) => {
+            if (typeof service === 'object' && typeof service.provider === 'string') {
+                const key = service.provider;
+                if (service.useClass) {
+                    this.listProvidersClass.set(key, service.useClass);
+                }
+                else if (service.useFactory) {
+                    this.listProviders.set(key, awilix.asFunction(service.useFactory).scoped());
+                }
+                else {
+                    this.listProviders.set(key, awilix.asValue(service.useValue));
+                }
+            }
+            if (typeof service === 'object' && shared_utils.isClass(service.provider)) {
+                let useExample = false;
+                const key = service.provider.name;
+                if (service.useClass && shared_utils.isClass(service.useClass)) {
+                    this.listProvidersClass.set(key, service.useClass);
+                }
+                else {
+                    useExample = true;
+                    this.logger.important(`You are trying to inject the ${key} provider`, `but it is not possible to add it because using useFactory or useValue`);
+                }
+                if (useExample) {
+                    this.logger.debug('Example ✅', '{ provider: UserClassRepository, useClass: UserClassImplementation }');
+                    this.logger.debug('Example ❌', '{ provider: UserClassRepository, useClass: () => { return "text" }}');
+                    this.logger.debug('Example ❌', '{ provider: UserClassRepository, useFactory: () => { return "text" }}');
+                    this.logger.debug('Example ❌', '{ provider: UserClassRepository, useValue: "Text" }');
+                }
+            }
+        });
+        this.logger.debug('Injector - list provider', this.listProviders);
+        this.logger.debug('Injector - list provider type class', this.listProvidersClass);
+    }
+    /**
+     * Método para obtener un objeto con los parámetros(key) y valores(useValue, useClass, useFactory)
+     * que se inyectarán en la clase (target).
+     *
+     * @param { TClass} target - La clase objetivo.
+     * @returns {object} - Objeto con datos a inyectar.
+     * @throws {MissingInjectTokenException} Si un `@Inject(token)` de `target` no tiene
+     * su provider registrado en este módulo ni en ninguno de los módulos importados.
+     */
+    getInjectData(target) {
+        const injectData = {};
+        const dInject = this.metadata.getInjectionDependencies(target);
+        if (dInject.size > 0) {
+            for (const key of dInject.keys()) {
+                if (this.listProviders.has(key)) {
+                    const paramName = dInject.get(key);
+                    const providerValue = this.listProviders.get(key);
+                    injectData[paramName] = providerValue.resolve();
+                }
+                else {
+                    throw new missingInjectToken_exception.MissingInjectTokenException(key, target.name, this.moduleName);
+                }
+            }
+        }
+        return injectData;
+    }
+    /**
+     * Método para obtener el injector apropiado para la clase objetivo
+     * e inyectar los parametros del constructor encontrados en getInjectData
+     *
+     * Al hacer asClass().inject() evita que los busque en el contenedor ya que
+     * se registran de forma local en la clase objetivo
+     *
+     * @param {any} target - La clase objetivo.
+     * @returns - El injector configurado.
+     */
+    getInjectorClass(target) {
+        const injectData = this.getInjectData(target);
+        const lifetime = this.metadata.getLifetime(target);
+        let injector = awilix.asClass(target)[LIFETIME_METHOD[lifetime]]();
+        if (!shared_utils.isEmpty(injectData)) {
+            this.logger.debug(`Inject - list dependencies to inject of ${target.name}:`, injectData);
+            injector = injector.inject(() => injectData);
+        }
+        return {
+            ...injector,
+            interface: target,
+        };
+    }
+    getAllProvider() {
+        return this.listProviders;
+    }
+}
+
+exports.Injector = Injector;

package/{injector → lib/cjs/injector}/module.js

@@ -1,14 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = void 0;
-require("reflect-metadata");
-const awilix_1 = require("awilix");
-const shared_utils_1 = require("@zanobijs/common/utils/shared.utils");
-const utils_1 = require("@zanobijs/common/utils");
-const injector_1 = require("./injector");
-const metadata_1 = require("../metadata");
-const exceptions_1 = require("../exceptions");
-const invalidProvider_module_exception_1 = require("../exceptions/invalidProvider.module.exception");
+'use strict';
+
+require('reflect-metadata');
+var awilix = require('awilix');
+var shared_utils = require('@zanobijs/common/utils/shared.utils');
+var utils = require('@zanobijs/common/utils');
+var injector = require('./injector.js');
+var metadata = require('../metadata.js');
+var invalid_module_exception = require('../exceptions/invalid.module.exception.js');
+var invalidProvider_module_exception = require('../exceptions/invalidProvider.module.exception.js');
+require('@zanobijs/common/exceptions/runtime.exception');
+
 /**
  * Módulo para gestionar la configuración y el registro de
  * controladores, servicios, proveedores y dependencias.
@@ -28,8 +29,8 @@ class Module {
      * Constructor del módulo.
      */
     constructor() {
-        this.logger = (0, utils_1.Logger)();
-        this.metadata = metadata_1.Metadata.getInstance();
+        this.logger = utils.Logger();
+        this.metadata = metadata.Metadata.getInstance();
     }
     /**
      * Configura el módulo con la información proporcionada.
@@ -39,10 +40,10 @@ class Module {
         if (this.metadata.isTypeModule(module)) {
             this.module = module;
             this.logger.debug('Module - Setup - Create Injector to module:', module.name);
-            this.injector = new injector_1.Injector(this.module, this.listProviders, this.listProvidersClass);
+            this.injector = new injector.Injector(this.module, this.listProviders, this.listProvidersClass);
         }
         else {
-            throw new exceptions_1.InvalidModuleAnnotationException();
+            throw new invalid_module_exception.InvalidModuleAnnotationException();
         }
     }
     /** Metodo de exposicion para escarnear proveedores y obtener
@@ -96,16 +97,16 @@ class Module {
         if (entities && entities.length > 0) {
             const registeredEntities = entities
                 .filter((target) => {
-                return ((0, shared_utils_1.isClass)(target) &&
+                return (shared_utils.isClass(target) &&
                     this.types.includes(this.metadata.determineType(target)));
             })
                 .map((target) => {
                 this.logger.debug('Module - Entity', `<<< ${target.name} >>>`);
                 this.groupDependenciesForAlias(target);
-                const targetName = (0, shared_utils_1.unCapitalize)(target.name);
+                const targetName = shared_utils.unCapitalize(target.name);
                 return {
                     [target.name]: this.injector.getInjectorClass(target),
-                    [targetName]: (0, awilix_1.aliasTo)(target.name),
+                    [targetName]: awilix.aliasTo(target.name),
                 };
             });
             Object.assign(this.registerClass, ...registeredEntities);
@@ -132,18 +133,18 @@ class Module {
                     throw new Error('The type used in the provider useClass property is not valid');
                 }
                 this.groupDependenciesForAlias(value);
-                const targetName = (0, shared_utils_1.unCapitalize)(value.name);
-                const targetProviderName = (0, shared_utils_1.unCapitalize)(key);
+                const targetName = shared_utils.unCapitalize(value.name);
+                const targetProviderName = shared_utils.unCapitalize(key);
                 const registerProviderWithEntities = {
                     [value.name]: this.injector.getInjectorClass(value),
-                    [targetName]: (0, awilix_1.aliasTo)(value.name),
-                    [key]: (0, awilix_1.aliasTo)(value.name),
-                    [targetProviderName]: (0, awilix_1.aliasTo)(value.name),
+                    [targetName]: awilix.aliasTo(value.name),
+                    [key]: awilix.aliasTo(value.name),
+                    [targetProviderName]: awilix.aliasTo(value.name),
                 };
                 Object.assign(this.registerClass, registerProviderWithEntities);
             }
             catch (error) {
-                throw new invalidProvider_module_exception_1.InvalidProviderModuleException(value.name, this.module.name, error.message);
+                throw new invalidProvider_module_exception.InvalidProviderModuleException(value.name, this.module.name, error.message);
             }
         }
     }
@@ -162,7 +163,7 @@ class Module {
     groupDependenciesForAlias(target) {
         const dependencies = this.metadata.getClassDependencies(target);
         this.logger.debug(`Module - List dependecies to group by ${target.name}`, dependencies);
-        if (dependencies && !(0, shared_utils_1.isEmpty)(dependencies)) {
+        if (dependencies && !shared_utils.isEmpty(dependencies)) {
             this.dependenciesClass = [...this.dependenciesClass, ...dependencies];
         }
     }
@@ -179,7 +180,7 @@ class Module {
         this.logger.debug('Module - dependencies to register as candidates ', this.dependenciesClass);
         this.dependenciesClass.forEach((dependency) => {
             if (!this.registerClass[dependency.nameParameter]) {
-                this.registerClass[dependency.nameParameter] = (0, awilix_1.aliasTo)(dependency.nameClassContainer);
+                this.registerClass[dependency.nameParameter] = awilix.aliasTo(dependency.nameClassContainer);
             }
         });
     }
@@ -210,4 +211,5 @@ class Module {
         return this.registerClass;
     }
 }
+
 exports.Module = Module;