@tsed/di 8.0.1 → 8.0.2

package/src/common/interfaces/InvokeOptions.ts

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

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

package/src/common/interfaces/OnInit.ts

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

package/src/common/interfaces/ProviderOpts.ts

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

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

package/src/common/interfaces/ResolvedInvokeOptions.ts

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

@@ -0,0 +1,3 @@
+import type {AbstractType, Type} from "@tsed/core";
+
+export type TokenProvider<T = any> = string | symbol | Type<T> | AbstractType<T> | Function;

package/src/common/interfaces/TokenRoute.ts

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

package/src/common/registries/GlobalProviders.spec.ts

@@ -0,0 +1,94 @@
+import {LocalsContainer} from "../domain/LocalsContainer.js";
+import {Provider} from "../domain/Provider.js";
+import {ProviderType} from "../domain/ProviderType.js";
+import {InjectorService} from "../services/InjectorService.js";
+import {GlobalProviderRegistry, GlobalProviders} from "./GlobalProviders.js";
+import {registerProvider} from "./ProviderRegistry.js";
+
+describe("GlobalProviderRegistry", () => {
+  describe("createRegistry()", () => {
+    it("should create registry", () => {
+      // GIVEN
+      const providers = new GlobalProviderRegistry();
+
+      // WHEN
+      providers.createRegistry("test", Provider, {});
+
+      // THEN
+      expect(providers.getRegistrySettings("test")).toEqual({
+        model: Provider
+      });
+    });
+  });
+  describe("getRegistrySettings()", () => {
+    it("should get registry from provider type (CONTROLLER)", () => {
+      // GIVEN
+      const providers = new GlobalProviderRegistry();
+      providers.createRegistry(ProviderType.CONTROLLER, Provider, {});
+
+      const provider = new Provider(Symbol.for("token"));
+      provider.type = ProviderType.CONTROLLER;
+
+      providers.set(Symbol.for("token"), provider);
+
+      // WHEN
+      const settings = providers.getRegistrySettings(Symbol.for("token"));
+
+      // THEN
+      expect(settings).toEqual({
+        model: Provider
+      });
+    });
+    it("should get registry from provider type (PROVIDER)", () => {
+      // GIVEN
+      const providers = new GlobalProviderRegistry();
+      const provider = new Provider("token");
+      provider.type = ProviderType.PROVIDER;
+      // WHEN
+      const settings = providers.getRegistrySettings(provider as never);
+
+      // THEN
+      expect(settings).toEqual({
+        model: Provider
+      });
+    });
+  });
+  describe("merge()", () => {
+    it("should create new metadata", () => {
+      const registry = new GlobalProviderRegistry();
+      const clazz = class {};
+
+      registry.merge(clazz, {attr1: 1});
+      expect(registry.get(clazz)?.attr1).toEqual(1);
+    });
+
+    it("should merge metadata", () => {
+      const registry = new GlobalProviderRegistry();
+      const clazz = class {};
+      registry.merge(clazz, {attr1: 1});
+      registry.merge(clazz, {attr2: 2});
+
+      expect(registry.get(clazz)?.attr1).toEqual(1);
+      expect(registry.get(clazz)?.attr2).toEqual(2);
+
+      registry.delete(clazz);
+
+      expect(registry.get(clazz)).toBeUndefined();
+    });
+  });
+  describe("hooks", () => {
+    it("should collect hooks", () => {
+      class MyService {
+        $onInit() {}
+
+        $onReady() {}
+      }
+
+      const provider = registerProvider({
+        token: MyService
+      });
+
+      expect(Object.keys(provider.hooks || {})).toEqual(["$onInit", "$onReady"]);
+    });
+  });
+});

package/src/common/registries/GlobalProviders.ts

@@ -0,0 +1,131 @@
+import {getClassOrSymbol, Type} from "@tsed/core";
+
+import {Provider} from "../domain/Provider.js";
+import {ProviderType} from "../domain/ProviderType.js";
+import {ProviderOpts} from "../interfaces/ProviderOpts.js";
+import {RegistrySettings} from "../interfaces/RegistrySettings.js";
+import {TokenProvider} from "../interfaces/TokenProvider.js";
+
+export class GlobalProviderRegistry extends Map<TokenProvider, Provider> {
+  #settings: Map<TokenProvider, RegistrySettings> = new Map();
+
+  /**
+   * The get() method returns a specified element from a Map object.
+   * @param key Required. The key of the element to return from the 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.
+   */
+  get(key: TokenProvider): Provider | undefined {
+    return super.get(getClassOrSymbol(key));
+  }
+
+  /**
+   * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+   * @param key
+   * @returns {boolean}
+   */
+  has(key: TokenProvider): boolean {
+    return super.has(getClassOrSymbol(key));
+  }
+
+  /**
+   * The set() method adds or updates an element with a specified key and value to a Map object.
+   * @param key Required. The key of the element to add to the Map object.
+   * @param metadata Required. The value of the element to add to the Map object.
+   */
+  set(key: TokenProvider, metadata: Provider): this {
+    super.set(getClassOrSymbol(key), metadata);
+
+    return this;
+  }
+
+  /**
+   *
+   * @param target
+   * @param options
+   */
+  merge(target: TokenProvider, options: Partial<ProviderOpts>) {
+    if (options.global === false) {
+      return GlobalProviders.createProvider(target, options);
+    }
+
+    const meta = this.createIfNotExists(target, options);
+
+    Object.keys(options).forEach((key) => {
+      meta[key] = (options as never)[key];
+    });
+
+    this.set(target, meta);
+
+    return meta;
+  }
+
+  /**
+   * The delete() method removes the specified element from a Map object.
+   * @param key Required. The key of the element to remove from the Map object.
+   * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
+   */
+  delete(key: TokenProvider): boolean {
+    return super.delete(getClassOrSymbol(key));
+  }
+
+  createRegistry(type: string | symbol, model: Type<Provider>, options: Partial<RegistrySettings> = {}) {
+    const defaultOptions = this.getRegistrySettings(type);
+
+    options = Object.assign(defaultOptions, {
+      ...options,
+      model
+    });
+
+    this.#settings.set(type, options);
+
+    return this;
+  }
+
+  getRegistrySettings(target: TokenProvider): RegistrySettings {
+    let type: TokenProvider | ProviderType = ProviderType.PROVIDER;
+
+    if (typeof target === "string") {
+      type = target;
+    } else {
+      const provider = this.get(target);
+      if (provider) {
+        type = provider.type;
+      }
+    }
+
+    return (
+      this.#settings.get(type) || {
+        model: Provider
+      }
+    );
+  }
+
+  protected createProvider(key: TokenProvider, options: Partial<ProviderOpts<any>>) {
+    const type = options.type || ProviderType.PROVIDER;
+    const {model = Provider} = this.#settings.get(type) || {};
+
+    return new model(key, options);
+  }
+
+  /**
+   *
+   * @param key
+   * @param options
+   */
+  protected createIfNotExists(key: TokenProvider, options: Partial<ProviderOpts>): Provider {
+    if (!this.has(key)) {
+      const item = this.createProvider(key, options);
+
+      this.set(key, item);
+    }
+
+    return this.get(key)!;
+  }
+}
+
+/**
+ *
+ * @type {GlobalProviders}
+ */
+// tslint:disable-next-line: variable-name
+export const GlobalProviders = new GlobalProviderRegistry();

package/src/common/registries/ProviderRegistry.spec.ts

@@ -0,0 +1,36 @@
+import {GlobalProviders} from "./GlobalProviders.js";
+import {registerProvider} from "./ProviderRegistry.js";
+
+describe("ProviderRegistry", () => {
+  describe("registerProvider()", () => {
+    beforeEach(() => {
+      vi.spyOn(GlobalProviders, "merge");
+      vi.spyOn(GlobalProviders, "has").mockReturnValue(false);
+    });
+    afterEach(() => {
+      vi.resetAllMocks();
+    });
+
+    it("should add provider (token)", () => {
+      class Test {}
+
+      registerProvider({token: Test});
+
+      expect(GlobalProviders.merge).toHaveBeenCalledWith(Test, {
+        token: Test,
+        global: true
+      });
+    });
+
+    it("should add provider (provide)", () => {
+      class Test {}
+
+      registerProvider({provide: Test});
+
+      expect(GlobalProviders.merge).toHaveBeenCalledWith(Test, {
+        token: Test,
+        global: true
+      });
+    });
+  });
+});

package/src/common/registries/ProviderRegistry.ts

@@ -0,0 +1,32 @@
+import {ControllerProvider} from "../domain/ControllerProvider.js";
+import {ProviderType} from "../domain/ProviderType.js";
+import {injectable} from "../fn/injectable.js";
+import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import {GlobalProviders} from "./GlobalProviders.js";
+
+GlobalProviders.createRegistry(ProviderType.CONTROLLER, ControllerProvider);
+
+type Opts<Type = any> = Partial<ProviderOpts<Type>> &
+  (
+    | {
+        token: TokenProvider<Type>;
+      }
+    | {
+        /**
+         * @deprecated use token prop instead
+         */
+        provide: TokenProvider<Type>;
+      }
+  );
+
+/**
+ * Register a provider configuration.
+ * @deprecated Since v8. Use injectable() function instead.
+ */
+export function registerProvider<Type = any>({token, provide, ...opts}: Opts<Type>) {
+  return injectable(token || provide, {
+    ...opts,
+    token: token || provide
+  } as unknown as Partial<ProviderOpts>).inspect();
+}

package/src/common/services/DIConfiguration.spec.ts

@@ -0,0 +1,60 @@
+import {Env} from "@tsed/core";
+
+import {DIConfiguration} from "./DIConfiguration.js";
+
+describe("DIConfiguration", () => {
+  describe("version()", () => {
+    it("should get version", () => {
+      // GIVEN
+      const configuration = new DIConfiguration();
+
+      configuration.version = "1.0.0";
+      expect(configuration.version).toEqual("1.0.0");
+    });
+  });
+  describe("env()", () => {
+    it("should get env", () => {
+      // GIVEN
+      const configuration = new DIConfiguration();
+
+      configuration.env = Env.DEV;
+      expect(configuration.env).toEqual(Env.DEV);
+    });
+  });
+  describe("debug()", () => {
+    it("should return debug", () => {
+      // GIVEN
+      const configuration = new DIConfiguration();
+
+      configuration.debug = true;
+      expect(configuration.debug).toEqual(true);
+
+      configuration.debug = false;
+      expect(configuration.debug).toEqual(false);
+    });
+  });
+  describe("forEach()", () => {
+    it("should return all key, value", () => {
+      // GIVEN
+      const configuration = new DIConfiguration();
+      const obj: any = {};
+      configuration.forEach((value, key) => {
+        obj[key] = value;
+      });
+      expect(obj).toEqual({
+        imports: [],
+        logger: {},
+        routes: []
+      });
+    });
+  });
+  describe("imports()", () => {
+    it("should get imports", () => {
+      // GIVEN
+      const configuration = new DIConfiguration();
+
+      configuration.imports = [];
+      expect(configuration.imports).toEqual([]);
+    });
+  });
+});

package/src/common/services/DIConfiguration.ts

@@ -0,0 +1,140 @@
+import {Env, getValue, setValue} from "@tsed/core";
+
+import type {DILoggerOptions} from "../interfaces/DILoggerOptions.js";
+import type {ImportTokenProviderOpts} from "../interfaces/ImportTokenProviderOpts.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import type {TokenRoute} from "../interfaces/TokenRoute.js";
+
+export const CONFIGURATION = Symbol.for("CONFIGURATION");
+
+export class DIConfiguration {
+  readonly default: Map<string, any> = new Map();
+  protected map: Map<string, any> = new Map();
+
+  constructor(initialProps = {}) {
+    Object.entries({
+      imports: [],
+      routes: [],
+      logger: {},
+      ...initialProps
+    }).forEach(([key, value]) => {
+      this.default.set(key, value);
+    });
+  }
+
+  get version() {
+    return this.get("version")!;
+  }
+
+  set version(v: string) {
+    this.map.set("version", v);
+  }
+
+  get rootDir() {
+    return this.get("rootDir")!;
+  }
+
+  set rootDir(value: string) {
+    this.map.set("rootDir", value);
+  }
+
+  get env(): Env {
+    return this.map.get("env");
+  }
+
+  set env(value: Env) {
+    this.map.set("env", value);
+  }
+
+  get imports(): (TokenProvider | ImportTokenProviderOpts)[] {
+    return this.get("imports")!;
+  }
+
+  set imports(imports: (TokenProvider | ImportTokenProviderOpts)[]) {
+    this.map.set("imports", imports);
+  }
+
+  get routes(): TokenRoute[] {
+    return this.get("routes")!;
+  }
+
+  set routes(routes: TokenRoute[]) {
+    this.map.set("routes", routes);
+  }
+
+  get logger(): Partial<DILoggerOptions> {
+    return this.get("logger")!;
+  }
+
+  set logger(value: Partial<DILoggerOptions>) {
+    const logger = {...this.logger, ...value};
+    this.map.set("logger", logger);
+  }
+
+  get debug(): boolean {
+    return this.logger.level === "debug";
+  }
+
+  set debug(debug: boolean) {
+    this.logger = {...this.logger, level: debug ? "debug" : "info"};
+  }
+
+  /**
+   *
+   * @param callbackfn
+   * @param thisArg
+   */
+  forEach(callbackfn: (value: any, index: string, map: Map<string, any>) => void, thisArg?: any) {
+    return new Set([...Array.from(this.default.keys()), ...Array.from(this.map.keys())]).forEach((key) => {
+      callbackfn(this.getRaw(key), key, this.map);
+    }, thisArg);
+  }
+
+  /**
+   *
+   * @param propertyKey
+   * @param value
+   */
+  set(propertyKey: string | Partial<TsED.Configuration>, value?: any): this {
+    if (typeof propertyKey === "string") {
+      if (Reflect.has(this, propertyKey)) {
+        // @ts-ignore
+        this[propertyKey] = value;
+      } else {
+        this.setRaw(propertyKey, value);
+      }
+    } else {
+      Object.entries(propertyKey).forEach(([key, value]) => {
+        this.set(key, value);
+      });
+    }
+
+    return this;
+  }
+
+  setRaw(propertyKey: string, value: any) {
+    setValue(this.map, propertyKey, value);
+
+    return this;
+  }
+
+  /**
+   *
+   * @param propertyKey
+   * @param defaultValue
+   * @returns {undefined|any}
+   */
+  get<T = any>(propertyKey: string, defaultValue?: T): T {
+    return this.getRaw(propertyKey, defaultValue);
+  }
+
+  protected getRaw(propertyKey: string, defaultValue?: any): any {
+    const value = getValue(this.map, propertyKey);
+
+    if (value !== undefined) {
+      return value;
+    }
+
+    return getValue(this.default, propertyKey, defaultValue);
+  }
+}

package/src/common/services/DILogger.spec.ts

@@ -0,0 +1,22 @@
+import {Container, destroyInjector, Inject, Injectable, injector, LOGGER} from "../../common/index.js";
+
+describe("DILogger", () => {
+  afterEach(() => destroyInjector());
+  it("should inject logger in another service", async () => {
+    @Injectable()
+    class MyService {
+      @Inject(LOGGER)
+      logger: LOGGER;
+    }
+
+    injector().logger = console;
+
+    const container = new Container();
+    container.add(MyService);
+
+    await injector().load(container);
+    const logger = injector().get(MyService)!.logger;
+
+    expect(logger).toEqual(injector().logger);
+  });
+});

package/src/common/services/DILogger.ts

@@ -0,0 +1,8 @@
+import {injectable} from "../fn/injectable.js";
+import {injector} from "../fn/injector.js";
+import {DILogger} from "../interfaces/DILogger.js";
+
+export const LOGGER = Symbol.for("LOGGER");
+export type LOGGER = DILogger;
+
+injectable(LOGGER).factory(() => injector().logger);