@tsed/di 8.0.1 → 8.0.3

package/src/common/domain/Container.spec.ts

@@ -0,0 +1,85 @@
+import {Container} from "./Container.js";
+import {Provider} from "./Provider.js";
+import {ProviderType} from "./ProviderType.js";
+
+describe("Container", () => {
+  describe("getProvider()", () => {
+    class Test {}
+
+    it("should return a provider", () => {
+      // GIVEN
+      const container = new Container();
+      const provider = new Provider(Test);
+
+      container.add(Test, provider);
+
+      // WHEN
+      const result = container.getProvider(Test);
+
+      // THEN
+      expect(result!).toBeInstanceOf(Provider);
+    });
+  });
+  describe("getProviders()", () => {
+    let container: Container;
+
+    beforeEach(() => {
+      class MyMiddleware {}
+
+      class MyService {}
+
+      class MyController {}
+
+      container = new Container();
+      container.addProvider(MyMiddleware, {type: ProviderType.MIDDLEWARE});
+      container.addProvider(MyService, {type: ProviderType.PROVIDER});
+      container.addProvider(MyController, {type: ProviderType.CONTROLLER});
+
+      // await container.load();
+    });
+
+    it("should return middlewares only", () => {
+      const providers = container.getProviders(ProviderType.MIDDLEWARE);
+
+      const result = providers.find((item: any) => item.type !== ProviderType.MIDDLEWARE);
+
+      expect(providers[0].type).toEqual(ProviderType.MIDDLEWARE);
+      expect(result).toBeUndefined();
+    });
+
+    it("should return controllers only", () => {
+      const providers = container.getProviders(ProviderType.CONTROLLER);
+
+      const result = providers.find((item: any) => item.type !== ProviderType.CONTROLLER);
+
+      expect(providers[0].type).toEqual(ProviderType.CONTROLLER);
+      expect(result).toBeUndefined();
+    });
+
+    it("should return all providers", () => {
+      const providers = container.getProviders();
+      const controllers = providers.filter((item: any) => item.type === ProviderType.CONTROLLER);
+      const middlewares = providers.filter((item: any) => item.type === ProviderType.MIDDLEWARE);
+
+      expect(providers.length > 0).toEqual(true);
+      expect(controllers.length > 0).toEqual(true);
+      expect(middlewares.length > 0).toEqual(true);
+    });
+  });
+  describe("addProviders()", () => {
+    it("should add providers", () => {
+      class Test {}
+
+      // GIVEN
+      const container = new Container();
+      const childContainer = new Container();
+      childContainer.addProvider(Test);
+
+      // WHEN
+      container.addProviders(childContainer);
+
+      // THEN
+      expect(container.getProvider(Test)!).toBeInstanceOf(Provider);
+    });
+  });
+});

package/src/common/domain/Container.ts

@@ -0,0 +1,80 @@
+import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import {GlobalProviders} from "../registries/GlobalProviders.js";
+import {Provider} from "./Provider.js";
+import type {ProviderType} from "./ProviderType.js";
+
+export class Container extends Map<TokenProvider, Provider> {
+  /**
+   *
+   * @param token
+   * @param settings
+   */
+  public add(token: TokenProvider, settings: Partial<ProviderOpts> = {}): this {
+    const provider = GlobalProviders.get(token)?.clone() || new Provider(token);
+
+    Object.assign(provider, settings);
+
+    return super.set(token, provider);
+  }
+
+  /**
+   * Add a provider to the
+   * @param token
+   * @param settings
+   */
+  public addProvider(token: TokenProvider, settings: Partial<ProviderOpts> = {}): this {
+    return this.add(token, settings);
+  }
+
+  /**
+   *
+   * @param token
+   */
+  public hasProvider(token: TokenProvider) {
+    return super.has(token);
+  }
+
+  /**
+   * Add a provider to the
+   * @param token
+   * @param provider
+   */
+  public setProvider(token: TokenProvider, provider: Provider) {
+    return super.set(token, provider);
+  }
+
+  /**
+   * The getProvider() method returns a specified element from a Map object.
+   * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+   * @param token
+   */
+  public getProvider<T extends Provider = Provider>(token: TokenProvider | undefined): T | undefined {
+    return super.get(token!) as T;
+  }
+
+  /**
+   * Get all providers registered in the injector container.
+   *
+   * @param type Filter the list by the given ProviderType.
+   * @returns {[TokenProvider , Provider<any>][]}
+   */
+  public getProviders(type?: TokenProvider | ProviderType | string | string[]): Provider[] {
+    const types = ([] as (string | ProviderType)[]).concat(type as never).map(String);
+
+    return [...this].reduce((providers, [_, provider]) => {
+      if (types.includes(String(provider.type)) || !type) {
+        return [...providers, provider];
+      }
+      return providers;
+    }, []);
+  }
+
+  public addProviders(container: Map<TokenProvider, Provider>) {
+    container.forEach((provider) => {
+      if (!this.hasProvider(provider.token)) {
+        this.setProvider(provider.token, provider.clone());
+      }
+    });
+  }
+}

package/src/common/domain/ControllerProvider.spec.ts

@@ -0,0 +1,55 @@
+import {ControllerProvider} from "./ControllerProvider.js";
+import {ProviderScope} from "./ProviderScope.js";
+
+class Test {}
+
+describe("ControllerProvider", () => {
+  let controllerProvider: ControllerProvider;
+
+  beforeAll(() => {
+    controllerProvider = new ControllerProvider(Test);
+    controllerProvider.path = "/";
+    controllerProvider.scope = ProviderScope.REQUEST;
+    controllerProvider.middlewares = {
+      useBefore: [new Function()],
+      use: [new Function()],
+      useAfter: [new Function()]
+    };
+  });
+
+  it("should have type field to equals to controller", () => {
+    expect(controllerProvider.type).toEqual("controller");
+  });
+
+  it("should get path", () => {
+    expect(controllerProvider.path).toEqual("/");
+  });
+
+  it("should get children", () => {
+    expect(controllerProvider.children).toHaveLength(0);
+  });
+
+  it("should get a scope", () => {
+    expect(controllerProvider.scope).toEqual("request");
+  });
+
+  it("should have children", () => {
+    expect(controllerProvider.hasChildren()).toEqual(false);
+  });
+  it("should get parent", () => {
+    expect(!!controllerProvider.parent).toBe(false);
+  });
+
+  it("should have parent", () => {
+    expect(!!controllerProvider.hasParent()).toBe(false);
+  });
+
+  it("should have a middlewares", () => {
+    expect(Array.isArray(controllerProvider.middlewares.use)).toBe(true);
+    expect(controllerProvider.middlewares.use![0]).toBeInstanceOf(Function);
+    expect(Array.isArray(controllerProvider.middlewares.useAfter)).toBe(true);
+    expect(controllerProvider.middlewares.useAfter![0]).toBeInstanceOf(Function);
+    expect(Array.isArray(controllerProvider.middlewares.useBefore)).toBe(true);
+    expect(controllerProvider.middlewares.useBefore![0]).toBeInstanceOf(Function);
+  });
+});

package/src/common/domain/ControllerProvider.ts

@@ -0,0 +1,48 @@
+import {TokenProvider} from "../interfaces/TokenProvider.js";
+import {Provider} from "./Provider.js";
+import {ProviderType} from "./ProviderType.js";
+
+export interface ControllerMiddlewares {
+  useBefore: TokenProvider[];
+  use: TokenProvider[];
+  useAfter: TokenProvider[];
+}
+
+export class ControllerProvider<T = any> extends Provider<T> {
+  public tokenRouter: string;
+
+  constructor(token: TokenProvider, options: Partial<Provider> = {}) {
+    super(token, options);
+    this.type = ProviderType.CONTROLLER;
+  }
+
+  /**
+   *
+   * @returns {any[]}
+   */
+  get middlewares(): Partial<ControllerMiddlewares> {
+    return Object.assign(
+      {
+        use: [],
+        useAfter: [],
+        useBefore: []
+      },
+      this.store.get("middlewares", {})
+    );
+  }
+
+  /**
+   *
+   * @param middlewares
+   */
+  set middlewares(middlewares: Partial<ControllerMiddlewares>) {
+    const mdlwrs = this.middlewares;
+    const concat = (key: string, a: any, b: any) => (a[key] = a[key].concat(b[key]));
+
+    Object.keys(middlewares).forEach((key: string) => {
+      concat(key, mdlwrs, middlewares);
+    });
+
+    this.store.set("middlewares", mdlwrs);
+  }
+}

package/src/common/domain/InjectablePropertyType.ts

@@ -0,0 +1,7 @@
+export enum InjectablePropertyType {
+  METHOD = "method",
+  PROPERTY = "property",
+  CONSTANT = "constant",
+  VALUE = "value",
+  INTERCEPTOR = "interceptor"
+}

package/src/common/domain/LocalsContainer.spec.ts

@@ -0,0 +1,20 @@
+import {LocalsContainer} from "./LocalsContainer.js";
+
+describe("LocalsContainer", () => {
+  describe("destroy()", () => {
+    it("should destroy container", async () => {
+      // GIVEN
+      const instance = {
+        $onDestroy: vi.fn().mockResolvedValue(undefined)
+      };
+      const container = new LocalsContainer();
+      container.set("TOKEN", instance);
+
+      container.hooks.on("$onDestroy", () => instance.$onDestroy());
+
+      await container.destroy();
+
+      expect(instance.$onDestroy).toHaveBeenCalledWith();
+    });
+  });
+});

package/src/common/domain/LocalsContainer.ts

@@ -0,0 +1,11 @@
+import {Hooks} from "@tsed/hooks";
+
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+
+export class LocalsContainer extends Map<TokenProvider, any> {
+  readonly hooks = new Hooks();
+
+  async destroy() {
+    await this.hooks.asyncEmit("$onDestroy");
+  }
+}

package/src/common/domain/Provider.spec.ts

@@ -0,0 +1,107 @@
+import {Provider} from "./Provider.js";
+import {ProviderScope} from "./ProviderScope.js";
+
+class T1 {}
+
+class T2 {}
+
+const S1 = Symbol.for("S1");
+
+describe("Provider", () => {
+  describe("when is a class", () => {
+    it("should wrap the token provided", () => {
+      const provider = new Provider(T1);
+      provider.scope = ProviderScope.REQUEST;
+      provider.customProp = "test";
+
+      expect(provider.token).toEqual(T1);
+      expect(provider.useClass).toEqual(T1);
+      expect(!!provider.store).toEqual(true);
+      expect(provider.clone()).toEqual(provider);
+    });
+
+    it("should override the token provider", () => {
+      const provider = new Provider(T1);
+      provider.scope = ProviderScope.REQUEST;
+      provider.customProp = "test";
+      provider.useClass = T2;
+
+      const cloned = provider.clone();
+
+      expect(provider.token).toEqual(T1);
+      expect(provider.useClass).toEqual(T2);
+      expect(!!provider.store).toEqual(true);
+      expect(cloned.useClass).toEqual(T2);
+      expect(cloned.scope).toEqual(ProviderScope.REQUEST);
+      expect(provider.hasChildren()).toEqual(false);
+      expect(provider.hasParent()).toEqual(false);
+    });
+  });
+
+  describe("when is a symbol", () => {
+    it("should wrap the token provided", () => {
+      const provider = new Provider(S1);
+
+      expect(provider.token).toEqual(S1);
+      expect(!!provider.useClass).toEqual(false);
+      expect(!!provider.store).toEqual(true);
+    });
+  });
+
+  describe("when is a string", () => {
+    it("should wrap the token provided", () => {
+      const provider = new Provider("test");
+
+      expect(provider.token).toEqual("test");
+      expect(provider.provide).toEqual("test");
+      expect(!!provider.useClass).toEqual(false);
+      expect(!!provider.store).toEqual(true);
+    });
+  });
+
+  describe("clone()", () => {
+    it("should clone a provider", () => {
+      const provider = new Provider(T1);
+      provider.type = "provider";
+      provider.scope = ProviderScope.REQUEST;
+    });
+  });
+
+  describe("className", () => {
+    it("should return the class name", () => {
+      expect(new Provider(T1).className).toEqual("T1");
+    });
+
+    it("should return the symbol name", () => {
+      expect(new Provider(S1).className).toEqual("S1");
+    });
+  });
+
+  describe("name", () => {
+    it("should return the class name", () => {
+      expect(new Provider(T1).name).toEqual("T1");
+    });
+  });
+  describe("path", () => {
+    it("should return set the path", () => {
+      const provider = new Provider(T1);
+      provider.path = "path";
+      expect(provider.path).toEqual("path");
+    });
+  });
+
+  describe("toString()", () => {
+    it("should return the class name", () => {
+      expect(new Provider(T1).toString()).toEqual("Token:T1:T1");
+    });
+  });
+
+  describe("isAsync()", () => {
+    it("should return true", () => {
+      const provider = new Provider(T1);
+      provider.useAsyncFactory = () => Promise.resolve("test");
+
+      expect(provider.isAsync()).toEqual(true);
+    });
+  });
+});

package/src/common/domain/Provider.ts

@@ -0,0 +1,205 @@
+import {type AbstractType, classOf, getClassOrSymbol, isClass, nameOf, Store, Type} from "@tsed/core";
+
+import {DI_USE_PARAM_OPTIONS} from "../constants/constants.js";
+import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import {discoverHooks} from "../utils/discoverHooks.js";
+import {ProviderScope} from "./ProviderScope.js";
+import {ProviderType} from "./ProviderType.js";
+
+export type ProviderHookCallback<T = any> = (instance: T, ...args: unknown[]) => Promise<void> | void;
+
+export class Provider<T = any> implements ProviderOpts<T> {
+  /**
+   * Token group provider to retrieve all provider from the same type
+   */
+  public type: ProviderType | TokenProvider = ProviderType.PROVIDER;
+  public deps: TokenProvider[];
+  public imports: (TokenProvider | [TokenProvider])[];
+  public alias: string;
+  public priority: number;
+  public useFactory?: Function;
+  public useAsyncFactory?: Function;
+  public useValue?: unknown;
+  public hooks: Record<string, ProviderHookCallback<T>> = {};
+  #useClass: Type<T>;
+  #token: TokenProvider;
+  #store: Store;
+  #tokenStore: Store;
+
+  [key: string]: any;
+
+  constructor(token: TokenProvider<T>, options: Partial<Provider> = {}) {
+    this.token = token;
+    this.useClass = token as Type<T>;
+
+    Object.assign(this, options);
+
+    if (options instanceof Provider) {
+      this.#useClass = options.#useClass;
+      this.#store = options.#store;
+      this.#tokenStore = options.#tokenStore;
+    }
+  }
+
+  get token() {
+    return this.#token;
+  }
+
+  set token(value: TokenProvider) {
+    if (value) {
+      this.#token = getClassOrSymbol(value);
+      this.#tokenStore = this.#store = Store.from(value);
+    }
+  }
+
+  /**
+   * @deprecated
+   */
+  get provide(): TokenProvider {
+    return this.token;
+  }
+
+  /**
+   * @deprecated
+   * @param value
+   */
+  set provide(value: TokenProvider) {
+    this.token = value;
+  }
+
+  get useClass(): Type<T> {
+    return this.#useClass;
+  }
+
+  /**
+   * Create a new store if the given value is a class. Otherwise, the value is ignored.
+   * @param value
+   */
+  set useClass(value: Type<T> | AbstractType<T>) {
+    if (isClass(value)) {
+      this.#useClass = classOf(value);
+      this.#store = Store.from(value);
+      this.hooks = discoverHooks(this.#useClass);
+    }
+  }
+
+  get className() {
+    return this.name;
+  }
+
+  get name() {
+    return nameOf(this.token);
+  }
+
+  get store(): Store {
+    return this.#store;
+  }
+
+  get path() {
+    return this.store.get("path", "/");
+  }
+
+  set path(path: string) {
+    this.store.set("path", path);
+  }
+
+  /**
+   * Get the scope of the provider.
+   *
+   * ::: tip Note
+   * Async provider is always a SINGLETON
+   * :::
+   *
+   * @returns {boolean}
+   */
+  get scope(): ProviderScope {
+    if (this.isAsync()) {
+      return ProviderScope.SINGLETON;
+    }
+
+    return this.get<ProviderScope>("scope", ProviderScope.SINGLETON);
+  }
+
+  /**
+   * Change the scope value of the provider.
+   * @param scope
+   */
+  set scope(scope: ProviderScope) {
+    this.store.set("scope", scope);
+  }
+
+  get configuration(): Partial<TsED.Configuration> {
+    return this.get("configuration")!;
+  }
+
+  set configuration(configuration: Partial<TsED.Configuration>) {
+    this.store.set("configuration", configuration);
+  }
+
+  get children(): TokenProvider[] {
+    return this.store.get("childrenControllers", []);
+  }
+
+  set children(children: TokenProvider[]) {
+    this.store.set("childrenControllers", children);
+  }
+
+  getArgOpts(index: number) {
+    return this.store.get(`${DI_USE_PARAM_OPTIONS}:${index}`);
+  }
+
+  /**
+   * Retrieves a value from the provider's store.
+   * @param key The key to look up
+   * @returns The value if found, undefined otherwise
+   */
+  get<Type = unknown>(key: string): Type | undefined;
+  /**
+   * Retrieves a value from the provider's store with a default fallback.
+   * @param key The key to look up
+   * @param defaultValue The value to return if key is not found
+   * @returns The found value or defaultValue
+   */
+  get<Type = unknown>(key: string, defaultValue: Type): Type;
+  get<Type = unknown>(key: string, defaultValue?: Type): Type | undefined {
+    return this.store.get(key) || this.#tokenStore.get(key) || defaultValue;
+  }
+
+  isAsync(): boolean {
+    return !!this.useAsyncFactory;
+  }
+
+  clone(): Provider {
+    return new (classOf(this))(this.token, this);
+  }
+
+  /**
+   *
+   * @returns {boolean}
+   */
+  public hasChildren(): boolean {
+    return !!this.children.length;
+  }
+
+  /**
+   *
+   * @returns {boolean}
+   */
+  public hasParent(): boolean {
+    return !!this.store.get("parentController");
+  }
+
+  toString() {
+    return [
+      "Token",
+      this.name,
+      this.useClass && nameOf(this.useClass),
+      this.useFactory && "Factory",
+      this.useValue && "Value",
+      this.useAsyncFactory && "AsyncFactory"
+    ]
+      .filter(Boolean)
+      .join(":");
+  }
+}

package/src/common/domain/ProviderScope.ts

@@ -0,0 +1,5 @@
+export enum ProviderScope {
+  SINGLETON = "singleton",
+  REQUEST = "request",
+  INSTANCE = "instance"
+}

package/src/common/domain/ProviderType.ts

@@ -0,0 +1,8 @@
+export enum ProviderType {
+  VALUE = "value",
+  PROVIDER = "provider",
+  MODULE = "module",
+  CONTROLLER = "controller",
+  INTERCEPTOR = "interceptor",
+  MIDDLEWARE = "middleware"
+}

package/src/common/errors/InjectionError.spec.ts

@@ -0,0 +1,17 @@
+import {InjectionError} from "./InjectionError.js";
+
+describe("InjectionError", () => {
+  it("should create new instance of InjectionError (1)", () => {
+    const error = new InjectionError(class Target {}, "SERVICE");
+
+    expect(error.message).toEqual("Injection failed on Target\nOrigin: SERVICE");
+    expect(error.name).toEqual("INJECTION_ERROR");
+  });
+
+  it("should create new instance of InjectionError (2)", () => {
+    const error = new InjectionError(class Target {}, new Error("test"));
+
+    expect(error.message).toEqual("Injection failed on Target\nOrigin: test");
+    expect(error.name).toEqual("INJECTION_ERROR");
+  });
+});