@tsed/di 8.11.1 → 8.11.2-rc.1

package/src/common/decorators/inject.ts

@@ -1,150 +0,0 @@
-import {DecoratorTypes} from "@tsed/core/types/DecoratorTypes.js";
-import {Metadata} from "@tsed/core/types/Metadata.js";
-import {Store} from "@tsed/core/types/Store.js";
-import {type Type} from "@tsed/core/types/Type.js";
-import {catchError} from "@tsed/core/utils/catchError.js";
-import {decoratorTypeOf} from "@tsed/core/utils/decoratorTypeOf.js";
-import {isPromise} from "@tsed/core/utils/isPromise.js";
-
-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

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

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

@@ -1,150 +0,0 @@
-import {catchError, classOf, nameOf} from "@tsed/core";
-
-import {DITest} from "../../node/index.js";
-import {InterceptorContext} from "../interfaces/InterceptorContext.js";
-import {InterceptorMethods} from "../interfaces/InterceptorMethods.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);
-
-    expect(nameOf(context.target)).toContain("Service");
-
-    return `${retValue} - ${context.options || ""} - intercepted 1`;
-  }
-}
-
-@Interceptor()
-class MyInterceptor2 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 2`;
-  }
-}
-
-@Service()
-class ServiceTest {
-  @Intercept(MyInterceptor, "options data")
-  exec(param: string) {
-    return `Original data - ${param}`;
-  }
-
-  @Intercept(MyInterceptor, "options data")
-  @Intercept(MyInterceptor2, "options data")
-  chained(param: string) {
-    return `Chained - ${param}`;
-  }
-
-  @Intercept(MyInterceptor2, "options data")
-  @Intercept(MyInterceptor, "options data")
-  reverseChained(param: string) {
-    return `Chained - ${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 1");
-    });
-    it("should chained interceptor", async () => {
-      // GIVEN
-      const serviceTest = await DITest.invoke<ServiceTest>(ServiceTest)!;
-
-      // WHEN
-      const result = serviceTest.chained("param data");
-
-      expect(getInterceptorOptions(ServiceTest, "chained")).toEqual("options data");
-
-      // THEN
-      expect(result).toEqual("Chained - param data - options data - intercepted 2 - options data - intercepted 1");
-    });
-    it("should chained interceptor (reversed)", async () => {
-      // GIVEN
-      const serviceTest = await DITest.invoke<ServiceTest>(ServiceTest)!;
-
-      // WHEN
-      const result = serviceTest.reverseChained("param data");
-
-      expect(getInterceptorOptions(ServiceTest, "reverseChained")).toEqual("options data");
-
-      // THEN
-      expect(result).toEqual("Chained - param data - options data - intercepted 1 - options data - intercepted 2");
-    });
-    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 1");
-    });
-    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

@@ -1,89 +0,0 @@
-import {DecoratorParameters} from "@tsed/core/types/DecoratorParameters.js";
-import {DecoratorTypes} from "@tsed/core/types/DecoratorTypes.js";
-import {Store} from "@tsed/core/types/Store.js";
-import {Type} from "@tsed/core/types/Type.js";
-import {classOf} from "@tsed/core/utils/classOf.js";
-import {decorateMethodsOf} from "@tsed/core/utils/decorateMethodsOf.js";
-import {decoratorTypeOf} from "@tsed/core/utils/decoratorTypeOf.js";
-import {nameOf} from "@tsed/core/utils/nameOf.js";
-
-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);
-
-  function newMethod(...args: any[]) {
-    const next = (err?: Error) => {
-      if (!err) {
-        return originalMethod.apply(this, args);
-      }
-
-      throw err;
-    };
-
-    const context: InterceptorContext<any> = {
-      target: klass,
-      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
-    );
-  }
-
-  descriptor!.value = newMethod;
-
-  Reflect.deleteProperty(klass.prototype, propertyKey);
-  Reflect.defineProperty(klass.prototype, propertyKey, descriptor!);
-
-  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);
-    }
-  };
-}

package/src/common/decorators/interceptor.ts

@@ -1,17 +0,0 @@
-import {ProviderType} from "../domain/ProviderType.js";
-import {Injectable} from "./injectable.js";
-
-/**
- * The decorators `@Interceptor()` declare a new service can be injected in other service or controller on there `constructor`.
- * All services annotated with `@Interceptor()` are constructed one time.
- *
- * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
- *
- * @returns {Function}
- * @decorator
- */
-export function Interceptor(): Function {
-  return Injectable({
-    type: ProviderType.INTERCEPTOR
-  });
-}

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

@@ -1,53 +0,0 @@
-import {catchAsyncError, classOf, nameOf} from "@tsed/core";
-
-import {inject} from "../fn/inject.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";
-
-describe("LazyInject", () => {
-  it("should lazy load module (import)", async () => {
-    @Injectable()
-    class MyInjectable {
-      @LazyInject("MyLazyModule", () => import("./__mock__/lazy.import.module.js"))
-      lazy: Promise<MyLazyModule>;
-    }
-
-    const service = inject(MyInjectable);
-    const nbProviders = injector().getProviders().length;
-
-    const lazyService = await service.lazy;
-
-    expect(nameOf(classOf(lazyService))).toEqual("MyLazyModule");
-    expect(nbProviders).not.toEqual(injector().getProviders().length);
-  });
-
-  it("should throw an error when the module doesn't exists", async () => {
-    @Injectable()
-    class MyInjectable {
-      // @ts-ignore
-      @LazyInject("Lazy", () => import("lazy-module"), {})
-      lazy?: Promise<MyLazyModule>;
-    }
-
-    const service = inject<MyInjectable>(MyInjectable);
-    const error = await catchAsyncError(() => service.lazy);
-
-    expect(error?.message).toContain("'lazy-module' imported from");
-  });
-
-  it("should lazy load optionally a module", async () => {
-    @Injectable()
-    class MyInjectable {
-      // @ts-ignore
-      @OptionalLazyInject("default", () => import("lazy-module-optional"))
-      lazy?: Promise<MyLazyModule>;
-    }
-
-    const service = inject(MyInjectable);
-    const lazyService = await service.lazy;
-
-    expect(lazyService).toEqual(undefined);
-  });
-});

package/src/common/decorators/lazyInject.ts

@@ -1,92 +0,0 @@
-import {catchError} from "@tsed/core/utils/catchError.js";
-import {isFunction} from "@tsed/core/utils/isFunction.js";
-
-import {lazyInject, optionalLazyInject} from "../fn/lazyInject.js";
-
-function mapOptions(args: any[], optional = false) {
-  function wrap(key: string, resolver: any) {
-    return async () => {
-      try {
-        const {[key]: token} = await resolver();
-
-        return {default: token};
-      } catch (er) {
-        if (!optional) {
-          throw er;
-        }
-
-        return;
-      }
-    };
-  }
-
-  if (isFunction(args[0])) {
-    return wrap("default", args[0]);
-  }
-
-  return wrap(args[0], args[1]);
-}
-
-/**
- * Lazy load a provider from his package and invoke only when the provider is used
- *
- * ```typescript
- * import type {PlatformException} from "@tsed/platform-exceptions";
- *
- * @Injectable()
- * export class MyService {
- *   @LazyInject(() => import("@tsed/platform-exceptions"))
- *   exceptions: Promise<PlatformException>;
- * }
- * ```
- *
- * @param key - The named export to import from the module.
- * @param resolver - A function that returns a promise resolving to the module.
- * @returns {Function}
- * @decorator
- */
-export function LazyInject(resolver: () => Promise<{default: unknown}>): PropertyDecorator;
-export function LazyInject(key: string, resolver: () => Promise<{default: unknown}>): PropertyDecorator;
-export function LazyInject(...args: any[]): PropertyDecorator {
-  let resolver = mapOptions(args);
-
-  return (target: any, propertyKey: string | symbol): any | void => {
-    catchError(() => Reflect.deleteProperty(target, propertyKey));
-    Reflect.defineProperty(target, propertyKey, {
-      async get() {
-        return lazyInject<any>(resolver as any);
-      }
-    });
-  };
-}
-
-/**
- * Optionally Lazy load a provider from his package and invoke only when the provider is used
- *
- * ```typescript
- * import type {PlatformException} from "@tsed/platform-exceptions";
- *
- * @Injectable()
- * export class MyService {
- *   @OptionalLazyInject(() => import("@tsed/platform-exceptions"))
- *   exceptions: Promise<PlatformException>;
- * }
- * ```
- * @param key - The named export to import from the module.
- * @param resolver - A function that returns a promise resolving to the module.
- * @decorator
- */
-export function OptionalLazyInject(resolver: () => Promise<{default: unknown}>): PropertyDecorator;
-export function OptionalLazyInject(key: string, resolver: () => Promise<{default: unknown}>): PropertyDecorator;
-export function OptionalLazyInject(...args: any[]): PropertyDecorator {
-  const resolver = mapOptions(args, true);
-
-  return (target: any, propertyKey: string | symbol): any | void => {
-    catchError(() => Reflect.deleteProperty(target, propertyKey));
-    Reflect.defineProperty(target, propertyKey, {
-      async get() {
-        return optionalLazyInject(resolver as any);
-      }
-    });
-  };
-}

package/src/common/decorators/module.ts

@@ -1,52 +0,0 @@
-import {useDecorators} from "@tsed/core/utils/useDecorators.js";
-
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {ProviderType} from "../domain/ProviderType.js";
-import {TokenProvider} from "../interfaces/TokenProvider.js";
-import {Configuration} from "./configuration.js";
-import {Injectable} from "./injectable.js";
-
-export interface ModuleOptions extends Omit<TsED.Configuration, "scopes"> {
-  /**
-   * Provider scope
-   */
-  scope?: ProviderScope;
-  /**
-   * Providers must be initialized before building this module
-   */
-  imports?: TokenProvider[];
-  /**
-   * Explicit token must be injected in the constructor
-   */
-  deps?: TokenProvider[];
-
-  /**
-   * Additional properties are stored as provider configuration.
-   */
-  [key: string]: any;
-}
-
-/**
- * Declare a new Ts.ED module
- *
- * ## Options
- * - imports: List of Provider which must be built by injector before invoking the module
- * - deps: List of provider must be injected to the module constructor (explicit declaration)
- *
- * @param options
- * @decorator
- */
-export function Module(options: Partial<ModuleOptions> = {}) {
-  const {scopes, imports, deps, scope, ...configuration} = options;
-
-  return useDecorators(
-    Configuration(configuration),
-    Injectable({
-      type: ProviderType.MODULE,
-      scope: ProviderScope.SINGLETON,
-      imports,
-      deps,
-      injectable: false
-    })
-  );
-}