feat(di): add events function to emit event

tsedio · Oct 8, 2024 · bea2874 · bea2874
1 parent c2a779d
commit bea2874
Show file tree

Hide file tree

Showing 28 changed files with 392 additions and 266 deletions.
diff --git a/packages/di/.barrelsby.json b/packages/di/.barrelsby.json
@@ -1,5 +1,5 @@
 {
   "directory": ["./src/common", "./src/node"],
-  "exclude": ["**/__mock__", "**/__mocks__", "**/*.spec.ts"],
+  "exclude": ["**/__mock__", "**/__mocks__", "**/*.spec.ts", "localsContainer.ts"],
   "delete": true
 }
diff --git a/packages/di/src/common/decorators/autoInjectable.spec.ts b/packages/di/src/common/decorators/autoInjectable.spec.ts
@@ -1,4 +1,3 @@
-import {catchError} from "@tsed/core";
 import {Logger} from "@tsed/logger";
 import {beforeEach} from "vitest";
 
@@ -105,9 +104,8 @@ describe("AutoInjectable", () => {
       class Test {
         @Inject(Logger)
         logger: Logger;
-
-        private value: string;
         instances?: InterfaceGroup[];
+        private value: string;
 
         constructor(initialValue: string, @Inject(TOKEN_GROUPS) instances?: InterfaceGroup[]) {
           this.value = initialValue;

diff --git a/packages/di/src/common/decorators/autoInjectable.ts b/packages/di/src/common/decorators/autoInjectable.ts
@@ -1,12 +1,12 @@
 import {isArray, type Type} from "@tsed/core";
 
 import {LocalsContainer} from "../domain/LocalsContainer.js";
-import {$injector} from "../fn/injector.js";
+import {injector} from "../fn/injector.js";
 import type {TokenProvider} from "../interfaces/TokenProvider.js";
 import {getConstructorDependencies} from "../utils/getConstructorDependencies.js";
 
 function resolveAutoInjectableArgs(token: Type, args: unknown[]) {
-  const injector = $injector();
+  const inj = injector();
   const locals = new LocalsContainer();
   const deps: TokenProvider[] = getConstructorDependencies(token);
   const list: any[] = [];
@@ -17,9 +17,7 @@ function resolveAutoInjectableArgs(token: Type, args: unknown[]) {
       list.push(args[i]);
     } else {
       const value = deps[i];
-      const instance = isArray(value)
-        ? injector!.getMany(value[0], locals, {parent: token})
-        : injector!.invoke(value, locals, {parent: token});
+      const instance = isArray(value) ? inj!.getMany(value[0], locals, {parent: token}) : inj!.invoke(value, locals, {parent: token});
 
       list.push(instance);
     }

diff --git a/packages/di/src/common/decorators/inject.spec.ts b/packages/di/src/common/decorators/inject.spec.ts
@@ -1,6 +1,7 @@
 import {catchAsyncError} from "@tsed/core";
 
 import {DITest} from "../../node/index.js";
+import {injector} from "../fn/injector.js";
 import {registerProvider} from "../registries/ProviderRegistry.js";
 import {InjectorService} from "../services/InjectorService.js";
 import {Inject} from "./inject.js";
@@ -19,8 +20,8 @@ describe("@Inject()", () => {
         test: InjectorService;
       }
 
-      const injector = new InjectorService();
-      const instance = await injector.invoke<Test>(Test);
+      const inj = injector({rebuild: true});
+      const instance = await inj.invoke<Test>(Test);
 
       expect(instance).toBeInstanceOf(Test);
       expect(instance.test).toBeInstanceOf(InjectorService);
@@ -54,12 +55,12 @@ describe("@Inject()", () => {
         test: Test;
       }
 
-      const injector = new InjectorService();
+      const inj = injector({rebuild: true});
 
-      await injector.load();
+      await inj.load();
 
-      const parent1 = await injector.invoke<Parent1>(Parent1);
-      const parent2 = await injector.invoke<Parent2>(Parent2);
+      const parent1 = await inj.invoke<Parent1>(Parent1);
+      const parent2 = await inj.invoke<Parent2>(Parent2);
 
       expect(parent1.test).toBeInstanceOf(Test);
       expect(parent2.test).toBeInstanceOf(Test);
@@ -72,8 +73,8 @@ describe("@Inject()", () => {
         test: InjectorService;
       }
 
-      const injector = new InjectorService();
-      const instance = await injector.invoke<Test>(Test);
+      const inj = injector({rebuild: true});
+      const instance = await inj.invoke<Test>(Test);
 
       expect(instance).toBeInstanceOf(Test);
       expect(instance.test).toBeInstanceOf(InjectorService);
@@ -86,8 +87,8 @@ describe("@Inject()", () => {
         test: InjectorService;
       }
 
-      const injector = new InjectorService();
-      const instance = await injector.invoke<Test>(Test);
+      const inj = injector({rebuild: true});
+      const instance = await inj.invoke<Test>(Test);
 
       expect(instance).toBeInstanceOf(Test);
       expect(instance.test).toBeInstanceOf(InjectorService);
@@ -136,11 +137,11 @@ describe("@Inject()", () => {
         instances: InterfaceGroup[];
       }
 
-      const injector = new InjectorService();
+      const inj = injector({rebuild: true});
 
-      await injector.load();
+      await inj.load();
 
-      const instance = await injector.invoke<MyInjectable>(MyInjectable);
+      const instance = await inj.invoke<MyInjectable>(MyInjectable);
 
       expect(instance.instances).toBeInstanceOf(Array);
       expect(instance.instances).toHaveLength(3);
@@ -197,8 +198,8 @@ describe("@Inject()", () => {
           constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
         }
 
-        const injector = new InjectorService();
-        const instance = await injector.invoke<MyInjectable>(MyInjectable);
+        const inj = injector({rebuild: true});
+        const instance = await inj.invoke<MyInjectable>(MyInjectable);
 
         expect(instance.injector).toBeInstanceOf(InjectorService);
       });
@@ -248,11 +249,11 @@ describe("@Inject()", () => {
           constructor(@Inject(TOKEN_GROUPS) readonly instances: InterfaceGroup[]) {}
         }
 
-        const injector = new InjectorService();
+        const inj = injector({rebuild: true});
 
-        await injector.load();
+        await inj.load();
 
-        const instance = await injector.invoke<MyInjectable>(MyInjectable);
+        const instance = await inj.invoke<MyInjectable>(MyInjectable);
 
         expect(instance.instances).toBeInstanceOf(Array);
         expect(instance.instances).toHaveLength(3);

diff --git a/packages/di/src/common/decorators/inject.ts b/packages/di/src/common/decorators/inject.ts
@@ -4,10 +4,8 @@ import {DI_INJECTABLE_PROPS, DI_INVOKE_OPTIONS, DI_USE_OPTIONS} from "../constan
 import {InvalidPropertyTokenError} from "../errors/InvalidPropertyTokenError.js";
 import {inject} from "../fn/inject.js";
 import {injectMany} from "../fn/injectMany.js";
-import {$injector} from "../fn/injector.js";
 import type {InvokeOptions} from "../interfaces/InvokeOptions.js";
 import {TokenProvider} from "../interfaces/TokenProvider.js";
-import {InjectorService} from "../services/InjectorService.js";
 import {getConstructorDependencies, setConstructorDependencies} from "../utils/getConstructorDependencies.js";
 
 function setToken(

diff --git a/packages/di/src/common/decorators/intercept.spec.ts b/packages/di/src/common/decorators/intercept.spec.ts
@@ -10,10 +10,6 @@ import {Service} from "./service.js";
 
 @Interceptor()
 class MyInterceptor implements InterceptorMethods {
-  constructor(injSrv: InjectorService) {
-    // do some logic
-  }
-
   intercept(context: InterceptorContext<any>) {
     const r = typeof context.args[0] === "string" ? undefined : new Error(`Error message`);
     const retValue = context.next(r);

diff --git a/packages/di/src/common/decorators/lazyInject.spec.ts b/packages/di/src/common/decorators/lazyInject.spec.ts
@@ -1,6 +1,6 @@
 import {catchAsyncError, classOf, nameOf} from "@tsed/core";
 
-import {InjectorService} from "../services/InjectorService.js";
+import {injector} from "../fn/injector.js";
 import type {MyLazyModule} from "./__mock__/lazy.module.js";
 import {Injectable} from "./injectable.js";
 import {LazyInject, OptionalLazyInject} from "./lazyInject.js";
@@ -13,14 +13,14 @@ describe("LazyInject", () => {
       lazy: Promise<MyLazyModule>;
     }
 
-    const injector = new InjectorService();
-    const service = await injector.invoke<MyInjectable>(MyInjectable);
-    const nbProviders = injector.getProviders().length;
+    const inj = injector({rebuild: true});
+    const service = await inj.invoke<MyInjectable>(MyInjectable);
+    const nbProviders = inj.getProviders().length;
 
     const lazyService = await service.lazy;
 
     expect(nameOf(classOf(lazyService))).toEqual("MyLazyModule");
-    expect(nbProviders).not.toEqual(injector.getProviders().length);
+    expect(nbProviders).not.toEqual(inj.getProviders().length);
   });
 
   it("should throw an error when token isn't a valid provider", async () => {
@@ -30,8 +30,8 @@ describe("LazyInject", () => {
       lazy?: Promise<MyLazyModule>;
     }
 
-    const injector = new InjectorService();
-    const service = await injector.invoke<MyInjectable>(MyInjectable);
+    const inj = injector({rebuild: true});
+    const service = await inj.invoke<MyInjectable>(MyInjectable);
     const error = await catchAsyncError(() => service.lazy);
 
     expect(error?.message).toEqual('Unable to lazy load the "TKO". The token isn\'t a valid token provider.');
@@ -45,8 +45,8 @@ describe("LazyInject", () => {
       lazy?: Promise<MyLazyModule>;
     }
 
-    const injector = new InjectorService();
-    const service = await injector.invoke<MyInjectable>(MyInjectable);
+    const inj = injector({rebuild: true});
+    const service = await inj.invoke<MyInjectable>(MyInjectable);
     const error = await catchAsyncError(() => service.lazy);
 
     expect(error?.message).toContain("Failed to load url lazy-module");
@@ -60,8 +60,8 @@ describe("LazyInject", () => {
       lazy?: Promise<MyLazyModule>;
     }
 
-    const injector = new InjectorService();
-    const service = await injector.invoke<MyInjectable>(MyInjectable);
+    const inj = injector({rebuild: true});
+    const service = await inj.invoke<MyInjectable>(MyInjectable);
     const lazyService = await service.lazy;
 
     expect(lazyService).toEqual({});
@@ -74,13 +74,13 @@ describe("LazyInject", () => {
       lazy: Promise<MyLazyModule>;
     }
 
-    const injector = new InjectorService();
-    const service = await injector.invoke<MyInjectable>(MyInjectable);
-    const originalLazyInvoke = injector.lazyInvoke.bind(injector);
+    const inj = injector({rebuild: true});
+    const service = await inj.invoke<MyInjectable>(MyInjectable);
+    const originalLazyInvoke = inj.lazyInvoke.bind(inj);
     const promise1 = service.lazy;
     let promise2: Promise<MyLazyModule> | undefined;
 
-    vi.spyOn(injector, "lazyInvoke").mockImplementationOnce((token) => {
+    vi.spyOn(inj, "lazyInvoke").mockImplementationOnce((token) => {
       promise2 = service.lazy;
       return originalLazyInvoke(token);
     });

diff --git a/packages/di/src/common/decorators/lazyInject.ts b/packages/di/src/common/decorators/lazyInject.ts
@@ -1,6 +1,6 @@
 import {catchError, importPackage} from "@tsed/core";
 
-import {$injector} from "../fn/injector.js";
+import {injector} from "../fn/injector.js";
 
 /**
  * Lazy load a provider from his package and invoke only when the provider is used
@@ -42,7 +42,7 @@ export function LazyInject(
             }
           }
 
-          bean = token ? await $injector().lazyInvoke(token) : {};
+          bean = token ? await injector().lazyInvoke(token) : {};
         }
 
         return bean;

diff --git a/packages/di/src/common/decorators/value.spec.ts b/packages/di/src/common/decorators/value.spec.ts
@@ -1,4 +1,5 @@
 import {DITest} from "../../node/index.js";
+import {configuration} from "../fn/configuration.js";
 import {Value} from "./value.js";
 
 describe("@Value()", () => {
@@ -25,7 +26,7 @@ describe("@Value()", () => {
       expect(test.test).toEqual("off");
     });
     it("should create a getter with default value", async () => {
-      expect(DITest.injector.settings.get("logger.test")).toEqual(undefined);
+      expect(configuration().get("logger.test")).toEqual(undefined);
 
       // WHEN
       class Test {
@@ -38,7 +39,7 @@ describe("@Value()", () => {
       const test = await DITest.invoke<Test>(Test);
 
       expect(test.test).toEqual("default value");
-      expect(DITest.injector.settings.get("logger.test")).toEqual(undefined);
+      expect(configuration().get("logger.test")).toEqual(undefined);
     });
     it("should create a getter with native default value", async () => {
       // WHEN
@@ -52,7 +53,7 @@ describe("@Value()", () => {
       const test = await DITest.invoke<Test>(Test);
 
       expect(test.test).toEqual("default prop");
-      expect(DITest.injector.settings.get("logger.test")).toEqual("default prop");
+      expect(configuration().get("logger.test")).toEqual("default prop");
     });
   });
 });
diff --git a/packages/di/src/common/decorators/value.ts b/packages/di/src/common/decorators/value.ts
@@ -1,14 +1,14 @@
 import {catchError} from "@tsed/core";
 
-import {$injector} from "../fn/injector.js";
+import {injector} from "../fn/injector.js";
 
 export function bindValue(target: any, propertyKey: string | symbol, expression: string, defaultValue?: any) {
   const descriptor = {
     get() {
-      return $injector().settings.get(expression, defaultValue);
+      return injector().settings.get(expression, defaultValue);
     },
     set(value: unknown) {
-      $injector().settings.set(expression, value);
+      injector().settings.set(expression, value);
     },
     enumerable: true,
     configurable: true