@tsed/di 8.0.1 → 8.0.3

package/src/common/index.ts

@@ -0,0 +1,63 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./constants/constants.js";
+export * from "./decorators/autoInjectable.js";
+export * from "./decorators/configuration.js";
+export * from "./decorators/constant.js";
+export * from "./decorators/controller.js";
+export * from "./decorators/inject.js";
+export * from "./decorators/injectable.js";
+export * from "./decorators/intercept.js";
+export * from "./decorators/interceptor.js";
+export * from "./decorators/lazyInject.js";
+export * from "./decorators/module.js";
+export * from "./decorators/opts.js";
+export * from "./decorators/overrideProvider.js";
+export * from "./decorators/scope.js";
+export * from "./decorators/service.js";
+export * from "./decorators/useOpts.js";
+export * from "./decorators/value.js";
+export * from "./domain/Container.js";
+export * from "./domain/ControllerProvider.js";
+export * from "./domain/InjectablePropertyType.js";
+export * from "./domain/LocalsContainer.js";
+export * from "./domain/Provider.js";
+export * from "./domain/ProviderScope.js";
+export * from "./domain/ProviderType.js";
+export * from "./errors/InjectionError.js";
+export * from "./errors/InvalidPropertyTokenError.js";
+export * from "./fn/configuration.js";
+export * from "./fn/constant.js";
+export * from "./fn/inject.js";
+export * from "./fn/injectable.js";
+export * from "./fn/injectMany.js";
+export * from "./fn/injector.js";
+export * from "./fn/lazyInject.js";
+export * from "./fn/localsContainer.js";
+export * from "./fn/refValue.js";
+export * from "./interfaces/DIConfigurationOptions.js";
+export * from "./interfaces/DILogger.js";
+export * from "./interfaces/DILoggerOptions.js";
+export * from "./interfaces/ImportTokenProviderOpts.js";
+export * from "./interfaces/InterceptorContext.js";
+export * from "./interfaces/InterceptorMethods.js";
+export * from "./interfaces/InvokeOptions.js";
+export * from "./interfaces/OnDestroy.js";
+export * from "./interfaces/OnInit.js";
+export * from "./interfaces/ProviderOpts.js";
+export * from "./interfaces/RegistrySettings.js";
+export * from "./interfaces/ResolvedInvokeOptions.js";
+export * from "./interfaces/TokenProvider.js";
+export * from "./interfaces/TokenRoute.js";
+export * from "./registries/GlobalProviders.js";
+export * from "./registries/ProviderRegistry.js";
+export * from "./services/DIConfiguration.js";
+export * from "./services/DILogger.js";
+export * from "./services/InjectorService.js";
+export * from "./utils/colors.js";
+export * from "./utils/createContainer.js";
+export * from "./utils/discoverHooks.js";
+export * from "./utils/getConfiguration.js";
+export * from "./utils/getConstructorDependencies.js";
+export * from "./utils/providerBuilder.js";

package/src/common/integration/async-factory.spec.ts

@@ -0,0 +1,60 @@
+import {isPromise} from "@tsed/core";
+import {afterEach, beforeEach} from "vitest";
+
+import {Inject} from "../decorators/inject.js";
+import {Injectable} from "../decorators/injectable.js";
+import {Container} from "../domain/Container.js";
+import {destroyInjector, injector} from "../fn/injector.js";
+import {GlobalProviders} from "../registries/GlobalProviders.js";
+import {registerProvider} from "../registries/ProviderRegistry.js";
+import {InjectorService} from "../services/InjectorService.js";
+
+describe("DI", () => {
+  afterEach(() => destroyInjector());
+  describe("create new injector", () => {
+    const ASYNC_FACTORY = Symbol.for("ASYNC_FACTORY");
+
+    registerProvider({
+      token: ASYNC_FACTORY,
+
+      useAsyncFactory() {
+        return {
+          connection: true,
+          close() {}
+        };
+      },
+      hooks: {
+        $onDestroy(instance: any) {
+          return instance.close();
+        }
+      }
+    });
+
+    @Injectable()
+    class Server {
+      @Inject(ASYNC_FACTORY)
+      asyncFactory: any;
+    }
+
+    afterAll(() => {
+      GlobalProviders.delete(Server);
+      GlobalProviders.delete(ASYNC_FACTORY);
+    });
+
+    it("should load all providers with the SINGLETON scope only", async () => {
+      // GIVEN
+      const container = new Container();
+      container.add(ASYNC_FACTORY);
+      container.add(Server);
+
+      const server = injector().invoke<any>(Server);
+      expect(isPromise(server.asyncFactory)).toEqual(true);
+
+      // WHEN
+      await injector().load(container);
+
+      expect(isPromise(server.asyncFactory)).toEqual(false);
+      expect(server.asyncFactory.connection).toEqual(true);
+    });
+  });
+});

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

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

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

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

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

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

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

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

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

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

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