@zanobijs/core 1.0.0-beta.1

package/injector/injector.ts

@@ -0,0 +1,89 @@
+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.d.ts

@@ -0,0 +1,76 @@
+import "reflect-metadata";
+/**
+ * Módulo para gestionar la configuración y el registro de controladores, servicios y dependencias.
+ */
+export declare class Module {
+    private config;
+    private module;
+    private logger;
+    private injector;
+    private registerClass;
+    private dependenciesClass;
+    private metadata;
+    private types;
+    /**
+     * Constructor del módulo.
+     */
+    constructor();
+    /**
+     * Configura el módulo con la información proporcionada.
+     * @param {any} module - Módulo a configurar.
+     */
+    setup(module: any): void;
+    /**
+     * Inicializa el módulo extrayendo metadatos y registrando las entidades.
+     */
+    initialize(): void;
+    /**
+     * Extrae los metadatos del módulo usando reflect-metadata.
+     * @private
+     */
+    private getMetadataModule;
+    /**
+     * Registra las entidades de configuración en el módulo.
+     * @private
+     */
+    private registerDependencies;
+    /**
+     * Registra entidades de configuración (controladores o servicios) del módulo.
+     * @param {('controllers' | 'services')} entityType - Tipo de entidad a registrar.
+     * @private
+     */
+    private registerEntities;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Devuelve las importaciones del módulo.
+     * @returns {any[] | undefined} - Importaciones del módulo.
+     */
+    getImports(): any[] | undefined;
+    /**
+     * Devuelve las clases registradas en el módulo.
+     * @returns {any} - Clases registradas.
+     */
+    getRegisterClass(): any;
+}

package/injector/module.js

@@ -0,0 +1,135 @@
+"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");
+/**
+ * Módulo para gestionar la configuración y el registro de controladores, servicios y dependencias.
+ */
+class Module {
+    config;
+    module;
+    logger;
+    injector;
+    registerClass = {};
+    dependenciesClass = [];
+    metadata;
+    types = ["controller", "service"];
+    /**
+     * Constructor del módulo.
+     */
+    constructor() {
+        this.logger = (0, utils_1.Logger)();
+        this.metadata = metadata_1.Metadata.getInstance();
+    }
+    /**
+     * Configura el módulo con la información proporcionada.
+     * @param {any} module - Módulo a configurar.
+     */
+    setup(module) {
+        if (this.metadata.isTypeModule(module)) {
+            this.module = module;
+            this.injector = new injector_1.Injector(module);
+        }
+        else {
+            throw new exceptions_1.InvalidModuleAnnotationException();
+        }
+    }
+    /**
+     * Inicializa el módulo extrayendo metadatos y registrando las entidades.
+     */
+    initialize() {
+        this.getMetadataModule();
+        this.registerDependencies();
+        this.registerDependenciesToAlias();
+    }
+    /**
+     * Extrae los metadatos del módulo usando reflect-metadata.
+     * @private
+     */
+    getMetadataModule() {
+        this.config = this.metadata.getMetadataModule(this.module);
+    }
+    /**
+     * Registra las entidades de configuración en el módulo.
+     * @private
+     */
+    registerDependencies() {
+        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
+     */
+    registerEntities(entityType) {
+        const entities = this.config[entityType];
+        if (entities && entities.length > 0) {
+            const registeredEntities = entities
+                .filter((target) => (0, shared_utils_1.isClass)(target) &&
+                this.types.includes(this.metadata.determineType(target)))
+                .map((target) => {
+                this.groupDependenciesForAlias(target);
+                const targetName = (0, shared_utils_1.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.
+     */
+    groupDependenciesForAlias(target) {
+        const dependencies = this.metadata.getClassDependencies(target);
+        if (dependencies && !(0, shared_utils_1.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
+     */
+    registerDependenciesToAlias() {
+        this.dependenciesClass.forEach((dependency) => {
+            if (!this.registerClass[dependency.nameParameter]) {
+                this.registerClass[dependency.nameParameter] = (0, awilix_1.aliasTo)(dependency.nameClassContainer);
+            }
+        });
+    }
+    /**
+     * Devuelve las importaciones del módulo.
+     * @returns {any[] | undefined} - Importaciones del módulo.
+     */
+    getImports() {
+        return this.config.imports;
+    }
+    /**
+     * Devuelve las clases registradas en el módulo.
+     * @returns {any} - Clases registradas.
+     */
+    getRegisterClass() {
+        this.logger.debug("Module - register class", this.registerClass);
+        return this.registerClass;
+    }
+}
+exports.Module = Module;

package/injector/module.ts

@@ -0,0 +1,149 @@
+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.js

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

package/interface/index.ts

@@ -0,0 +1 @@
+

package/metadata.d.ts

@@ -0,0 +1,106 @@
+import { IModuleConfig } from "zanobijs-common";
+/**
+ * La clase `Metadata` proporciona métodos para acceder y manipular
+ * metadatos relacionados con diversos componentes y módulos.
+ */
+export declare class Metadata {
+    private static instance;
+    private readonly metadataMap;
+    private constructor();
+    /**
+     * Obtiene la instancia única (singleton) de `Metadata`.
+     *
+     * @returns La instancia única de `Metadata`.
+     */
+    static getInstance(): Metadata;
+    /**
+     * 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;
+    /**
+     * 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): {
+        dClass: any;
+        dParam: any;
+        dInject: Map<string, string>;
+    };
+    /**
+     * 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): any;
+    /**
+     * 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): any;
+    /**
+     * 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>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}