@tsed/di 8.11.0 → 8.11.2-rc.1

package/src/common/integration/di.spec.ts

@@ -1,153 +0,0 @@
-import {afterEach} from "vitest";
-
-import {Inject} from "../decorators/inject.js";
-import {Injectable} from "../decorators/injectable.js";
-import {Scope} from "../decorators/scope.js";
-import {Service} from "../decorators/service.js";
-import {Container} from "../domain/Container.js";
-import {LocalsContainer} from "../domain/LocalsContainer.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {inject} from "../fn/inject.js";
-import {destroyInjector, injector} from "../fn/injector.js";
-import {OnDestroy} from "../interfaces/OnDestroy.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-
-describe("DI", () => {
-  afterEach(() => destroyInjector());
-
-  describe("from injector global container", () => {
-    @Service()
-    @Scope(ProviderScope.INSTANCE)
-    class ServiceInstance {
-      constructor() {}
-    }
-
-    @Service()
-    class ServiceSingleton {
-      constructor() {}
-    }
-
-    @Service()
-    @Scope(ProviderScope.REQUEST)
-    class ServiceRequest implements OnDestroy {
-      constructor(
-        public serviceSingleton: ServiceSingleton,
-        public serviceInstance: ServiceInstance
-      ) {}
-
-      $onDestroy(): Promise<any> | void {
-        return undefined;
-      }
-    }
-
-    afterAll(() => {
-      GlobalProviders.delete(ServiceSingleton);
-      GlobalProviders.delete(ServiceRequest);
-      GlobalProviders.delete(ServiceInstance);
-    });
-
-    it("should load all providers with the SINGLETON scope only", async () => {
-      // GIVEN
-      const providers = new Container();
-      providers.add(ServiceInstance);
-      providers.add(ServiceSingleton);
-      providers.add(ServiceRequest);
-
-      // WHEN
-      await injector().load(providers);
-
-      // THEN
-      expect(injector().get(ServiceSingleton)).toEqual(inject(ServiceSingleton));
-      expect(injector().get(ServiceRequest)).toBeInstanceOf(ServiceRequest);
-      expect(injector().has(ServiceRequest)).toBeFalsy();
-      expect(injector().get(ServiceInstance)).toBeInstanceOf(ServiceInstance);
-      expect(injector().has(ServiceRequest)).toBeFalsy();
-
-      expect(injector().invoke(ServiceRequest) === injector().invoke(ServiceRequest)).toEqual(false);
-      expect(inject(ServiceInstance) === inject(ServiceInstance)).toEqual(false);
-
-      const locals = new LocalsContainer();
-      expect(inject(ServiceRequest, {locals})).toEqual(inject(ServiceRequest, {locals}));
-      expect(inject(ServiceInstance, {locals}) === inject(ServiceInstance, {locals})).toEqual(false);
-    });
-  });
-  describe("invoke class with abstract class", () => {
-    abstract class BaseService {}
-
-    @Injectable()
-    class NestedService extends BaseService {}
-
-    class BaseMyService {
-      @Inject(NestedService)
-      nested: BaseService;
-    }
-
-    @Injectable()
-    class MyService extends BaseMyService {}
-
-    afterAll(() => {
-      GlobalProviders.delete(MyService);
-      GlobalProviders.delete(NestedService);
-    });
-
-    it("should inject the expected class", async () => {
-      const providers = new Container();
-      providers.add(MyService);
-      providers.add(NestedService);
-
-      await injector().load(providers);
-
-      expect(injector().get<MyService>(MyService)!.nested).toBeInstanceOf(NestedService);
-    });
-  });
-  describe("invoke class with a symbol", () => {
-    interface BaseService {}
-
-    const BaseService: unique symbol = Symbol("BaseService");
-
-    @Injectable({token: BaseService})
-    class NestedService implements BaseService {}
-
-    @Injectable()
-    class MyService {
-      @Inject(BaseService)
-      nested: BaseService;
-    }
-
-    afterAll(() => {
-      GlobalProviders.delete(MyService);
-      GlobalProviders.delete(NestedService);
-    });
-
-    it("should inject the expected class", async () => {
-      const providers = new Container();
-      providers.add(MyService);
-      providers.add(NestedService);
-
-      await injector().load(providers);
-
-      expect(injector().get<MyService>(MyService)!.nested).toBeInstanceOf(NestedService);
-    });
-  });
-  describe("invoke class with a provider", () => {
-    it("should invoke class with a another useClass", async () => {
-      @Injectable()
-      class MyClass {}
-
-      class FakeMyClass {}
-
-      injector().addProvider(MyClass, {
-        useClass: FakeMyClass
-      });
-
-      const instance = inject(MyClass);
-
-      expect(instance).toBeInstanceOf(FakeMyClass);
-      expect(injector().get(MyClass)).toBeInstanceOf(FakeMyClass);
-
-      await injector().load();
-
-      expect(injector().get(MyClass)).toBeInstanceOf(FakeMyClass);
-    });
-  });
-});

package/src/common/integration/imports.spec.ts

@@ -1,39 +0,0 @@
-import {DITest} from "../../node/index.js";
-import {Inject} from "../decorators/inject.js";
-import {Injectable} from "../decorators/injectable.js";
-import {Module} from "../decorators/module.js";
-
-@Injectable()
-class MyService {
-  createConnection() {}
-}
-
-@Module()
-class MyModule {
-  @Inject()
-  myService: MyService;
-
-  $onInit() {
-    this.myService.createConnection();
-  }
-}
-
-describe("DITest", () => {
-  beforeEach(() =>
-    DITest.create({
-      imports: [
-        {
-          token: MyService,
-          use: {
-            createConnection: vi.fn()
-          }
-        }
-      ]
-    })
-  );
-
-  it("should create container with stubbed service", () => {
-    const service = DITest.get(MyService);
-    expect(service.createConnection).toHaveBeenCalledWith();
-  });
-});

package/src/common/integration/request.spec.ts

@@ -1,79 +0,0 @@
-import {beforeEach} from "vitest";
-
-import {Scope} from "../decorators/scope.js";
-import {Service} from "../decorators/service.js";
-import {Container} from "../domain/Container.js";
-import {LocalsContainer} from "../domain/LocalsContainer.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {destroyInjector, injector} from "../fn/injector.js";
-import {OnDestroy} from "../interfaces/OnDestroy.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-import {InjectorService} from "../services/InjectorService.js";
-
-describe("DI Request", () => {
-  beforeEach(() => destroyInjector());
-
-  @Service()
-  @Scope(ProviderScope.INSTANCE)
-  class ServiceInstance {
-    constructor() {}
-  }
-
-  @Service()
-  class ServiceSingleton {
-    constructor() {}
-  }
-
-  @Service()
-  @Scope(ProviderScope.REQUEST)
-  class ServiceRequest implements OnDestroy {
-    constructor(
-      public serviceSingleton: ServiceSingleton,
-      public serviceInstance: ServiceInstance
-    ) {}
-
-    $onDestroy(): Promise<any> | void {
-      return undefined;
-    }
-  }
-
-  afterAll(() => {
-    GlobalProviders.delete(ServiceSingleton);
-    GlobalProviders.delete(ServiceRequest);
-    GlobalProviders.delete(ServiceInstance);
-  });
-
-  describe("when invoke a service declared as REQUEST", () => {
-    it("should get a new instance of ServiceRequest", async () => {
-      // GIVEN
-      const container = new Container();
-
-      container.addProvider(ServiceSingleton);
-      container.addProvider(ServiceRequest);
-      container.addProvider(ServiceInstance);
-
-      await injector().load(container);
-
-      // we use a local container to create a new context
-      const locals = new LocalsContainer();
-
-      // WHEN
-      const result1: any = injector().invoke(ServiceRequest, {locals});
-      const result2: any = injector().invoke(ServiceRequest, {locals});
-      const serviceSingleton1: any = injector().invoke(ServiceSingleton, {locals});
-      const serviceSingleton2: any = injector().get(ServiceSingleton);
-
-      vi.spyOn(result1, "$onDestroy").mockResolvedValue(undefined);
-
-      await locals.destroy();
-      // THEN
-      expect(result1).toEqual(result2);
-      expect(result1.serviceSingleton).toEqual(serviceSingleton1);
-      expect(result1.serviceInstance).toBeInstanceOf(ServiceInstance);
-
-      expect(serviceSingleton1).toEqual(serviceSingleton2);
-
-      return expect(result1.$onDestroy).toHaveBeenCalledWith();
-    });
-  });
-});

package/src/common/integration/singleton.spec.ts

@@ -1,125 +0,0 @@
-import {Scope} from "../decorators/scope.js";
-import {Service} from "../decorators/service.js";
-import {Container} from "../domain/Container.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {destroyInjector, injector} from "../fn/injector.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-import {InjectorService} from "../services/InjectorService.js";
-
-describe("DI Singleton", () => {
-  @Service()
-  class ServiceSingleton {
-    constructor(public injector: InjectorService) {}
-  }
-
-  @Service()
-  @Scope(ProviderScope.REQUEST)
-  class ServiceRequest {
-    constructor() {}
-  }
-
-  @Service()
-  @Scope(ProviderScope.INSTANCE)
-  class ServiceInstance {
-    constructor() {}
-  }
-
-  @Service()
-  class ServiceSingletonWithRequestDep {
-    constructor(
-      public serviceRequest: ServiceRequest,
-      public serviceRequest2: ServiceRequest
-    ) {}
-  }
-
-  @Service()
-  class ServiceSingletonWithInstanceDep {
-    constructor(
-      public serviceInstance: ServiceInstance,
-      public serviceInstance2: ServiceInstance
-    ) {}
-  }
-
-  afterEach(() => destroyInjector());
-  afterAll(() => {
-    GlobalProviders.delete(ServiceSingleton);
-    GlobalProviders.delete(ServiceRequest);
-    GlobalProviders.delete(ServiceInstance);
-    GlobalProviders.delete(ServiceSingletonWithRequestDep);
-    GlobalProviders.delete(ServiceSingletonWithInstanceDep);
-  });
-
-  describe("when it has a SINGLETON dependency", () => {
-    it("should get the service instance", async () => {
-      // GIVEN
-      const container = new Container();
-
-      container.addProvider(ServiceSingleton);
-      container.addProvider(ServiceRequest);
-      container.addProvider(ServiceInstance);
-      container.addProvider(ServiceSingletonWithRequestDep);
-      container.addProvider(ServiceSingletonWithInstanceDep);
-
-      // WHEN
-      await injector().load(container);
-
-      // THEN
-      expect(injector().get<ServiceSingleton>(ServiceSingleton)!).toBeInstanceOf(ServiceSingleton);
-    });
-  });
-  describe("when it has a REQUEST dependency", () => {
-    it("should get the instance and REQUEST dependency should be considered as local SINGLETON", async () => {
-      // GIVEN
-      const container = new Container();
-      container.addProvider(ServiceSingleton);
-      container.addProvider(ServiceRequest);
-      container.addProvider(ServiceInstance);
-      container.addProvider(ServiceSingletonWithRequestDep);
-      container.addProvider(ServiceSingletonWithInstanceDep);
-
-      // WHEN
-      await injector().load(container);
-      const serviceSingletonWithReqDep = injector().get<ServiceSingletonWithRequestDep>(ServiceSingletonWithRequestDep)!;
-      const serviceRequest = injector().get<ServiceRequest>(ServiceRequest)!;
-
-      // THEN
-      expect(serviceSingletonWithReqDep).toBeInstanceOf(ServiceSingletonWithRequestDep);
-      expect(serviceSingletonWithReqDep.serviceRequest).toBeInstanceOf(ServiceRequest);
-      expect(serviceSingletonWithReqDep.serviceRequest2).toBeInstanceOf(ServiceRequest);
-
-      // The same service injected twice or more are considered as a Singleton (REQUEST downgraded to SINGLETON)
-      expect(serviceSingletonWithReqDep.serviceRequest).toEqual(serviceSingletonWithReqDep.serviceRequest2);
-
-      // The service isn't registered in the injectorService
-      expect(serviceRequest).toBeDefined();
-      expect(injector().has(ServiceRequest)).toEqual(false);
-    });
-  });
-  describe("when it has a INSTANCE dependency", () => {
-    it("should get the service instance", async () => {
-      // GIVEN
-      const container = new Container();
-      container.addProvider(ServiceSingleton);
-      container.addProvider(ServiceRequest);
-      container.addProvider(ServiceInstance);
-      container.addProvider(ServiceSingletonWithRequestDep);
-      container.addProvider(ServiceSingletonWithInstanceDep);
-      // WHEN
-      await injector().load(container);
-      const serviceWithInstDep = injector().get<ServiceSingletonWithInstanceDep>(ServiceSingletonWithInstanceDep)!;
-      const serviceInstance = injector().get<ServiceInstance>(ServiceInstance)!;
-
-      // THEN
-      expect(serviceWithInstDep).toBeInstanceOf(ServiceSingletonWithInstanceDep);
-      expect(serviceWithInstDep.serviceInstance).toBeInstanceOf(ServiceInstance);
-      expect(serviceWithInstDep.serviceInstance2).toBeInstanceOf(ServiceInstance);
-
-      // A same service injected twice or more are considered as a new INSTANCE for each injection
-      expect(serviceWithInstDep.serviceInstance === serviceWithInstDep.serviceInstance2).toEqual(false);
-
-      // The service isn't registered in the injectorService
-      expect(serviceInstance).toBeInstanceOf(ServiceInstance);
-      expect(injector().has(ServiceInstance)).toEqual(false);
-    });
-  });
-});

package/src/common/interfaces/DIConfigurationOptions.ts

@@ -1,29 +0,0 @@
-import type {ProviderScope} from "../domain/ProviderScope.js";
-import type {ImportTokenProviderOpts} from "./ImportTokenProviderOpts.js";
-import type {TokenProvider} from "./TokenProvider.js";
-
-declare global {
-  namespace TsED {
-    // @ts-ignore
-    interface Context {}
-
-    /**
-     * Here to allow extension on DIConfiguration base service
-     */
-    interface DIConfiguration {}
-
-    interface Configuration extends Record<string, any> {
-      scopes: {[key: string]: ProviderScope};
-      /**
-       * Define dependencies to build the provider
-       */
-      imports: (TokenProvider | ImportTokenProviderOpts)[];
-      /**
-       * Mount controllers
-       */
-      mount: Record<string, TokenProvider[]>;
-    }
-  }
-}
-
-export interface DIConfigurationOptions extends TsED.Configuration {}

package/src/common/interfaces/DILogger.ts

@@ -1,13 +0,0 @@
-export interface DILogger {
-  info(...args: any[]): void | any;
-
-  warn(...args: any[]): void | any;
-
-  debug(...args: any[]): void | any;
-
-  error(...args: any[]): void | any;
-
-  trace(...args: any[]): void | any;
-
-  [key: string]: any;
-}

package/src/common/interfaces/DILoggerOptions.ts

@@ -1,54 +0,0 @@
-export interface DILoggerOptions {
-  /**
-   * Enable debug mode. By default debug is false.
-   */
-  debug?: boolean;
-  /**
-   * Enable info mode. By default debug is false.
-   */
-  level?: "debug" | "info" | "warn" | "error" | "off";
-  /**
-   * Enable log performance tracker and disable log server.
-   */
-  perf?: boolean;
-  /**
-   * List of regexp to ignore log.
-   */
-  ignoreUrlPatterns?: (string | RegExp)[];
-  /**
-   * The number of space characters to use as white space in JSON output. Default is 2 (0 in production).
-   */
-  jsonIndentation?: number;
-  /**
-   * A function called for each incoming request to create a request id.
-   * @returns {number}
-   */
-  reqIdBuilder?: (req: any) => string;
-  /**
-   * Disable routes table displayed in the logger. By default debug is `false`.
-   */
-  disableRoutesSummary?: boolean;
-  /**
-   * Disable bootstrap log displayed in the logger. By default debug is `false`.
-   */
-  disableBootstrapLog?: boolean;
-  /**
-   * Specify log format. Example: `%[%d{[yyyy-MM-dd hh:mm:ss,SSS}] %p%] %m`. See [@tsed/logger configuration](https://tsedio.github.io/logger/).
-   */
-  format?: string;
-  /**
-   * Specify the log stack size for the context.logger. When the stack.length is reach, the logger is flushed during the request.
-   * Default size is set to 30.
-   */
-  maxStackSize?: number;
-}
-
-declare global {
-  namespace TsED {
-    interface LoggerConfiguration extends DILoggerOptions {}
-
-    interface Configuration extends Record<string, any> {
-      logger?: LoggerConfiguration;
-    }
-  }
-}

package/src/common/interfaces/ImportTokenProviderOpts.ts

@@ -1,29 +0,0 @@
-import type {AbstractType, Type} from "@tsed/core";
-
-import type {TokenProvider} from "./TokenProvider.js";
-
-export type UseImportTokenProviderOpts = {
-  token: TokenProvider;
-  use: unknown;
-};
-
-export type UseClassImportTokenProviderOpts = {
-  token: TokenProvider;
-  useClass: Type | AbstractType<any>;
-};
-
-export type UseFactoryImportTokenProviderOpts = {
-  token: TokenProvider;
-  useFactory: (...args: unknown[]) => unknown;
-};
-
-export type UseAsyncFactoryImportTokenProviderOpts = {
-  token: TokenProvider;
-  useAsyncFactory: (...args: unknown[]) => Promise<unknown>;
-};
-
-export type ImportTokenProviderOpts =
-  | UseImportTokenProviderOpts
-  | UseClassImportTokenProviderOpts
-  | UseFactoryImportTokenProviderOpts
-  | UseAsyncFactoryImportTokenProviderOpts;

package/src/common/interfaces/InterceptorContext.ts

@@ -1,13 +0,0 @@
-import type {Type} from "@tsed/core";
-
-export interface InterceptorNext {
-  <T>(err?: Error): T;
-}
-
-export interface InterceptorContext<Klass = Type, Opts = any> {
-  target: Klass;
-  propertyKey: string | symbol;
-  args: any[];
-  next: InterceptorNext;
-  options?: Opts;
-}

package/src/common/interfaces/InterceptorMethods.ts

@@ -1,5 +0,0 @@
-import type {InterceptorContext, InterceptorNext} from "./InterceptorContext.js";
-
-export interface InterceptorMethods {
-  intercept(context: InterceptorContext, next?: InterceptorNext): any;
-}

package/src/common/interfaces/InvokeOptions.ts

@@ -1,28 +0,0 @@
-import type {LocalsContainer} from "../domain/LocalsContainer.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {TokenProvider} from "./TokenProvider.js";
-
-export interface InvokeOptions {
-  /**
-   * Define dependencies to build the provider and inject them in the constructor.
-   */
-  deps: TokenProvider[];
-  /**
-   * List of imports to be created before the provider. Imports list aren't injected directly in the provider constructor.
-   */
-  imports: TokenProvider[];
-  /**
-   * Parent provider.
-   */
-  parent?: TokenProvider;
-  /**
-   * If true, the injector will rebuild the instance.
-   */
-  rebuild?: boolean;
-  /**
-   * Option given to injectable props or parameter constructor (UseOpts).
-   */
-  useOpts?: Record<string, unknown>;
-
-  locals?: LocalsContainer;
-}

package/src/common/interfaces/OnDestroy.ts

@@ -1,3 +0,0 @@
-export interface OnDestroy {
-  $onDestroy(): Promise<any> | void;
-}

package/src/common/interfaces/OnInit.ts

@@ -1,3 +0,0 @@
-export interface OnInit {
-  $onInit(): Promise<any> | void;
-}

package/src/common/interfaces/ProviderOpts.ts

@@ -1,57 +0,0 @@
-import type {Type} from "@tsed/core";
-
-import type {ProviderScope} from "../domain/ProviderScope.js";
-import type {ProviderType} from "../domain/ProviderType.js";
-import type {TokenProvider} from "./TokenProvider.js";
-
-export interface ProviderOpts<T = any> {
-  /**
-   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
-   */
-  token: TokenProvider<T>;
-  /**
-   * Create alias token to retrieve the instance provider.
-   */
-  alias?: TokenProvider;
-  /**
-   * Provider type
-   */
-  type?: TokenProvider | ProviderType;
-  /**
-   * Instance build by the injector
-   */
-  instance?: T;
-  /**
-   * Define dependencies to build the provider
-   */
-  deps?: TokenProvider[];
-  /**
-   * Class to instantiate for the `token`.
-   */
-  useClass?: Type<T>;
-  /**
-   * Provide a function to build the provider
-   */
-  useFactory?: Function;
-  /**
-   * Provide an async function to build the provider
-   */
-  useAsyncFactory?: Function;
-  /**
-   * Provide predefined value
-   */
-  useValue?: any;
-  /**
-   * Scope used by the injector to build the provider.
-   */
-  scope?: ProviderScope;
-
-  /**
-   * hooks to intercept custom events
-   */
-  hooks?: Record<string, (instance: T, ...args: any[]) => Promise<any> | any>;
-  /**
-   *
-   */
-  [key: string]: any;
-}

package/src/common/interfaces/RegistrySettings.ts

@@ -1,11 +0,0 @@
-import {Type} from "@tsed/core/types/Type.js";
-
-import type {Provider} from "../domain/Provider.js";
-
-/**
- * @ignore
- */
-export interface RegistrySettings {
-  injectable?: boolean;
-  model?: Type<Provider>;
-}

package/src/common/interfaces/ResolvedInvokeOptions.ts

@@ -1,14 +0,0 @@
-import type {LocalsContainer} from "../domain/LocalsContainer.js";
-import type {Provider} from "../domain/Provider.js";
-import type {TokenProvider} from "./TokenProvider.js";
-
-export interface ResolvedInvokeOptions {
-  token: TokenProvider;
-  parent?: TokenProvider;
-  deps: TokenProvider[];
-  imports: (TokenProvider | [TokenProvider])[];
-  provider: Provider;
-  locals: LocalsContainer;
-
-  construct(deps: TokenProvider[]): any;
-}

package/src/common/interfaces/TokenProvider.ts

@@ -1,8 +0,0 @@
-import type {AbstractType, Type} from "@tsed/core";
-
-/**
- * A token is a unique identifier for a provider in the dependency injection system.
- * It solves the inference problem when using `inject()` function.
- */
-export type FactoryTokenProvider<T = any> = T & {readonly __type: "token_factory"};
-export type TokenProvider<T = any> = string | symbol | Type<T> | AbstractType<T> | FactoryTokenProvider<T>;

package/src/common/interfaces/TokenRoute.ts

@@ -1,6 +0,0 @@
-import {TokenProvider} from "./TokenProvider.js";
-
-export interface TokenRoute {
-  token: TokenProvider;
-  route: string;
-}