@tsed/di 8.11.0 → 8.11.2-rc.1

package/src/common/domain/ControllerProvider.ts

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

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

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

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

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

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

@@ -1,218 +0,0 @@
-import {Store} from "@tsed/core/types/Store.js";
-import {type AbstractType, Type} from "@tsed/core/types/Type.js";
-import {classOf} from "@tsed/core/utils/classOf.js";
-import {getClassOrSymbol} from "@tsed/core/utils/getClassOrSymbol.js";
-import {isClass} from "@tsed/core/utils/isClass.js";
-import {nameOf} from "@tsed/core/utils/nameOf.js";
-
-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(":");
-  }
-
-  reset() {
-    this.useValue = undefined;
-    this.useFactory = undefined;
-    this.useAsyncFactory = undefined;
-
-    return this;
-  }
-}

package/src/common/domain/ProviderScope.ts

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

package/src/common/domain/ProviderType.ts

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

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

@@ -1,17 +0,0 @@
-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");
-  });
-});

package/src/common/errors/InjectionError.ts

@@ -1,71 +0,0 @@
-import {getConstructorArgNames} from "@tsed/core/utils/getConstructorArgNames.js";
-import {isClass} from "@tsed/core/utils/isClass.js";
-import {isString} from "@tsed/core/utils/isString.js";
-import {nameOf} from "@tsed/core/utils/nameOf.js";
-
-import {TokenProvider} from "../interfaces/TokenProvider.js";
-import {colors} from "../utils/colors.js";
-
-export class InjectionError extends Error {
-  name = "INJECTION_ERROR";
-
-  public tokens: TokenProvider[] = [];
-  public origin: any;
-
-  constructor(token: TokenProvider, origin?: any) {
-    super(isString(origin) ? origin : "");
-
-    this.tokens = [token];
-
-    if (origin) {
-      if (isString(origin)) {
-        this.origin = {
-          message: origin,
-          stack: this.stack
-        };
-      } else {
-        if (origin.tokens) {
-          this.tokens = this.tokens.concat(origin.tokens);
-          this.origin = origin.origin;
-        } else {
-          this.origin = origin;
-          this.stack = origin.stack;
-        }
-      }
-    }
-
-    const originMessage = this.origin ? "\nOrigin: " + this.origin.message : "";
-    const tokensMessage = this.tokens.map((token) => nameOf(token)).join(" > ");
-
-    this.message = `Injection failed on ${tokensMessage}${originMessage}`;
-  }
-
-  static throwInjectorError(token: any, currentDependency: any, error: any) {
-    if (currentDependency && isClass(token)) {
-      error.message = printDependencyInjectionError(token, {...currentDependency, message: error.message});
-    }
-
-    throw new InjectionError(token, error);
-  }
-}
-
-function printDependencyInjectionError(token: any, options: {token: any; index: number; deps: any[]; message: string}) {
-  let erroredArg = "";
-
-  const args = getConstructorArgNames(token)
-    .map((arg, index) => {
-      if (options.index === index) {
-        erroredArg = arg;
-        arg = colors.red(arg);
-      }
-
-      return `${arg}: ${nameOf(options.deps[index])}`;
-    })
-    .join(", ");
-
-  const signature = nameOf(token) + "->constructor(" + args + ")";
-  const indexOf = signature.indexOf(erroredArg) - 5;
-  const drawline = (indexOf: number) => " ".repeat(indexOf) + colors.red("^" + "‾".repeat(erroredArg.length - 1));
-
-  return "Unable to inject dependency. " + options.message + "\n\n" + signature + "\n" + (indexOf > -1 ? drawline(indexOf) : "");
-}

package/src/common/errors/InvalidPropertyTokenError.ts

@@ -1,14 +0,0 @@
-import {classOf} from "@tsed/core/utils/classOf.js";
-import {nameOf} from "@tsed/core/utils/nameOf.js";
-
-export class InvalidPropertyTokenError extends Error {
-  name = "INVALID_TOKEN_ERROR";
-
-  constructor(target: any, propertyKey: string) {
-    super(
-      `Object isn't a valid token. Please check the token set on ${nameOf(
-        classOf(target)
-      )}.${propertyKey}.\n- Check that it is not a circular reference.\n- Check that the token (class or symbol) exists`
-    );
-  }
-}

package/src/common/fn/configuration.spec.ts

@@ -1,42 +0,0 @@
-import {Store} from "@tsed/core";
-import {beforeEach} from "vitest";
-
-import {DITest} from "../../node/index.js";
-import {Configuration} from "../decorators/configuration.js";
-import {Injectable} from "../decorators/injectable.js";
-import {Provider} from "../domain/Provider.js";
-import {configuration} from "./configuration.js";
-import {inject} from "./inject.js";
-import {injector} from "./injector.js";
-
-@Injectable()
-class Test {
-  public config = configuration();
-}
-
-describe("configuration()", () => {
-  beforeEach(() =>
-    DITest.create({
-      feature: "feature"
-    })
-  );
-  afterEach(() => DITest.reset());
-
-  it("should inject configuration", async () => {
-    const instance = inject(Test);
-
-    expect(instance.config).toEqual(injector().settings);
-    expect(instance.config.get("feature")).toEqual("feature");
-  });
-
-  it("should declare a new provider with custom configuration", () => {
-    @Configuration({})
-    class Test {}
-
-    const provider = new Provider(Test);
-    provider.injectable = false;
-    provider.configuration = {};
-
-    expect(Store.from(Test).get("configuration")).toEqual({});
-  });
-});

package/src/common/fn/configuration.ts

@@ -1,22 +0,0 @@
-import {Store} from "@tsed/core/types/Store.js";
-
-import type {TokenProvider} from "../interfaces/TokenProvider.js";
-import {DIConfiguration} from "../services/DIConfiguration.js";
-import {injector} from "./injector.js";
-
-export function configuration(): TsED.DIConfiguration & DIConfiguration;
-export function configuration(token: TokenProvider): Partial<TsED.Configuration>;
-export function configuration(token: TokenProvider, configuration: Partial<TsED.Configuration>): Partial<TsED.Configuration>;
-export function configuration(token?: TokenProvider, configuration?: Partial<TsED.Configuration>) {
-  if (token) {
-    const store = Store.from(token);
-
-    if (configuration) {
-      store.set("configuration", configuration);
-    }
-
-    return store.get("configuration", configuration);
-  }
-
-  return injector().settings as TsED.DIConfiguration & DIConfiguration;
-}

package/src/common/fn/constant.spec.ts

@@ -1,37 +0,0 @@
-import {DITest} from "../../node/index.js";
-import {constant} from "../fn/constant.js";
-
-describe("constant()", () => {
-  beforeEach(() =>
-    DITest.create({
-      logger: {
-        level: "off"
-      }
-    })
-  );
-  afterEach(() => DITest.reset());
-  it("should inject constant to the property", async () => {
-    // WHEN
-    class Test {
-      test: string = constant("logger.level", "default value");
-    }
-
-    // THEN
-
-    const test = await DITest.invoke<Test>(Test);
-
-    expect(test.test).toEqual("off");
-  });
-  it("should return the default value if expression is undefined", async () => {
-    // WHEN
-    class Test {
-      test: string = constant("logger.test", "default value");
-    }
-
-    // THEN
-
-    const test = await DITest.invoke<Test>(Test);
-
-    expect(test.test).toEqual("default value");
-  });
-});

package/src/common/fn/constant.ts

@@ -1,7 +0,0 @@
-import {injector} from "./injector.js";
-
-export function constant<Type>(expression: string): Type | undefined;
-export function constant<Type>(expression: string, defaultValue: Type | undefined): Type;
-export function constant<Type>(expression: string, defaultValue?: Type | undefined): Type | undefined {
-  return injector().settings.get(expression, defaultValue);
-}