@zanobijs/core 1.0.0-beta.1 → 1.0.0-beta.3

package/__test__/injector/module.spec.ts

@@ -1,66 +0,0 @@
-import "reflect-metadata";
-import { expect } from "chai";
-import { Module } from "../../injector";
-import { ModuleTestWithImports, ModuleTestWithInjector } from "../mocks/classModule.mock";
-
-describe("Core - Injector - module", () => {
-  let moduleInstance: Module;
-
-  beforeEach(() => {
-    moduleInstance = new Module();
-  });
-
-  describe("setup", () => {
-    it("should respond that setup no is a module", () => {
-      try {
-        const mockModule = {};
-        moduleInstance.setup(mockModule);
-      } catch (error) {
-        expect(error.message).to.equal(
-          "The class must have an annotation @Module()",
-        );
-      }
-    });
-    it("should respond no problem with the setup.", () => {
-      moduleInstance.setup(ModuleTestWithInjector);
-      expect(moduleInstance.getRegisterClass()).to.is.empty;
-    });
-  });
-
-  describe("Module initialize", () => {
-    it("should respond that call getMetadataModule and register on Module", () => {
-      let metadataCalled = false;
-      let registerDependencies = false;
-      let registerDependenciesToAlias = false;
-
-      moduleInstance["getMetadataModule"] = () => {
-        metadataCalled = true;
-      };
-      moduleInstance["registerDependencies"] = () => {
-        registerDependencies = true;
-      };
-      moduleInstance["registerDependenciesToAlias"] = () => {
-        registerDependenciesToAlias = true;
-      };
-
-      moduleInstance.initialize();
-
-      expect(metadataCalled).to.be.true;
-      expect(registerDependencies).to.be.true;
-      expect(registerDependenciesToAlias).to.be.true;
-    });
-  });
-  describe("Module get information", () => {
-    it("Should respond apiKey and sContro2 in registered providers", () => {
-      moduleInstance.setup(ModuleTestWithInjector);
-      moduleInstance.initialize();
-      expect(moduleInstance.getRegisterClass()).to.have.property("sContro2");
-      expect(moduleInstance.getRegisterClass()).to.have.property("apiKey");
-    });
-    it("Should respond imports of module", () => {
-      moduleInstance.setup(ModuleTestWithImports);
-      moduleInstance.initialize();
-      expect(moduleInstance.getImports()).to.not.empty
-    });
-  });
-});

package/__test__/metadata.spec.ts

@@ -1,71 +0,0 @@
-import { expect } from "chai";
-import { Metadata } from "../metadata";
-import { ModuleTestEmpty, ModuleTest } from "./mocks/classModule.mock";
-import { ServiceWithDepenParam } from "./mocks/classWithDependeciesInject.mock";
-import { ControllerWithDepenClass } from "./mocks/classWithDependeciesClass.mock";
-
-describe("Core - metadata", () => {
-  class genericClassForTesting {}
-  const metadata = Metadata.getInstance();
-
-  describe("Is Type", () => {
-    it("should respond false to is module", () => {
-      expect(metadata.isTypeModule(genericClassForTesting)).to.be.false;
-    });
-    it("should respond false to is imports", () => {
-      expect(metadata.isTypeImport(genericClassForTesting)).to.be.false;
-    });
-    it("should respond false to is controllers", () => {
-      expect(metadata.isTypeController(genericClassForTesting)).to.be.false;
-    });
-    it("should respond false to is services", () => {
-      expect(metadata.isTypeService(genericClassForTesting)).to.be.false;
-    });
-    it("should respond false to is exports", () => {
-      expect(metadata.isTypeExports(genericClassForTesting)).to.be.false;
-    });
-    it("should respond true to is module", () => {
-      expect(metadata.isTypeModule(ModuleTestEmpty)).to.be.true;
-    });
-    it("should respond determine type of service", () => {
-      expect(metadata.determineType(ServiceWithDepenParam)).to.be.equal(
-        "service",
-      );
-    });
-    it("should respond determine type of unknown", () => {
-      class ServiceTest {}
-      try {
-        metadata.determineType(ServiceTest);
-      } catch (error) {
-        expect(error.message).to.be.equal("ServiceTest type is unknown");
-      }
-    });
-  });
-  describe("Get Metadata", () => {
-    it("Should respond the metadata of the decorator module", () => {
-      const metadata2 = Metadata.getInstance();
-      const resultMetadata = metadata2.getMetadataModule(ModuleTest);
-      expect(resultMetadata).to.have.property("imports");
-      expect(resultMetadata).to.have.property("controllers");
-      expect(resultMetadata).to.have.property("services");
-      expect(resultMetadata).to.have.property("exports");
-    });
-    it("should respond the dependency metadata of a controller", () => {
-      const resultMetadata = metadata.getAllDependencies(
-        ControllerWithDepenClass,
-      );
-      expect(resultMetadata).to.have.property("dClass");
-      expect(resultMetadata).to.have.property("dParam");
-      expect(resultMetadata).to.have.property("dInject");
-      expect(resultMetadata.dInject).to.be.empty;
-    });
-    it("should respond the dependency metadata of a service", () => {
-      const resultMetadata = metadata.getAllDependencies(ServiceWithDepenParam);
-      expect(resultMetadata).to.have.property("dClass");
-      expect(resultMetadata).to.have.property("dParam");
-      expect(resultMetadata).to.have.property("dInject");
-      expect(resultMetadata.dInject).to.not.be.empty;
-    });
-  });
-  describe("", () => {});
-});

package/__test__/mocks/classModule.mock.ts

@@ -1,55 +0,0 @@
-import { Module } from "zanobijs-common";
-import { ControllerWithDepenClass, ServiceToController } from "./classWithDependeciesClass.mock";
-import { ControllerWithDepen2, ServiceToController2 } from "./classWithDependeciesInject.mock";
-
-@Module({
-  imports: [],
-  controllers: [],
-  services: [],
-  exports: [],
-})
-export class ModuleTestEmpty {}
-
-@Module({
-  imports: [],
-  controllers: [ControllerWithDepenClass],
-  services: [ServiceToController],
-  exports: [],
-})
-export class ModuleTest {}
-
-@Module({
-  imports: [],
-  controllers: [ControllerWithDepen2],
-  services: [
-    ServiceToController2,
-    {
-      provider: "API_KEY",
-      useValue: "isApiKey_qwerty12345"
-    },
-  ],
-  exports: [],
-})
-export class ModuleTestWithInjector {}
-
-@Module({
-  imports: [ModuleTestWithInjector],
-  controllers: [],
-  services: [],
-  exports: [],
-})
-export class ModuleTestWithImports {}
-
-@Module({
-  imports: [ModuleTestWithInjector],
-  controllers: [ControllerWithDepen2],
-  services: [
-    ServiceToController2,
-    {
-      provider: "API_SECRET",
-      useValue: "isApiSecret_cvbdfgert"
-    },
-  ],
-  exports: [],
-})
-export class ModuleTestAll {}

package/__test__/mocks/classWithDependeciesClass.mock.ts

@@ -1,21 +0,0 @@
-import { Controller, Injectable } from "zanobijs-common";
-
-@Injectable()
-export class ServiceToService {
-  constructor() {}
-}
-
-@Injectable()
-export class Service {
-  constructor() {}
-}
-
-@Injectable()
-export class ServiceToController {
-  constructor() {}
-}
-
-@Controller()
-export class ControllerWithDepenClass {
-  constructor(private servicio: ServiceToController) {}
-}

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.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, asClass } 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.ts

@@ -1 +0,0 @@
-