@tsed/di 8.11.1 → 8.11.2-rc.1

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

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

@@ -1,132 +0,0 @@
-import {Type} from "@tsed/core/types/Type.js";
-import {getClassOrSymbol} from "@tsed/core/utils/getClassOrSymbol.js";
-
-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

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

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

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

@@ -1,142 +0,0 @@
-import {Env} from "@tsed/core/types/Env.js";
-import {getValue} from "@tsed/core/utils/getValue.js";
-import {setValue} from "@tsed/core/utils/setValue.js";
-
-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

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

@@ -1,8 +0,0 @@
-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);