@zanobijs/core 1.0.0-beta.2 → 1.0.0-beta.4

package/__test__/mocks/classWithDependeciesInject.mock.ts

@@ -1,47 +0,0 @@
-import { Controller, Inject, Injectable } from "@zanobijs/common";
-
-@Injectable()
-export class ServiceToController2 {
-  constructor() {}
-  getHello(){
-    return "Hello ServiceToController2";
-  }
-}
-
-
-@Injectable()
-export class ServiceWithDepenParam {
-  constructor(
-    private servicio: ServiceToController2,
-    @Inject("USER_NAME") private userName: string,
-    @Inject("USER_AGE") private userAge: number,
-    @Inject("USER_LOGIN") private userLogin: boolean,
-    @Inject("USER_LIKE") private userHobbis: string[],
-  ) {}
-}
-
-
-@Controller()
-export class ControllerWithDepen2 {
-  constructor(
-    private sContro2: ServiceToController2,
-    @Inject("API_KEY") private apiKey: string,
-  ) {
-    this.apiKey = apiKey;
-  }
-
-  getApiKey() {
-    return this.apiKey;
-  }
-  getHelloService() {
-    return this.sContro2.getHello();
-  }
-}
-
-@Injectable()
-export class ServiceWithDepen2 {
-  constructor(
-    private serviceWithDepenParam: ServiceWithDepenParam,
-    @Inject("API_KEY") private api_key: string,
-  ) {}
-}

package/__test__/mocks/index.d.ts

@@ -1 +0,0 @@
-export * from "./classModule.mock";

package/__test__/mocks/index.ts

@@ -1 +0,0 @@
-export * from "./classModule.mock"

package/exceptions/constant.message.ts

@@ -1 +0,0 @@
-export const MODULE_INVALID_ANNOTATION_ERROR = () => `The class must have an annotation @Module()`;

package/exceptions/index.ts

@@ -1,2 +0,0 @@
-export * from "./constant.message"
-export * from "./invalid.module.exception"

package/exceptions/invalid.module.exception.ts

@@ -1,16 +0,0 @@
-import { RuntimeException } from "@zanobijs/common/exceptions/runtime.exception";
-import { MODULE_INVALID_ANNOTATION_ERROR } from "./constant.message";
-
-/**
- * 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.
- */
-export class InvalidModuleAnnotationException extends RuntimeException {
-  constructor(detail: any = ``) {
-    super(MODULE_INVALID_ANNOTATION_ERROR(), detail);
-  }
-}

package/factory.ts

@@ -1,69 +0,0 @@
-import "reflect-metadata";
-import {AwilixContainer, InjectionMode, createContainer } from "awilix";
-import { Module } from "./injector/module";
-
-/**
- * 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 controladores y
- * servicios.
- */
-export class Factory {
-  private moduleHandler: Module;
-  private registeredClasses = {};
-  private container: AwilixContainer<any>;
-
-  constructor(appModule: any) {
-    this.moduleHandler = new Module();
-    this.registerClassesFromModule(appModule);
-  }
-
-  /**
-   * Este método registra clases desde el módulo proporcionado
-   * y recorre sus importaciones de forma recursiva para registrar
-   * las clases necesarias de importación.
-   * @private
-   */
-  private registerClassesFromModule(module: any): void {
-    this.registerFromModule(module);
-    const importedModules = this.moduleHandler.getImports();
-    if (importedModules && importedModules.length) {
-      importedModules.forEach((moduleImport) => {
-        this.registerClassesFromModule(moduleImport);
-      });
-    }
-  }
-
-  /**
-   * Registra clases desde un módulo específico.
-   * @param {any} module - Módulo desde el que se registrarán las clases.
-   * @private
-   */
-  private registerFromModule(module: any): void {
-    this.moduleHandler.setup(module);
-    this.moduleHandler.initialize();
-    Object.assign(
-      this.registeredClasses,
-      this.moduleHandler.getRegisterClass(),
-    );
-  }
-
-  /**
-   * Crea el contenedor de inyección de dependencias y registra las clases.
-   * @returns {Factory} - Instancia actual de la fábrica.
-   */
-  create(): Factory {
-    this.container = createContainer({ injectionMode: InjectionMode.CLASSIC });
-    this.container.register(this.registeredClasses);
-    return this;
-  }
-
-  /**
-   * Resuelve y devuelve una instancia del contenedor basado en la entidad proporcionada.
-   * @param {string} entity - Nombre de la entidad a resolver.
-   * @returns {any} - Instancia resuelta.
-   */
-  get<T>(entity: string): T {
-    return this.container.resolve(entity)
-  }
-}

package/index.ts

@@ -1,2 +0,0 @@
-export { Factory } from './factory'
-export * from "./injector"

package/injector/index.ts

@@ -1,2 +0,0 @@
-export * from "./module"
-export * from "./injector";

package/injector/injector.ts

@@ -1,89 +0,0 @@
-import { ILoggerService, IModuleConfig } from "@zanobijs/common";
-import { Metadata } from "../metadata";
-import { Logger } from "@zanobijs/common/utils";
-import { isEmpty } from "@zanobijs/common/utils/shared.utils";
-import { asClass } from "awilix";
-
-export type Constructor<T> = { new (...args: any[]): T }
-
-/**
- * La clase `Injector` es la encargada de manejar la inyección de dependencias
- * solo para parametros tipo objecto { provider, useValue }
- */
-export class Injector {
-  private module: IModuleConfig;
-  private listProviders = new Map();
-  private metadata: Metadata;
-  private logger: ILoggerService;
-
-  /**
-   * 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: any) {
-    this.metadata = Metadata.getInstance();
-    this.logger = Logger();
-    this.module = module;
-    this.scanProviders();
-  }
-
-  /**
-   * 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
-   */
-  private scanProviders() {
-    const { services } = this.metadata.getMetadataModule(this.module);
-    services.forEach((service) => {
-      if (typeof service === "object")
-        this.listProviders.set(service.provider, service.useValue);
-    });
-    this.logger.debug("Injector - list provider", this.listProviders);
-  }
-
-  /**
-   * Método para obtener un objeto con los parámetros y valores
-   * que se inyectarán en la clase (target).
-   *
-   * @param {Class} target - La clase objetivo.
-   * @returns {object} - Objeto con datos a inyectar.
-   */
-  getInjectData(target: Function): object {
-    const injectData = {};
-    const dInject = this.metadata.getInjectionDependencies(target);
-    if (dInject.size > 0) {
-      for (const key of dInject.keys()) {
-        if (this.listProviders.has(key)) {
-          this.logger.info(`"${key}" is on providers list.`);
-          const paramName = dInject.get(key);
-          const useValue = this.listProviders.get(key);
-          injectData[paramName] = useValue;
-        }
-      }
-    }
-    return injectData;
-  }
-
-  /**
-   * Método para obtener el injector apropiado para la clase objetivo.
-   *
-   * @param {any} target - La clase objetivo.
-   * @returns - El injector configurado.
-   */
-  getInjector(target) {
-    const injectData = this.getInjectData(target);
-    let injector = asClass(target).scoped();
-
-    if (!isEmpty(injectData)) {
-      injector = injector.inject(() => injectData);
-    }
-
-    return {
-      ...injector,
-      interface: target,
-    };
-  }
-}

package/injector/module.ts

@@ -1,149 +0,0 @@
-import "reflect-metadata";
-import { aliasTo } from "awilix";
-import { IModuleConfig, ILoggerService } from "@zanobijs/common";
-import { unCapitalize, isEmpty, isClass } from "@zanobijs/common/utils/shared.utils";
-import { Logger } from "@zanobijs/common/utils";
-import { Injector } from "./injector";
-import { Metadata } from "../metadata";
-import { InvalidModuleAnnotationException } from "../exceptions";
-
-/**
- * Módulo para gestionar la configuración y el registro de controladores, servicios y dependencias.
- */
-export class Module {
-  private config: IModuleConfig;
-  private module: any;
-  private logger: ILoggerService;
-  private injector: Injector;
-  private registerClass = {};
-  private dependenciesClass: any[] = [];
-  private metadata: Metadata;
-  private types: string[] = ["controller", "service"];
-
-  /**
-   * Constructor del módulo.
-   */
-  constructor() {
-    this.logger = Logger();
-    this.metadata = Metadata.getInstance();
-  }
-
-  /**
-   * Configura el módulo con la información proporcionada.
-   * @param {any} module - Módulo a configurar.
-   */
-  setup(module: any): void {
-    if (this.metadata.isTypeModule(module)) {
-      this.module = module;
-      this.injector = new Injector(module);
-    } else {
-      throw new InvalidModuleAnnotationException();
-    }
-  }
-
-  /**
-   * Inicializa el módulo extrayendo metadatos y registrando las entidades.
-   */
-  initialize(): void {
-    this.getMetadataModule();
-    this.registerDependencies();
-    this.registerDependenciesToAlias();
-  }
-
-  /**
-   * Extrae los metadatos del módulo usando reflect-metadata.
-   * @private
-   */
-  private getMetadataModule(): void {
-    this.config = this.metadata.getMetadataModule(this.module);
-  }
-
-  /**
-   * Registra las entidades de configuración en el módulo.
-   * @private
-   */
-  private registerDependencies(): void {
-    this.registerEntities("controllers");
-    this.registerEntities("services");
-  }
-
-  /**
-   * Registra entidades de configuración (controladores o servicios) del módulo.
-   * @param {('controllers' | 'services')} entityType - Tipo de entidad a registrar.
-   * @private
-   */
-  private registerEntities(entityType: "controllers" | "services"): void {
-    const entities = this.config[entityType];
-
-    if (entities && entities.length > 0) {
-      const registeredEntities = entities
-        .filter(
-          (target) =>
-            isClass(target) &&
-            this.types.includes(this.metadata.determineType(target)),
-        )
-        .map((target) => {
-          this.groupDependenciesForAlias(target);
-          const targetName = unCapitalize(target.name);
-          return { [targetName]: this.injector.getInjector(target) };
-        });
-
-      Object.assign(this.registerClass, ...registeredEntities);
-    }
-  }
-
-  /**
-   * Agrupación de dependencias para alias
-   *
-   * Este método agrupa las dependencias de la clase utilizando el método
-   * `getClassDependencies` de la instancia `metadata`. Si la clase
-   * tiene dependencias y estas no están vacías, las añade a la propiedad
-   * `dependenciesClass` de la instancia actual para luego validar si existe
-   * alguna dependencia con un nombre diferente y asiganar un alias.
-   *
-   * @private
-   * @param {Function} target - La clase objetivo de la cual se quieren obtener las dependencias.
-   */
-  private groupDependenciesForAlias(target: Function): void {
-    const dependencies: any[] = this.metadata.getClassDependencies(target);
-    if (dependencies && !isEmpty(dependencies)) {
-      this.dependenciesClass = [...this.dependenciesClass, ...dependencies];
-    }
-  }
-
-  /**
-   * recorre las dependencias agrupadas y registra con un alias
-   * aquellas que tienen nombres diferente a la que esta registrada.
-   *
-   * @private
-   * @example
-   * contructor(private serviceA: ServiceA) // parametro con nombre igual
-   * contructor(private sA: ServiceA) // parametro con nombre diferente
-   */
-  private registerDependenciesToAlias(): void {
-    this.dependenciesClass.forEach((dependency) => {
-      if (!this.registerClass[dependency.nameParameter]) {
-        this.registerClass[dependency.nameParameter] = aliasTo(
-          dependency.nameClassContainer,
-        );
-      }
-    });
-  }
-
-  /**
-   * Devuelve las importaciones del módulo.
-   * @returns {any[] | undefined} - Importaciones del módulo.
-   */
-  getImports(): any[] | undefined {
-    return this.config.imports;
-  }
-
-  /**
-   * Devuelve las clases registradas en el módulo.
-   * @returns {any} - Clases registradas.
-   */
-  getRegisterClass(): any {
-    this.logger.debug("Module - register class", this.registerClass);
-    return this.registerClass;
-  }
-}

package/interface/index.js

@@ -1 +0,0 @@
-"use strict";

package/interface/index.ts

@@ -1 +0,0 @@
-

package/metadata.ts

@@ -1,178 +0,0 @@
-import { IModuleConfig } from "@zanobijs/common";
-import {
-  DEPENDENCIES_CLASS,
-  DEPENDENCIES_INJECT,
-  DEPENDENCIES_PARAMETERS,
-  IS_CONTROLLER,
-  IS_EXPORT,
-  IS_IMPORTS,
-  IS_MODULE,
-  IS_SERVICE,
-  MODULE_CONTROLLERS,
-  MODULE_EXPORTS,
-  MODULE_IMPORTS,
-  MODULE_SERVICES,
-} from "@zanobijs/common/utils/constants";
-
-/**
- * La clase `Metadata` proporciona métodos para acceder y manipular
- * metadatos relacionados con diversos componentes y módulos.
- */
-export class Metadata {
-  private static instance: Metadata;
-  private readonly metadataMap: { [key: string]: string } = {
-    [IS_MODULE]: "module",
-    [IS_IMPORTS]: "import",
-    [IS_CONTROLLER]: "controller",
-    [IS_SERVICE]: "service",
-    [IS_EXPORT]: "export",
-  };
-  private constructor() {}
-
-  /**
-   * Obtiene la instancia única (singleton) de `Metadata`.
-   *
-   * @returns La instancia única de `Metadata`.
-   */
-  static getInstance(): Metadata {
-    if (!this.instance) {
-      this.instance = new Metadata();
-    }
-    return this.instance;
-  }
-
-  /**
-   * Obtiene los metadatos de un módulo específico.
-   *
-   * @param module - El módulo del cual obtener los metadatos.
-   * @returns Un objeto con los metadatos del módulo {imports, controllers ,services, exports }.
-   */
-  getMetadataModule(module: any): IModuleConfig {
-    return {
-      imports: Reflect.getMetadata(MODULE_IMPORTS, module),
-      controllers: Reflect.getMetadata(MODULE_CONTROLLERS, module),
-      services: Reflect.getMetadata(MODULE_SERVICES, module),
-      exports: Reflect.getMetadata(MODULE_EXPORTS, module),
-    };
-  }
-
-  /**
-   * Obtiene todas las dependencias asociadas con una clase.
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Un objeto con las dependencias del target.
-   */
-  getAllDependencies(target: Function) {
-    return {
-      dClass: this.getClassDependencies(target),
-      dParam: this.getParameterDependencies(target),
-      dInject: this.getInjectionDependencies(target),
-    };
-  }
-
-  /**
-   * Obtiene las dependencias de clase asociadas con una clase.
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Las dependencias de clase de la clase.
-   */
-  getClassDependencies(target: Function) {
-    return Reflect.getMetadata(DEPENDENCIES_CLASS, target);
-  }
-
-  /**
-   * Obtiene las dependencias de parámetro asociadas con una clase.
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Las dependencias de parámetro de la clase.
-   */
-  getParameterDependencies(target: Function) {
-    return Reflect.getMetadata(DEPENDENCIES_PARAMETERS, target);
-  }
-
-  /**
-   * Obtiene las dependencias a inyectar asociadas con una clase.
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Un Map con las dependencias a inyectar de la clase.
-   */
-  getInjectionDependencies(target: Function): Map<string, string> {
-    return Reflect.getMetadata(DEPENDENCIES_INJECT, target) || new Map();
-  }
-
-  /**
-   * Determina el tipo de una clase basado en sus metadatos.
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Una cadena de texto que indica el tipo del clase segun el mapa de metadata.
-   * @throws {Error} Lanza un error si el tipo de la clase es desconocido.
-   */
-  determineType(target: Function): string {
-    for (const key in this.metadataMap) {
-      if (this.hasMetadata(key, target)) {
-        return this.metadataMap[key];
-      }
-    }
-    throw new Error(`${target.name} type is unknown`);
-  }
-
-  /**
-   * Verifica si una clase tiene un metadato específico.
-   *
-   * @param metadataKey - La llave del metadato a verificar.
-   * @param target - La función/clase objetivo.
-   * @returns Verdadero si el target tiene el metadato, falso en caso contrario.
-   */
-  private hasMetadata(metadataKey: string, target: Function): boolean {
-    return !!Reflect.getMetadata(metadataKey, target);
-  }
-  /**
-   * Verifica si una clase es de tipo "module".
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Verdadero si el target es de tipo "module", falso en caso contrario.
-   */
-  isTypeModule(target: Function): boolean {
-    return this.hasMetadata(IS_MODULE, target);
-  }
-
-  /**
-   * Verifica si una clase es de tipo "import".
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Verdadero si el target es de tipo "import", falso en caso contrario.
-   */
-  isTypeImport(target: Function): boolean {
-    return this.hasMetadata(IS_IMPORTS, target);
-  }
-
-  /**
-   * Verifica si una clase es de tipo "controller".
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Verdadero si el target es de tipo "controller", falso en caso contrario.
-   */
-  isTypeController(target: Function): boolean {
-    return this.hasMetadata(IS_CONTROLLER, target);
-  }
-
-  /**
-   * Verifica si una clase es de tipo "service".
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Verdadero si el target es de tipo "service", falso en caso contrario.
-   */
-  isTypeService(target: Function): boolean {
-    return this.hasMetadata(IS_SERVICE, target);
-  }
-
-  /**
-   * Verifica si una clase es de tipo "export".
-   *
-   * @param target - La función/clase objetivo.
-   * @returns Verdadero si el target es de tipo "export", falso en caso contrario.
-   */
-  isTypeExports(target: Function): boolean {
-    return this.hasMetadata(IS_EXPORT, target);
-  }
-}