@zanobijs/core 1.0.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [1.0.0-beta.1](https://github.com/devdroide/ZanobiJS/compare/v1.0.0-beta.0...v1.0.0-beta.1) (2023-11-08)
+
+**Note:** Version bump only for package @zanobijs/core

package/LICENSE

@@ -0,0 +1,33 @@
+Licencia de Uso para ZanobiJS
+
+AVISO: El código fuente contenido o descrito en este documento y todos los documentos relacioandos
+con el código fuente ("Material") son propiedad de John Edison Cortes Rivera [Devdroide].
+
+1. La difusión de esta información o reproducción de este material está estrictamente prohibido
+a menos que se obtenga un permiso previo por escrito de John Edison Cortes Rivera [Devdroide].
+
+2. Se concede el permiso para usar este software en proyectos personales o comerciales sin costo
+
+3. Queda prohibida la copia, modificación o redistribución de este software en cualquier forma.
+
+4. John Edison Cortes Rivera [Devdroide] no se hace responsable de cualquier daño o pérdida derivados del uso de este software.
+
+©2023 John Edison Cortes Rivera [Devdroide]. Todos los derechos reservados.
+
+********************************************************************************************************************************
+
+ZanobiJS Usage License
+
+NOTICE: The source code contained or described in this document and all related documents
+("Material") are the property of John Edison Cortes Rivera [Devdroide].
+
+1. Dissemination of this information or reproduction of this material is strictly prohibited
+unless prior written permission is obtained from John Edison Cortes Rivera [Devdroide].
+
+2. Permission is granted to use this software in personal or commercial projects free of charge.
+
+3. Copying, modifying, or redistributing this software in any form is prohibited.
+
+4. John Edison Cortes Rivera [Devdroide] is not liable for any damage or loss arising from the use of this software.
+
+©2023 John Edison Cortes Rivera [Devdroide]. All rights reserved.

package/README.md

@@ -0,0 +1,11 @@
+# `core`
+
+> TODO: description
+
+## Usage
+
+```
+const core = require('core');
+
+// TODO: DEMONSTRATE API
+```

package/__test__/factory.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/__test__/factory.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+// import { Module } from "zanobijs-common";
+const index_1 = require("../index");
+const classModule_mock_1 = require("./mocks/classModule.mock");
+describe("Core - factory", () => {
+    const factory = new index_1.Factory(classModule_mock_1.ModuleTestAll);
+    describe("Create Factory App", () => {
+        it("should respond error to create factory by error @Module", () => {
+            class ModuleWithoutDecorator {
+            }
+            try {
+                const factoryError = new index_1.Factory(ModuleWithoutDecorator);
+            }
+            catch (error) {
+                (0, chai_1.expect)(error.message).to.be.equal("The class must have an annotation @Module()");
+            }
+        });
+        it("should respond create factory", () => {
+            const app = factory.create();
+            (0, chai_1.expect)(app).to.be.instanceOf(index_1.Factory);
+        });
+    });
+    describe("Get Entities", () => {
+        it("should respond apiKey to controller the app", () => {
+            const app = factory.create();
+            const controllerWithDepen2 = app.get("controllerWithDepen2");
+            (0, chai_1.expect)(controllerWithDepen2.getApiKey()).to.be.equal("isApiKey_qwerty12345");
+        });
+    });
+    // it("", () => {});
+});

package/__test__/factory.spec.ts

@@ -0,0 +1,37 @@
+import { expect } from "chai";
+// import { Module } from "zanobijs-common";
+import { Factory } from "../index";
+import { ModuleTestAll } from "./mocks/classModule.mock";
+import { ControllerWithDepen2 } from "./mocks/classWithDependeciesInject.mock";
+
+describe("Core - factory", () => {
+  const factory = new Factory(ModuleTestAll);
+  describe("Create Factory App", () => {
+    it("should respond error to create factory by error @Module", () => {
+      class ModuleWithoutDecorator {}
+      try {
+        const factoryError = new Factory(ModuleWithoutDecorator);
+      } catch (error) {
+        expect(error.message).to.be.equal(
+          "The class must have an annotation @Module()",
+        );
+      }
+    });
+    it("should respond create factory", () => {
+      const app = factory.create();
+      expect(app).to.be.instanceOf(Factory);
+    });
+  });
+  describe("Get Entities", () => {
+    it("should respond apiKey to controller the app", () => {
+      const app = factory.create();
+      const controllerWithDepen2 = app.get<ControllerWithDepen2>(
+        "controllerWithDepen2",
+      );
+      expect(controllerWithDepen2.getApiKey()).to.be.equal(
+        "isApiKey_qwerty12345",
+      );
+    });
+  });
+  // it("", () => {});
+});

package/__test__/injector/injector.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/__test__/injector/injector.spec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const injector_1 = require("../../injector");
+const classModule_mock_1 = require("../mocks/classModule.mock");
+const classWithDependeciesInject_mock_1 = require("../mocks/classWithDependeciesInject.mock");
+const classWithDependeciesClass_mock_1 = require("../mocks/classWithDependeciesClass.mock");
+describe("Core - Injector - injector", () => {
+    const injector = new injector_1.Injector(classModule_mock_1.ModuleTestWithInjector);
+    beforeEach(() => {
+        process.env.ZANOBI_DEBUG = "false";
+    });
+    it("Should respond an object with paramters to inject", () => {
+        const getInjectData = injector.getInjectData(classWithDependeciesClass_mock_1.ControllerWithDepenClass);
+        (0, chai_1.expect)(getInjectData).to.is.empty;
+    });
+    it("Should respond an object without paramters to inject", () => {
+        const getInjectData = injector.getInjectData(classWithDependeciesInject_mock_1.ControllerWithDepen2);
+        (0, chai_1.expect)(getInjectData).to.have.property("apiKey");
+    });
+    it("Should respond an object type asClass with paramters to inject", () => {
+        const getInject = injector.getInjector(classWithDependeciesInject_mock_1.ControllerWithDepen2);
+        (0, chai_1.expect)(getInject).to.have.property("lifetime");
+        (0, chai_1.expect)(getInject).to.have.property("inject");
+        (0, chai_1.expect)(getInject).to.have.property("injector");
+    });
+    it("Should respond an object type asClass without injector", () => {
+        const getInject = injector.getInjector(classWithDependeciesClass_mock_1.ControllerWithDepenClass);
+        (0, chai_1.expect)(getInject).to.not.have.property("injector");
+    });
+    // it("", () => {});
+});

package/__test__/injector/injector.spec.ts

@@ -0,0 +1,32 @@
+import { expect } from "chai";
+import { Injector } from "../../injector";
+import { ModuleTestWithInjector } from "../mocks/classModule.mock";
+import { ControllerWithDepen2 } from "../mocks/classWithDependeciesInject.mock";
+import { ControllerWithDepenClass } from "../mocks/classWithDependeciesClass.mock";
+
+describe("Core - Injector - injector", () => {
+  const injector = new Injector(ModuleTestWithInjector);
+  beforeEach(() => {
+    process.env.ZANOBI_DEBUG = "false";
+  });
+
+  it("Should respond an object with paramters to inject", () => {
+    const getInjectData = injector.getInjectData(ControllerWithDepenClass);
+    expect(getInjectData).to.is.empty;
+  });
+  it("Should respond an object without paramters to inject", () => {
+    const getInjectData = injector.getInjectData(ControllerWithDepen2);
+    expect(getInjectData).to.have.property("apiKey");
+  });
+  it("Should respond an object type asClass with paramters to inject", () => {
+    const getInject = injector.getInjector(ControllerWithDepen2);
+    expect(getInject).to.have.property("lifetime");
+    expect(getInject).to.have.property("inject");
+    expect(getInject).to.have.property("injector");
+  });
+  it("Should respond an object type asClass without injector", () => {
+    const getInject = injector.getInjector(ControllerWithDepenClass);
+    expect(getInject).to.not.have.property("injector");
+  });
+  // it("", () => {});
+});

package/__test__/injector/module.spec.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/__test__/injector/module.spec.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const injector_1 = require("../../injector");
+const classModule_mock_1 = require("../mocks/classModule.mock");
+describe("Core - Injector - module", () => {
+    let moduleInstance;
+    beforeEach(() => {
+        moduleInstance = new injector_1.Module();
+    });
+    describe("setup", () => {
+        it("should respond that setup no is a module", () => {
+            try {
+                const mockModule = {};
+                moduleInstance.setup(mockModule);
+            }
+            catch (error) {
+                (0, chai_1.expect)(error.message).to.equal("The class must have an annotation @Module()");
+            }
+        });
+        it("should respond no problem with the setup.", () => {
+            moduleInstance.setup(classModule_mock_1.ModuleTestWithInjector);
+            (0, chai_1.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();
+            (0, chai_1.expect)(metadataCalled).to.be.true;
+            (0, chai_1.expect)(registerDependencies).to.be.true;
+            (0, chai_1.expect)(registerDependenciesToAlias).to.be.true;
+        });
+    });
+    describe("Module get information", () => {
+        it("Should respond apiKey and sContro2 in registered providers", () => {
+            moduleInstance.setup(classModule_mock_1.ModuleTestWithInjector);
+            moduleInstance.initialize();
+            (0, chai_1.expect)(moduleInstance.getRegisterClass()).to.have.property("sContro2");
+            (0, chai_1.expect)(moduleInstance.getRegisterClass()).to.have.property("apiKey");
+        });
+        it("Should respond imports of module", () => {
+            moduleInstance.setup(classModule_mock_1.ModuleTestWithImports);
+            moduleInstance.initialize();
+            (0, chai_1.expect)(moduleInstance.getImports()).to.not.empty;
+        });
+    });
+});

package/__test__/injector/module.spec.ts

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

@@ -0,0 +1 @@
+export {};

package/__test__/metadata.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const metadata_1 = require("../metadata");
+const classModule_mock_1 = require("./mocks/classModule.mock");
+const classWithDependeciesInject_mock_1 = require("./mocks/classWithDependeciesInject.mock");
+const classWithDependeciesClass_mock_1 = require("./mocks/classWithDependeciesClass.mock");
+describe("Core - metadata", () => {
+    class genericClassForTesting {
+    }
+    const metadata = metadata_1.Metadata.getInstance();
+    describe("Is Type", () => {
+        it("should respond false to is module", () => {
+            (0, chai_1.expect)(metadata.isTypeModule(genericClassForTesting)).to.be.false;
+        });
+        it("should respond false to is imports", () => {
+            (0, chai_1.expect)(metadata.isTypeImport(genericClassForTesting)).to.be.false;
+        });
+        it("should respond false to is controllers", () => {
+            (0, chai_1.expect)(metadata.isTypeController(genericClassForTesting)).to.be.false;
+        });
+        it("should respond false to is services", () => {
+            (0, chai_1.expect)(metadata.isTypeService(genericClassForTesting)).to.be.false;
+        });
+        it("should respond false to is exports", () => {
+            (0, chai_1.expect)(metadata.isTypeExports(genericClassForTesting)).to.be.false;
+        });
+        it("should respond true to is module", () => {
+            (0, chai_1.expect)(metadata.isTypeModule(classModule_mock_1.ModuleTestEmpty)).to.be.true;
+        });
+        it("should respond determine type of service", () => {
+            (0, chai_1.expect)(metadata.determineType(classWithDependeciesInject_mock_1.ServiceWithDepenParam)).to.be.equal("service");
+        });
+        it("should respond determine type of unknown", () => {
+            class ServiceTest {
+            }
+            try {
+                metadata.determineType(ServiceTest);
+            }
+            catch (error) {
+                (0, chai_1.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_1.Metadata.getInstance();
+            const resultMetadata = metadata2.getMetadataModule(classModule_mock_1.ModuleTest);
+            (0, chai_1.expect)(resultMetadata).to.have.property("imports");
+            (0, chai_1.expect)(resultMetadata).to.have.property("controllers");
+            (0, chai_1.expect)(resultMetadata).to.have.property("services");
+            (0, chai_1.expect)(resultMetadata).to.have.property("exports");
+        });
+        it("should respond the dependency metadata of a controller", () => {
+            const resultMetadata = metadata.getAllDependencies(classWithDependeciesClass_mock_1.ControllerWithDepenClass);
+            (0, chai_1.expect)(resultMetadata).to.have.property("dClass");
+            (0, chai_1.expect)(resultMetadata).to.have.property("dParam");
+            (0, chai_1.expect)(resultMetadata).to.have.property("dInject");
+            (0, chai_1.expect)(resultMetadata.dInject).to.be.empty;
+        });
+        it("should respond the dependency metadata of a service", () => {
+            const resultMetadata = metadata.getAllDependencies(classWithDependeciesInject_mock_1.ServiceWithDepenParam);
+            (0, chai_1.expect)(resultMetadata).to.have.property("dClass");
+            (0, chai_1.expect)(resultMetadata).to.have.property("dParam");
+            (0, chai_1.expect)(resultMetadata).to.have.property("dInject");
+            (0, chai_1.expect)(resultMetadata.dInject).to.not.be.empty;
+        });
+    });
+    describe("", () => { });
+});

package/__test__/metadata.spec.ts

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

@@ -0,0 +1,10 @@
+export declare class ModuleTestEmpty {
+}
+export declare class ModuleTest {
+}
+export declare class ModuleTestWithInjector {
+}
+export declare class ModuleTestWithImports {
+}
+export declare class ModuleTestAll {
+}

package/__test__/mocks/classModule.mock.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleTestAll = exports.ModuleTestWithImports = exports.ModuleTestWithInjector = exports.ModuleTest = exports.ModuleTestEmpty = void 0;
+const tslib_1 = require("tslib");
+const zanobijs_common_1 = require("zanobijs-common");
+const classWithDependeciesClass_mock_1 = require("./classWithDependeciesClass.mock");
+const classWithDependeciesInject_mock_1 = require("./classWithDependeciesInject.mock");
+let ModuleTestEmpty = class ModuleTestEmpty {
+};
+exports.ModuleTestEmpty = ModuleTestEmpty;
+exports.ModuleTestEmpty = ModuleTestEmpty = tslib_1.__decorate([
+    (0, zanobijs_common_1.Module)({
+        imports: [],
+        controllers: [],
+        services: [],
+        exports: [],
+    })
+], ModuleTestEmpty);
+let ModuleTest = class ModuleTest {
+};
+exports.ModuleTest = ModuleTest;
+exports.ModuleTest = ModuleTest = tslib_1.__decorate([
+    (0, zanobijs_common_1.Module)({
+        imports: [],
+        controllers: [classWithDependeciesClass_mock_1.ControllerWithDepenClass],
+        services: [classWithDependeciesClass_mock_1.ServiceToController],
+        exports: [],
+    })
+], ModuleTest);
+let ModuleTestWithInjector = class ModuleTestWithInjector {
+};
+exports.ModuleTestWithInjector = ModuleTestWithInjector;
+exports.ModuleTestWithInjector = ModuleTestWithInjector = tslib_1.__decorate([
+    (0, zanobijs_common_1.Module)({
+        imports: [],
+        controllers: [classWithDependeciesInject_mock_1.ControllerWithDepen2],
+        services: [
+            classWithDependeciesInject_mock_1.ServiceToController2,
+            {
+                provider: "API_KEY",
+                useValue: "isApiKey_qwerty12345"
+            },
+        ],
+        exports: [],
+    })
+], ModuleTestWithInjector);
+let ModuleTestWithImports = class ModuleTestWithImports {
+};
+exports.ModuleTestWithImports = ModuleTestWithImports;
+exports.ModuleTestWithImports = ModuleTestWithImports = tslib_1.__decorate([
+    (0, zanobijs_common_1.Module)({
+        imports: [ModuleTestWithInjector],
+        controllers: [],
+        services: [],
+        exports: [],
+    })
+], ModuleTestWithImports);
+let ModuleTestAll = class ModuleTestAll {
+};
+exports.ModuleTestAll = ModuleTestAll;
+exports.ModuleTestAll = ModuleTestAll = tslib_1.__decorate([
+    (0, zanobijs_common_1.Module)({
+        imports: [ModuleTestWithInjector],
+        controllers: [classWithDependeciesInject_mock_1.ControllerWithDepen2],
+        services: [
+            classWithDependeciesInject_mock_1.ServiceToController2,
+            {
+                provider: "API_SECRET",
+                useValue: "isApiSecret_cvbdfgert"
+            },
+        ],
+        exports: [],
+    })
+], ModuleTestAll);

package/__test__/mocks/classModule.mock.ts

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

@@ -0,0 +1,13 @@
+export declare class ServiceToService {
+    constructor();
+}
+export declare class Service {
+    constructor();
+}
+export declare class ServiceToController {
+    constructor();
+}
+export declare class ControllerWithDepenClass {
+    private servicio;
+    constructor(servicio: ServiceToController);
+}