@zanobijs/core 1.2.0 → 2.0.0-beta.0

package/{metadata.js → lib/cjs/metadata.js}

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Metadata = void 0;
-const constants_1 = require("@zanobijs/common/utils/constants");
+'use strict';
+
+var constants = require('@zanobijs/common/utils/constants');
+
 /**
  * La clase `Metadata` proporciona métodos para acceder y manipular
  * metadatos relacionados con diversos componentes y módulos.
@@ -9,11 +9,11 @@ const constants_1 = require("@zanobijs/common/utils/constants");
 class Metadata {
     static instance;
     metadataMap = {
-        [constants_1.IS_MODULE]: 'module',
-        [constants_1.IS_IMPORTS]: 'import',
-        [constants_1.IS_CONTROLLER]: 'controller',
-        [constants_1.IS_SERVICE]: 'service',
-        [constants_1.IS_EXPORT]: 'export',
+        [constants.IS_MODULE]: 'module',
+        [constants.IS_IMPORTS]: 'import',
+        [constants.IS_CONTROLLER]: 'controller',
+        [constants.IS_SERVICE]: 'service',
+        [constants.IS_EXPORT]: 'export',
     };
     constructor() { }
     /**
@@ -36,10 +36,10 @@ class Metadata {
      */
     getMetadataModule(module) {
         return {
-            imports: Reflect.getMetadata(constants_1.MODULE_IMPORTS, module),
-            controllers: Reflect.getMetadata(constants_1.MODULE_CONTROLLERS, module),
-            services: Reflect.getMetadata(constants_1.MODULE_SERVICES, module),
-            exports: Reflect.getMetadata(constants_1.MODULE_EXPORTS, module),
+            imports: Reflect.getMetadata(constants.MODULE_IMPORTS, module),
+            controllers: Reflect.getMetadata(constants.MODULE_CONTROLLERS, module),
+            services: Reflect.getMetadata(constants.MODULE_SERVICES, module),
+            exports: Reflect.getMetadata(constants.MODULE_EXPORTS, module),
         };
     }
     /**
@@ -62,7 +62,7 @@ class Metadata {
      * @returns Las dependencias de clase de la clase.
      */
     getClassDependencies(target) {
-        return Reflect.getMetadata(constants_1.DEPENDENCIES_CLASS, target);
+        return Reflect.getMetadata(constants.DEPENDENCIES_CLASS, target);
     }
     /**
      * Obtiene las dependencias de parámetro asociadas con una clase.
@@ -71,7 +71,7 @@ class Metadata {
      * @returns Las dependencias de parámetro de la clase.
      */
     getParameterDependencies(target) {
-        return Reflect.getMetadata(constants_1.DEPENDENCIES_PARAMETERS, target);
+        return Reflect.getMetadata(constants.DEPENDENCIES_PARAMETERS, target);
     }
     /**
      * Obtiene las dependencias a inyectar asociadas con una clase.
@@ -80,7 +80,16 @@ class Metadata {
      * @returns Un Map con las dependencias a inyectar de la clase.
      */
     getInjectionDependencies(target) {
-        return Reflect.getMetadata(constants_1.DEPENDENCIES_INJECT, target) || new Map();
+        return Reflect.getMetadata(constants.DEPENDENCIES_INJECT, target) || new Map();
+    }
+    /**
+     * Obtiene el lifetime declarado en `@Injectable`/`@Controller` de una clase.
+     *
+     * @param { TClass } target - La función/clase objetivo.
+     * @returns El lifetime de la clase. `'singleton'` si no se declaró ninguno.
+     */
+    getLifetime(target) {
+        return Reflect.getMetadata(constants.LIFETIME_CLASS, target) ?? 'singleton';
     }
     /**
      * Determina el tipo de una clase basado en sus metadatos.
@@ -114,7 +123,7 @@ class Metadata {
      * @returns Verdadero si el target es de tipo "module", falso en caso contrario.
      */
     isTypeModule(target) {
-        return this.hasMetadata(constants_1.IS_MODULE, target);
+        return this.hasMetadata(constants.IS_MODULE, target);
     }
     /**
      * Verifica si una clase es de tipo "import".
@@ -123,7 +132,7 @@ class Metadata {
      * @returns Verdadero si el target es de tipo "import", falso en caso contrario.
      */
     isTypeImport(target) {
-        return this.hasMetadata(constants_1.IS_IMPORTS, target);
+        return this.hasMetadata(constants.IS_IMPORTS, target);
     }
     /**
      * Verifica si una clase es de tipo "controller".
@@ -132,7 +141,7 @@ class Metadata {
      * @returns Verdadero si el target es de tipo "controller", falso en caso contrario.
      */
     isTypeController(target) {
-        return this.hasMetadata(constants_1.IS_CONTROLLER, target);
+        return this.hasMetadata(constants.IS_CONTROLLER, target);
     }
     /**
      * Verifica si una clase es de tipo "service".
@@ -141,7 +150,7 @@ class Metadata {
      * @returns Verdadero si el target es de tipo "service", falso en caso contrario.
      */
     isTypeService(target) {
-        return this.hasMetadata(constants_1.IS_SERVICE, target);
+        return this.hasMetadata(constants.IS_SERVICE, target);
     }
     /**
      * Verifica si una clase es de tipo "export".
@@ -150,7 +159,8 @@ class Metadata {
      * @returns Verdadero si el target es de tipo "export", falso en caso contrario.
      */
     isTypeExports(target) {
-        return this.hasMetadata(constants_1.IS_EXPORT, target);
+        return this.hasMetadata(constants.IS_EXPORT, target);
     }
 }
+
 exports.Metadata = Metadata;

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

@@ -0,0 +1,19 @@
+import { RuntimeException } from '@zanobijs/common/exceptions/runtime.exception';
+import { CIRCULAR_MODULE_IMPORT_ERROR } from './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 RuntimeException {
+    constructor(chain) {
+        super(CIRCULAR_MODULE_IMPORT_ERROR(chain));
+    }
+}
+
+export { CircularModuleImportException };

package/lib/esm/exceptions/constant.message.js

@@ -0,0 +1,8 @@
+const MODULE_INVALID_ANNOTATION_ERROR = () => 'The class must have an annotation @Module()';
+const CONTAINER_RESOLUTION_ERROR = (entity, resolutionError) => `${resolutionError} please review '${entity}' and its dependencies.`;
+const CONTAINER_RESOLUTION_ENTITY_ERROR = (entity) => `Please check that the entity '${entity}' exists and is registered in @modulo`;
+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.`;
+
+export { CIRCULAR_MODULE_IMPORT_ERROR, CONTAINER_RESOLUTION_ENTITY_ERROR, CONTAINER_RESOLUTION_ERROR, MISSING_INJECT_TOKEN_ERROR, MODULE_INVALID_ANNOTATION_ERROR, PROVIDER_INVALID_MODULE_ERROR };

package/lib/esm/exceptions/invalid.module.exception.js

@@ -0,0 +1,18 @@
+import { RuntimeException } from '@zanobijs/common/exceptions/runtime.exception';
+import { MODULE_INVALID_ANNOTATION_ERROR } from './constant.message.js';
+
+/**
+ * Excepción lanzada cuando una clase Modulo no tiene el decorador `@Module`
+ * 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 InvalidModuleAnnotationException extends RuntimeException {
+    constructor(detail = '') {
+        super(MODULE_INVALID_ANNOTATION_ERROR(), detail);
+    }
+}
+
+export { InvalidModuleAnnotationException };

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

@@ -0,0 +1,18 @@
+import { RuntimeException } from '@zanobijs/common/exceptions/runtime.exception';
+import { PROVIDER_INVALID_MODULE_ERROR } from './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 RuntimeException {
+    constructor(entity, moduleName, detail) {
+        super(PROVIDER_INVALID_MODULE_ERROR(entity, moduleName), detail);
+    }
+}
+
+export { InvalidProviderModuleException };

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

@@ -0,0 +1,18 @@
+import { RuntimeException } from '@zanobijs/common/exceptions/runtime.exception';
+import { MISSING_INJECT_TOKEN_ERROR } from './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 RuntimeException {
+    constructor(token, targetName, moduleName) {
+        super(MISSING_INJECT_TOKEN_ERROR(token, targetName, moduleName));
+    }
+}
+
+export { MissingInjectTokenException };

package/lib/esm/exceptions/resolution.exception.js

@@ -0,0 +1,37 @@
+import { RuntimeException } from '@zanobijs/common/exceptions/runtime.exception';
+import { CONTAINER_RESOLUTION_ENTITY_ERROR, CONTAINER_RESOLUTION_ERROR } from './constant.message.js';
+
+/**
+ * Excepción lanzada cuando se intenta obtener una dependencia
+ * de un controlador o servicio y esta no fue registrada
+ * en un modulo
+ *
+ * @remarks
+ * Esta clase extiende la base `RuntimeException`de @zanobijs/core
+ * para proporcionar detalles adicionales del error.
+ *
+ * @example
+ * private service1: Service1
+ * @Module{... services:["otherService"]}
+ */
+class ContainerResolutionException extends RuntimeException {
+    constructor(entity, resolutionError, detail) {
+        super(CONTAINER_RESOLUTION_ERROR(entity, resolutionError), detail);
+    }
+}
+/**
+ * Excepción lanzada cuando se intenta obtener una entidad
+ * (importar, controlador, servicio o exportar) que no fue
+ * declarada en `@Module` de @zanobijs/common
+ *
+ * @remarks
+ * Esta clase extiende la base `RuntimeException`de @zanobijs/core
+ * para proporcionar detalles adicionales del error.
+ */
+class ContainerResolutionEntityException extends RuntimeException {
+    constructor(entity, detail) {
+        super(CONTAINER_RESOLUTION_ENTITY_ERROR(entity), detail);
+    }
+}
+
+export { ContainerResolutionEntityException, ContainerResolutionException };

package/lib/esm/factory.js

@@ -0,0 +1,210 @@
+import 'reflect-metadata';
+import { createContainer, InjectionMode, AwilixResolutionError } from 'awilix';
+import { Module } from './injector/module.js';
+import { ContainerResolutionEntityException, ContainerResolutionException } from './exceptions/resolution.exception.js';
+import { CircularModuleImportException } from './exceptions/circularModuleImport.exception.js';
+import { Logger } from '@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 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 ContainerResolutionEntityException(className, error.message);
+        }
+        throw new 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 = Logger();
+        this.moduleHandler = new 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 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 = createContainer({
+            injectionMode: 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);
+        }
+    }
+}
+
+export { Factory, RequestScope };

package/lib/esm/index.js

@@ -0,0 +1,9 @@
+export { Factory, RequestScope } from './factory.js';
+export { Module } from './injector/module.js';
+export { Injector } from './injector/injector.js';
+export { CIRCULAR_MODULE_IMPORT_ERROR, CONTAINER_RESOLUTION_ENTITY_ERROR, CONTAINER_RESOLUTION_ERROR, MISSING_INJECT_TOKEN_ERROR, MODULE_INVALID_ANNOTATION_ERROR, PROVIDER_INVALID_MODULE_ERROR } from './exceptions/constant.message.js';
+export { InvalidModuleAnnotationException } from './exceptions/invalid.module.exception.js';
+export { InvalidProviderModuleException } from './exceptions/invalidProvider.module.exception.js';
+export { MissingInjectTokenException } from './exceptions/missingInjectToken.exception.js';
+export { CircularModuleImportException } from './exceptions/circularModuleImport.exception.js';
+export { ContainerResolutionEntityException, ContainerResolutionException } from './exceptions/resolution.exception.js';

package/{injector → lib/esm/injector}/injector.js

@@ -1,10 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = void 0;
-const metadata_1 = require("../metadata");
-const utils_1 = require("@zanobijs/common/utils");
-const shared_utils_1 = require("@zanobijs/common/utils/shared.utils");
-const awilix_1 = require("awilix");
+import { Metadata } from '../metadata.js';
+import { Logger } from '@zanobijs/common/utils';
+import { isClass, isEmpty } from '@zanobijs/common/utils/shared.utils';
+import { asFunction, asValue, asClass } from 'awilix';
+import { MissingInjectTokenException } from '../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 }
@@ -23,8 +32,8 @@ class Injector {
      * para poderlo procesar.
      */
     constructor(module, listProviders, listProvidersClass) {
-        this.metadata = metadata_1.Metadata.getInstance();
-        this.logger = (0, utils_1.Logger)();
+        this.metadata = Metadata.getInstance();
+        this.logger = Logger();
         this.moduleName = module.name;
         this.module = module;
         this.listProviders = listProviders;
@@ -46,16 +55,16 @@ class Injector {
                     this.listProvidersClass.set(key, service.useClass);
                 }
                 else if (service.useFactory) {
-                    this.listProviders.set(key, (0, awilix_1.asFunction)(service.useFactory).scoped());
+                    this.listProviders.set(key, asFunction(service.useFactory).scoped());
                 }
                 else {
-                    this.listProviders.set(key, (0, awilix_1.asValue)(service.useValue));
+                    this.listProviders.set(key, asValue(service.useValue));
                 }
             }
-            if (typeof service === 'object' && (0, shared_utils_1.isClass)(service.provider)) {
+            if (typeof service === 'object' && isClass(service.provider)) {
                 let useExample = false;
                 const key = service.provider.name;
-                if (service.useClass && (0, shared_utils_1.isClass)(service.useClass)) {
+                if (service.useClass && isClass(service.useClass)) {
                     this.listProvidersClass.set(key, service.useClass);
                 }
                 else {
@@ -79,6 +88,8 @@ class Injector {
      *
      * @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 = {};
@@ -91,7 +102,7 @@ class Injector {
                     injectData[paramName] = providerValue.resolve();
                 }
                 else {
-                    this.logger.important(`You are trying to inject @INJECT('${key}') into '${target.name}'`, `but the provider '${key}' and its value are not registered in '${this.moduleName}' or any other previously loaded modules`);
+                    throw new MissingInjectTokenException(key, target.name, this.moduleName);
                 }
             }
         }
@@ -109,8 +120,9 @@ class Injector {
      */
     getInjectorClass(target) {
         const injectData = this.getInjectData(target);
-        let injector = (0, awilix_1.asClass)(target).scoped();
-        if (!(0, shared_utils_1.isEmpty)(injectData)) {
+        const lifetime = this.metadata.getLifetime(target);
+        let injector = asClass(target)[LIFETIME_METHOD[lifetime]]();
+        if (!isEmpty(injectData)) {
             this.logger.debug(`Inject - list dependencies to inject of ${target.name}:`, injectData);
             injector = injector.inject(() => injectData);
         }
@@ -123,4 +135,5 @@ class Injector {
         return this.listProviders;
     }
 }
-exports.Injector = Injector;
+
+export { Injector };