@zanobijs/core 1.0.0-beta.1

package/__test__/mocks/classWithDependeciesClass.mock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerWithDepenClass = exports.ServiceToController = exports.Service = exports.ServiceToService = void 0;
+const tslib_1 = require("tslib");
+const zanobijs_common_1 = require("zanobijs-common");
+let ServiceToService = class ServiceToService {
+    constructor() { }
+};
+exports.ServiceToService = ServiceToService;
+exports.ServiceToService = ServiceToService = tslib_1.__decorate([
+    (0, zanobijs_common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], ServiceToService);
+let Service = class Service {
+    constructor() { }
+};
+exports.Service = Service;
+exports.Service = Service = tslib_1.__decorate([
+    (0, zanobijs_common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], Service);
+let ServiceToController = class ServiceToController {
+    constructor() { }
+};
+exports.ServiceToController = ServiceToController;
+exports.ServiceToController = ServiceToController = tslib_1.__decorate([
+    (0, zanobijs_common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], ServiceToController);
+let ControllerWithDepenClass = class ControllerWithDepenClass {
+    servicio;
+    constructor(servicio) {
+        this.servicio = servicio;
+    }
+};
+exports.ControllerWithDepenClass = ControllerWithDepenClass;
+exports.ControllerWithDepenClass = ControllerWithDepenClass = tslib_1.__decorate([
+    (0, zanobijs_common_1.Controller)(),
+    tslib_1.__metadata("design:paramtypes", [ServiceToController])
+], ControllerWithDepenClass);

package/__test__/mocks/classWithDependeciesClass.mock.ts

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

@@ -0,0 +1,24 @@
+export declare class ServiceToController2 {
+    constructor();
+    getHello(): string;
+}
+export declare class ServiceWithDepenParam {
+    private servicio;
+    private userName;
+    private userAge;
+    private userLogin;
+    private userHobbis;
+    constructor(servicio: ServiceToController2, userName: string, userAge: number, userLogin: boolean, userHobbis: string[]);
+}
+export declare class ControllerWithDepen2 {
+    private sContro2;
+    private apiKey;
+    constructor(sContro2: ServiceToController2, apiKey: string);
+    getApiKey(): string;
+    getHelloService(): string;
+}
+export declare class ServiceWithDepen2 {
+    private serviceWithDepenParam;
+    private api_key;
+    constructor(serviceWithDepenParam: ServiceWithDepenParam, api_key: string);
+}

package/__test__/mocks/classWithDependeciesInject.mock.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceWithDepen2 = exports.ControllerWithDepen2 = exports.ServiceWithDepenParam = exports.ServiceToController2 = void 0;
+const tslib_1 = require("tslib");
+const zanobijs_common_1 = require("zanobijs-common");
+let ServiceToController2 = class ServiceToController2 {
+    constructor() { }
+    getHello() {
+        return "Hello ServiceToController2";
+    }
+};
+exports.ServiceToController2 = ServiceToController2;
+exports.ServiceToController2 = ServiceToController2 = tslib_1.__decorate([
+    (0, zanobijs_common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], ServiceToController2);
+let ServiceWithDepenParam = class ServiceWithDepenParam {
+    servicio;
+    userName;
+    userAge;
+    userLogin;
+    userHobbis;
+    constructor(servicio, userName, userAge, userLogin, userHobbis) {
+        this.servicio = servicio;
+        this.userName = userName;
+        this.userAge = userAge;
+        this.userLogin = userLogin;
+        this.userHobbis = userHobbis;
+    }
+};
+exports.ServiceWithDepenParam = ServiceWithDepenParam;
+exports.ServiceWithDepenParam = ServiceWithDepenParam = tslib_1.__decorate([
+    (0, zanobijs_common_1.Injectable)(),
+    tslib_1.__param(1, (0, zanobijs_common_1.Inject)("USER_NAME")),
+    tslib_1.__param(2, (0, zanobijs_common_1.Inject)("USER_AGE")),
+    tslib_1.__param(3, (0, zanobijs_common_1.Inject)("USER_LOGIN")),
+    tslib_1.__param(4, (0, zanobijs_common_1.Inject)("USER_LIKE")),
+    tslib_1.__metadata("design:paramtypes", [ServiceToController2, String, Number, Boolean, Array])
+], ServiceWithDepenParam);
+let ControllerWithDepen2 = class ControllerWithDepen2 {
+    sContro2;
+    apiKey;
+    constructor(sContro2, apiKey) {
+        this.sContro2 = sContro2;
+        this.apiKey = apiKey;
+        this.apiKey = apiKey;
+    }
+    getApiKey() {
+        return this.apiKey;
+    }
+    getHelloService() {
+        return this.sContro2.getHello();
+    }
+};
+exports.ControllerWithDepen2 = ControllerWithDepen2;
+exports.ControllerWithDepen2 = ControllerWithDepen2 = tslib_1.__decorate([
+    (0, zanobijs_common_1.Controller)(),
+    tslib_1.__param(1, (0, zanobijs_common_1.Inject)("API_KEY")),
+    tslib_1.__metadata("design:paramtypes", [ServiceToController2, String])
+], ControllerWithDepen2);
+let ServiceWithDepen2 = class ServiceWithDepen2 {
+    serviceWithDepenParam;
+    api_key;
+    constructor(serviceWithDepenParam, api_key) {
+        this.serviceWithDepenParam = serviceWithDepenParam;
+        this.api_key = api_key;
+    }
+};
+exports.ServiceWithDepen2 = ServiceWithDepen2;
+exports.ServiceWithDepen2 = ServiceWithDepen2 = tslib_1.__decorate([
+    (0, zanobijs_common_1.Injectable)(),
+    tslib_1.__param(1, (0, zanobijs_common_1.Inject)("API_KEY")),
+    tslib_1.__metadata("design:paramtypes", [ServiceWithDepenParam, String])
+], ServiceWithDepen2);

package/__test__/mocks/classWithDependeciesInject.mock.ts

@@ -0,0 +1,47 @@
+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

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

package/__test__/mocks/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./classModule.mock"), exports);

package/__test__/mocks/index.ts

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

package/exceptions/constant.message.d.ts

@@ -0,0 +1 @@
+export declare const MODULE_INVALID_ANNOTATION_ERROR: () => string;

package/exceptions/constant.message.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_INVALID_ANNOTATION_ERROR = void 0;
+const MODULE_INVALID_ANNOTATION_ERROR = () => `The class must have an annotation @Module()`;
+exports.MODULE_INVALID_ANNOTATION_ERROR = MODULE_INVALID_ANNOTATION_ERROR;

package/exceptions/constant.message.ts

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

package/exceptions/index.d.ts

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

package/exceptions/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constant.message"), exports);
+tslib_1.__exportStar(require("./invalid.module.exception"), exports);

package/exceptions/index.ts

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

package/exceptions/invalid.module.exception.d.ts

@@ -0,0 +1,12 @@
+import { RuntimeException } from "zanobijs-common/exceptions/runtime.exception";
+/**
+ * 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 declare class InvalidModuleAnnotationException extends RuntimeException {
+    constructor(detail?: any);
+}

package/exceptions/invalid.module.exception.js

@@ -0,0 +1,19 @@
+"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");
+/**
+ * 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 runtime_exception_1.RuntimeException {
+    constructor(detail = ``) {
+        super((0, constant_message_1.MODULE_INVALID_ANNOTATION_ERROR)(), detail);
+    }
+}
+exports.InvalidModuleAnnotationException = InvalidModuleAnnotationException;

package/exceptions/invalid.module.exception.ts

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

@@ -0,0 +1,37 @@
+import "reflect-metadata";
+/**
+ * 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 declare class Factory {
+    private moduleHandler;
+    private registeredClasses;
+    private container;
+    constructor(appModule: any);
+    /**
+     * 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;
+    /**
+     * Registra clases desde un módulo específico.
+     * @param {any} module - Módulo desde el que se registrarán las clases.
+     * @private
+     */
+    private registerFromModule;
+    /**
+     * Crea el contenedor de inyección de dependencias y registra las clases.
+     * @returns {Factory} - Instancia actual de la fábrica.
+     */
+    create(): Factory;
+    /**
+     * 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;
+}

package/factory.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = void 0;
+require("reflect-metadata");
+const awilix_1 = require("awilix");
+const module_1 = require("./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.
+ */
+class Factory {
+    moduleHandler;
+    registeredClasses = {};
+    container;
+    constructor(appModule) {
+        this.moduleHandler = new module_1.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
+     */
+    registerClassesFromModule(module) {
+        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
+     */
+    registerFromModule(module) {
+        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() {
+        this.container = (0, awilix_1.createContainer)({ injectionMode: awilix_1.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(entity) {
+        return this.container.resolve(entity);
+    }
+}
+exports.Factory = Factory;

package/factory.ts

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

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

package/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = void 0;
+const tslib_1 = require("tslib");
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "Factory", { enumerable: true, get: function () { return factory_1.Factory; } });
+tslib_1.__exportStar(require("./injector"), exports);

package/index.ts

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

package/injector/index.d.ts

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

package/injector/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./module"), exports);
+tslib_1.__exportStar(require("./injector"), exports);

package/injector/index.ts

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

package/injector/injector.d.ts

@@ -0,0 +1,60 @@
+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 declare class Injector {
+    private module;
+    private listProviders;
+    private metadata;
+    private logger;
+    /**
+     * 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);
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Método para obtener el injector apropiado para la clase objetivo.
+     *
+     * @param {any} target - La clase objetivo.
+     * @returns - El injector configurado.
+     */
+    getInjector(target: any): {
+        interface: any;
+        injectionMode?: import("awilix").InjectionModeType;
+        injector?: import("awilix").InjectorFunction;
+        setLifetime(lifetime: import("awilix").LifetimeType): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        setInjectionMode(mode: import("awilix").InjectionModeType): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        singleton(): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        scoped(): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        transient(): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        proxy(): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        classic(): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        inject(injector: import("awilix").InjectorFunction): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+        resolve<U extends object>(container: import("awilix").AwilixContainer<U>): object;
+        name?: string;
+        lifetime?: import("awilix").LifetimeType;
+        register?: (...args: any[]) => import("awilix").Resolver<object>;
+        dispose?: import("awilix").Disposer<object>;
+        disposer(dispose: import("awilix").Disposer<object>): import("awilix").BuildResolver<object> & import("awilix").DisposableResolver<object>;
+    };
+}

package/injector/injector.js

@@ -0,0 +1,83 @@
+"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");
+/**
+ * La clase `Injector` es la encargada de manejar la inyección de dependencias
+ * solo para parametros tipo objecto { provider, useValue }
+ */
+class Injector {
+    module;
+    listProviders = new Map();
+    metadata;
+    logger;
+    /**
+     * 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) {
+        this.metadata = metadata_1.Metadata.getInstance();
+        this.logger = (0, utils_1.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
+     */
+    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) {
+        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 = (0, awilix_1.asClass)(target).scoped();
+        if (!(0, shared_utils_1.isEmpty)(injectData)) {
+            injector = injector.inject(() => injectData);
+        }
+        return {
+            ...injector,
+            interface: target,
+        };
+    }
+}
+exports.Injector = Injector;