@tsed/di 8.0.0 → 8.0.2

package/src/common/decorators/inject.spec.ts

@@ -0,0 +1,298 @@
+import {catchAsyncError} from "@tsed/core";
+
+import {DITest} from "../../node/index.js";
+import {inject} from "../fn/inject.js";
+import {injector} from "../fn/injector.js";
+import {registerProvider} from "../registries/ProviderRegistry.js";
+import {InjectorService} from "../services/InjectorService.js";
+import {Inject} from "./inject.js";
+import {Injectable} from "./injectable.js";
+
+@Injectable()
+class ProvidersList extends Map<string, string> {}
+
+@Injectable()
+class MyService {
+  @Inject(ProvidersList)
+  providersList: ProvidersList;
+
+  getValue() {
+    return this.providersList.get("key");
+  }
+}
+
+describe("@Inject()", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  describe("when the decorator used on property", () => {
+    it("should inject service", async () => {
+      // GIVEN
+      @Injectable()
+      class Test {
+        @Inject()
+        test: InjectorService;
+      }
+
+      const instance = inject<Test>(Test);
+
+      expect(instance).toBeInstanceOf(Test);
+      expect(instance.test).toBeInstanceOf(InjectorService);
+    });
+    it("should inject service and async factory", async () => {
+      // GIVEN
+      class Test {
+        constructor(public type: string) {}
+      }
+
+      const TokenAsync = Symbol.for("MyService");
+
+      registerProvider<Test>({
+        token: TokenAsync,
+        type: "test:async",
+        deps: [],
+        useAsyncFactory() {
+          return Promise.resolve(new Test("async"));
+        }
+      });
+
+      @Injectable()
+      class Parent1 {
+        @Inject(TokenAsync)
+        test: Test;
+      }
+
+      @Injectable()
+      class Parent2 {
+        @Inject(TokenAsync)
+        test: Test;
+      }
+
+      await injector().load();
+
+      const parent1 = inject<Parent1>(Parent1);
+      const parent2 = inject<Parent2>(Parent2);
+
+      expect(parent1.test).toBeInstanceOf(Test);
+      expect(parent2.test).toBeInstanceOf(Test);
+    });
+    it("should inject service and use onGet option to transform injected service", async () => {
+      // GIVEN
+      @Injectable()
+      class Test {
+        @Inject(InjectorService, {transform: (instance) => instance.get(InjectorService)})
+        test: InjectorService;
+      }
+
+      const instance = inject(Test);
+
+      expect(instance).toBeInstanceOf(Test);
+      expect(instance.test).toBeInstanceOf(InjectorService);
+    });
+    it("should inject service and use onGet option to transform injected service (legacy)", async () => {
+      // GIVEN
+      @Injectable()
+      class Test {
+        @Inject(InjectorService, (instance) => instance.get(InjectorService))
+        test: InjectorService;
+      }
+
+      const instance = inject<Test>(Test);
+
+      expect(instance).toBeInstanceOf(Test);
+      expect(instance.test).toBeInstanceOf(InjectorService);
+    });
+    it("should inject many services", async () => {
+      const TOKEN_GROUPS = Symbol.for("groups:1");
+
+      interface InterfaceGroup {
+        type: string;
+      }
+
+      @Injectable({
+        type: TOKEN_GROUPS
+      })
+      class MyService1 implements InterfaceGroup {
+        readonly type: string = "service1";
+
+        constructor(@Inject(InjectorService) readonly injector: any) {}
+      }
+
+      @Injectable({
+        type: TOKEN_GROUPS
+      })
+      class MyService2 implements InterfaceGroup {
+        readonly type: string = "service2";
+
+        constructor(@Inject(InjectorService) readonly injector: any) {}
+      }
+
+      const TokenAsync = Symbol.for("MyService2");
+
+      registerProvider({
+        token: TokenAsync,
+        type: TOKEN_GROUPS,
+        deps: [],
+        useAsyncFactory() {
+          return Promise.resolve({
+            type: "async"
+          });
+        }
+      });
+
+      @Injectable()
+      class MyInjectable {
+        @Inject(TOKEN_GROUPS)
+        instances: InterfaceGroup[];
+      }
+
+      await injector().load();
+
+      const instance = inject<MyInjectable>(MyInjectable);
+
+      expect(instance.instances).toBeInstanceOf(Array);
+      expect(instance.instances).toHaveLength(3);
+      expect(instance.instances[0].type).toEqual("service1");
+      expect(instance.instances[1].type).toEqual("service2");
+      expect(instance.instances[2].type).toEqual("async");
+    });
+    it("should throw error", () => {
+      try {
+        // GIVEN
+        @Injectable()
+        class Test {
+          @Inject()
+          test: Object;
+        }
+      } catch (er) {
+        expect(er.message).toContain("Object isn't a valid token. Please check the token set on Test.test");
+      }
+    });
+    it("should inject service and use mock", async () => {
+      @Injectable()
+      class Nested {
+        get cache() {
+          return true;
+        }
+      }
+
+      @Injectable()
+      class Test {
+        @Inject()
+        nested: Nested;
+      }
+
+      const instance = await DITest.invoke(Test, [
+        {
+          token: Nested,
+          use: {
+            cache: false
+          }
+        }
+      ]);
+
+      expect(instance.nested.cache).toEqual(false);
+
+      const instance2 = await DITest.invoke(Test, []);
+      expect(instance2.nested.cache).toEqual(true);
+    });
+  });
+  describe("when the decorator is used on constructor parameter", () => {
+    describe("when token is given on constructor", () => {
+      it("should inject the expected provider", async () => {
+        @Injectable()
+        class MyInjectable {
+          constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
+        }
+
+        const instance = inject(MyInjectable);
+
+        expect(instance.injector).toBeInstanceOf(InjectorService);
+      });
+    });
+
+    describe("when a group token is given on constructor", () => {
+      it("should inject the expected provider", async () => {
+        const TOKEN_GROUPS = Symbol.for("groups:2");
+
+        interface InterfaceGroup {
+          type: string;
+        }
+
+        @Injectable({
+          type: TOKEN_GROUPS
+        })
+        class MyService1 implements InterfaceGroup {
+          readonly type: string = "service1";
+
+          constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
+        }
+
+        @Injectable({
+          type: TOKEN_GROUPS
+        })
+        class MyService2 implements InterfaceGroup {
+          readonly type: string = "service2";
+
+          constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
+        }
+
+        const TokenAsync = Symbol.for("MyService1");
+
+        registerProvider({
+          token: TokenAsync,
+          type: TOKEN_GROUPS,
+          deps: [],
+          useAsyncFactory() {
+            return Promise.resolve({
+              type: "async"
+            });
+          }
+        });
+
+        @Injectable()
+        class MyInjectable {
+          constructor(@Inject(TOKEN_GROUPS) readonly instances: InterfaceGroup[]) {}
+        }
+
+        await injector().load();
+
+        const instance = inject(MyInjectable);
+
+        expect(instance.instances).toBeInstanceOf(Array);
+        expect(instance.instances).toHaveLength(3);
+        expect(instance.instances[0].type).toEqual("service1");
+        expect(instance.instances[1].type).toEqual("service2");
+        expect(instance.instances[2].type).toEqual("async");
+      });
+    });
+  });
+  describe("when token is Object", () => {
+    it("should throw error", async () => {
+      class Test {
+        @Inject()
+        test: any;
+      }
+
+      const error = await catchAsyncError(async () => {
+        const instance = await DITest.invoke(Test);
+
+        return instance.test;
+      });
+
+      expect(error?.message).toContain("Object isn't a valid token. Please check the token set on Test.test");
+    });
+  });
+  it("should rebuild all dependencies using invoke", async () => {
+    const providersList = inject(ProvidersList);
+    const myService = inject(MyService);
+    providersList.set("key", "value");
+
+    expect(inject(ProvidersList).get("key")).toEqual("value");
+    expect(myService.getValue()).toEqual("value");
+
+    const newMyService = await DITest.invoke(MyService, []);
+    expect(newMyService.getValue()).toEqual(undefined);
+    expect(myService.getValue()).toEqual("value");
+  });
+});

package/src/common/decorators/inject.ts

@@ -0,0 +1,144 @@
+import {catchError, decoratorTypeOf, DecoratorTypes, isPromise, Metadata, Store, type Type} from "@tsed/core";
+
+import {DI_INJECTABLE_PROPS, DI_INVOKE_OPTIONS, DI_USE_OPTIONS} from "../constants/constants.js";
+import {InvalidPropertyTokenError} from "../errors/InvalidPropertyTokenError.js";
+import {inject} from "../fn/inject.js";
+import {injectMany} from "../fn/injectMany.js";
+import type {InvokeOptions} from "../interfaces/InvokeOptions.js";
+import {TokenProvider} from "../interfaces/TokenProvider.js";
+import {getConstructorDependencies, setConstructorDependencies} from "../utils/getConstructorDependencies.js";
+
+function setToken(
+  token: TokenProvider,
+  {
+    target,
+    propertyKey,
+    parameterIndex
+  }: {
+    target: any;
+    propertyKey: string | symbol | undefined;
+    parameterIndex: number;
+  }
+) {
+  const paramTypes = getConstructorDependencies(target, propertyKey);
+  const type = paramTypes[parameterIndex];
+
+  paramTypes[parameterIndex] = type === Array ? [token] : token;
+
+  Metadata.setParamTypes(target, propertyKey!, paramTypes);
+  setConstructorDependencies(target, paramTypes);
+}
+
+function getTokenType(token: TokenProvider | (() => TokenProvider) | undefined, target: any, propertyKey: string | symbol) {
+  const useType = token || Metadata.getType(target, propertyKey);
+
+  if (useType === Object) {
+    throw new InvalidPropertyTokenError(target, String(propertyKey));
+  }
+
+  return useType;
+}
+
+export type TransformInjectedProviderCB<T, Klass = any> = (
+  instance: T,
+  {target, propertyKey}: {self: Klass; target: Type<Klass>; propertyKey: symbol | string}
+) => unknown;
+
+export interface BindInjectablePropertyOpts<T = any> {
+  token?: TokenProvider;
+  useOpts?: Record<string, unknown>;
+  transform?: TransformInjectedProviderCB<T>;
+}
+
+function bindInjectableProperty<T = any>(
+  target: any,
+  propertyKey: string | symbol,
+  {token, transform = (o) => o, useOpts}: BindInjectablePropertyOpts<T>
+) {
+  const symbol = Symbol();
+
+  if (!target[DI_INJECTABLE_PROPS]) {
+    Reflect.defineProperty(target, DI_INJECTABLE_PROPS, {
+      value: new Set(),
+      enumerable: false,
+      configurable: false
+    });
+  }
+
+  target[DI_INJECTABLE_PROPS].add(propertyKey);
+
+  catchError(() => Reflect.deleteProperty(target, propertyKey));
+  Reflect.defineProperty(target, propertyKey, {
+    get() {
+      const useType = getTokenType(token, target, propertyKey!);
+      const originalType = Metadata.getType(target, propertyKey);
+
+      const invokeOpts: Partial<InvokeOptions> = {
+        rebuild: !!this[DI_INVOKE_OPTIONS]?.rebuild,
+        locals: this[DI_INVOKE_OPTIONS]?.locals,
+        useOpts: useOpts || Store.from(target, propertyKey).get(DI_USE_OPTIONS)
+      };
+
+      if (this[symbol] === undefined) {
+        this[symbol] = originalType === Array ? injectMany(token as string, invokeOpts) : inject(useType, invokeOpts);
+      }
+
+      [].concat(this[symbol]).forEach((instance: any, index) => {
+        if (isPromise(this[symbol])) {
+          instance.then((result: any) => {
+            this[symbol]![index] = result;
+            if (originalType !== Array) {
+              this[symbol] = result;
+            }
+          });
+        }
+      });
+
+      return transform(this[symbol], {self: this, target, propertyKey});
+    }
+  });
+}
+
+/**
+ * Inject a provider to another provider.
+ *
+ * Use this decorator to inject a custom provider on constructor parameter or property.
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   @Inject(CONNECTION)
+ *   connection: CONNECTION;
+ * }
+ * ```
+ *
+ * @param token A token provider or token provider group
+ * @param transform
+ * @returns {Function}
+ * @decorator
+ */
+export function Inject<T = any>(token?: TokenProvider<T> | (() => TokenProvider<T>), transform?: TransformInjectedProviderCB<T>): any;
+export function Inject<T = any>(
+  token?: TokenProvider<T> | (() => TokenProvider<T>),
+  opts?: Partial<Omit<BindInjectablePropertyOpts<T>, "token">>
+): any;
+export function Inject<T = any>(
+  token?: TokenProvider<T> | (() => TokenProvider<T>),
+  opts: TransformInjectedProviderCB<T> | Partial<Omit<BindInjectablePropertyOpts<T>, "token">> = {}
+) {
+  opts = typeof opts === "function" ? {transform: opts} : opts;
+
+  return (target: any, propertyKey: string | symbol | undefined, index?: number) => {
+    const bindingType = decoratorTypeOf([target, propertyKey, index]);
+
+    switch (bindingType) {
+      case DecoratorTypes.PARAM_CTOR:
+        if (token) {
+          setToken(token, {target, propertyKey, parameterIndex: index!});
+        }
+        break;
+      case DecoratorTypes.PROP:
+        bindInjectableProperty(target, propertyKey!, {...opts, token});
+    }
+  };
+}

package/src/common/decorators/injectable.spec.ts

@@ -0,0 +1,43 @@
+import {GlobalProviders} from "../registries/GlobalProviders.js";
+import {Injectable} from "./injectable.js";
+
+describe("@Injectable()", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should call `registerProvider` setting `token` according to the target class", () => {
+    // GIVEN
+    class Test {}
+
+    // WHEN
+    Injectable()(Test);
+
+    // THEN
+    expect(GlobalProviders.get(Test)?.useClass).toEqual(Test);
+  });
+
+  it("should call `registerProvider` passing an additional options", () => {
+    // GIVEN
+    class Test {}
+
+    // WHEN
+    Injectable({options: "options"})(Test);
+
+    // THEN
+    expect(GlobalProviders.get(Test)?.useClass).toEqual(Test);
+    expect(GlobalProviders.get(Test)?.options).toEqual("options");
+  });
+
+  it("should override `token`", () => {
+    // GIVEN
+    class Test {}
+    const token = "custom";
+
+    // WHEN
+    Injectable({token})(Test);
+
+    // THEN
+    expect(GlobalProviders.get("custom")?.useClass).toEqual(Test);
+  });
+});

package/src/common/decorators/injectable.ts

@@ -0,0 +1,30 @@
+import {injectable} from "../fn/injectable.js";
+import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
+
+/**
+ * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
+ * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
+ *
+ * ::: tip
+ * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
+ * :::
+ *
+ * ### Options
+ *
+ * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
+ * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
+ * - token (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
+ * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export function Injectable(options: Partial<ProviderOpts> = {}): ClassDecorator {
+  return (target: any) => {
+    const opts = {
+      ...options,
+      ...(options.token ? {useClass: target} : {token: target})
+    };
+    injectable(opts.token, opts);
+  };
+}

package/src/common/decorators/intercept.spec.ts

@@ -0,0 +1,103 @@
+import {catchError} from "@tsed/core";
+
+import {DITest} from "../../node/index.js";
+import {InterceptorContext} from "../interfaces/InterceptorContext.js";
+import {InterceptorMethods} from "../interfaces/InterceptorMethods.js";
+import {InjectorService} from "../services/InjectorService.js";
+import {getInterceptorOptions, Intercept} from "./intercept.js";
+import {Interceptor} from "./interceptor.js";
+import {Service} from "./service.js";
+
+@Interceptor()
+class MyInterceptor implements InterceptorMethods {
+  intercept(context: InterceptorContext<any>) {
+    const r = typeof context.args[0] === "string" ? undefined : new Error(`Error message`);
+    const retValue = context.next(r);
+
+    return `${retValue} - ${context.options || ""} - intercepted`;
+  }
+}
+
+@Service()
+class ServiceTest {
+  @Intercept(MyInterceptor, "options data")
+  exec(param: string) {
+    return `Original data - ${param}`;
+  }
+}
+
+@Service()
+@Intercept(MyInterceptor, "options data")
+class ServiceTest2 {
+  exec(param: string) {
+    return `Original data - ${param}`;
+  }
+}
+
+describe("@Intercept", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  describe("when the decorator is used on a method", () => {
+    it("should intercept the method", async () => {
+      // GIVEN
+      const serviceTest = await DITest.invoke<ServiceTest>(ServiceTest)!;
+
+      // WHEN
+      const result = serviceTest.exec("param data");
+
+      expect(getInterceptorOptions(ServiceTest, "exec")).toEqual("options data");
+
+      // THEN
+      expect(result).toEqual("Original data - param data - options data - intercepted");
+    });
+    it("should intercept the method and mock interceptor", async () => {
+      // GIVEN
+      const serviceTest = await DITest.invoke<ServiceTest>(ServiceTest, [
+        {
+          token: MyInterceptor,
+          use: {
+            intercept: vi.fn().mockReturnValue("intercepted")
+          }
+        }
+      ]);
+
+      // WHEN
+      const result = serviceTest.exec("param data");
+
+      // THEN
+      expect(result).toEqual("intercepted");
+    });
+    it("should intercept the method and throw error", async () => {
+      // GIVEN
+      const serviceTest = await DITest.invoke<ServiceTest>(ServiceTest)!;
+
+      // WHEN
+      let actualError = catchError(() => serviceTest.exec({} as any));
+
+      // THEN
+      expect(actualError?.message).toEqual("Error message");
+    });
+  });
+  describe("when the decorator is used on a class", () => {
+    it("should intercept the method", async () => {
+      // GIVEN
+      const serviceTest = await DITest.invoke<ServiceTest2>(ServiceTest2)!;
+
+      // WHEN
+      const result = serviceTest.exec("param data");
+
+      // THEN
+      expect(result).toEqual("Original data - param data - options data - intercepted");
+    });
+    it("should intercept the method and throw error", async () => {
+      // GIVEN
+      const serviceTest = await DITest.invoke<ServiceTest2>(ServiceTest2)!;
+
+      // WHEN
+      let actualError = catchError(() => serviceTest.exec({} as any));
+      // THEN
+      expect(actualError?.message).toEqual("Error message");
+    });
+  });
+});

package/src/common/decorators/intercept.ts

@@ -0,0 +1,77 @@
+import {classOf, decorateMethodsOf, DecoratorParameters, decoratorTypeOf, DecoratorTypes, Store, Type} from "@tsed/core";
+
+import {DI_INTERCEPTOR_OPTIONS, DI_INVOKE_OPTIONS} from "../constants/constants.js";
+import {inject} from "../fn/inject.js";
+import type {InterceptorContext} from "../interfaces/InterceptorContext.js";
+import type {InterceptorMethods} from "../interfaces/InterceptorMethods.js";
+import type {InvokeOptions} from "../interfaces/InvokeOptions.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+
+export function getInterceptorOptions<T>(target: Type<any>, propertyKey: string | symbol) {
+  return Store.fromMethod(target, propertyKey).get(DI_INTERCEPTOR_OPTIONS) as T;
+}
+
+export function bindIntercept(target: any, propertyKey: string | symbol, token: TokenProvider, options: Record<string, unknown>) {
+  const klass = classOf(target);
+  const descriptor = Reflect.getOwnPropertyDescriptor(klass.prototype, propertyKey);
+  const originalMethod = descriptor!.value;
+  const symbol = Symbol();
+
+  Store.fromMethod(klass, propertyKey).set(DI_INTERCEPTOR_OPTIONS, options);
+
+  descriptor!.value = function (...args: any[]) {
+    const next = (err?: Error) => {
+      if (!err) {
+        return originalMethod.apply(this, args);
+      }
+
+      throw err;
+    };
+
+    const context: InterceptorContext<any> = {
+      target,
+      propertyKey,
+      args,
+      options,
+      next
+    };
+
+    const invokeOpts: Partial<InvokeOptions> = {
+      rebuild: !!this[DI_INVOKE_OPTIONS]?.rebuild,
+      locals: this[DI_INVOKE_OPTIONS]?.locals
+    };
+
+    this[symbol] = this[symbol] || inject(token, invokeOpts)!;
+
+    return this[symbol].intercept!(
+      {
+        ...context,
+        options
+      },
+      next
+    );
+  };
+
+  return descriptor;
+}
+
+/**
+ * Attaches interceptor to method call and executes the before and after methods
+ *
+ * @param interceptor
+ * @param options
+ * @decorator
+ */
+export function Intercept<T extends InterceptorMethods>(interceptor: Type<T>, options?: any): any {
+  return (...args: DecoratorParameters) => {
+    const [target, propertyKey] = args;
+    const type = decoratorTypeOf(args);
+    switch (type) {
+      case DecoratorTypes.CLASS:
+        decorateMethodsOf(target, Intercept(interceptor, options));
+        break;
+      case DecoratorTypes.METHOD:
+        return bindIntercept(target, propertyKey, interceptor, options);
+    }
+  };
+}