@tsed/di 8.11.0 → 8.11.2-rc.1

package/src/common/decorators/opts.ts

@@ -1,51 +0,0 @@
-import {classOf} from "@tsed/core/utils/classOf.js";
-
-import {DI_USE_PARAM_OPTIONS} from "../constants/constants.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {Inject} from "./inject.js";
-import {Scope} from "./scope.js";
-
-/**
- * Get instance options. This options depending on his invocation context.
- *
- * ```typescript
- * import {Injectable, Opts, UseOpts} from "@tsed/di";
- *
- * @Injectable()
- * class MyConfigurableService {
- *   source: string;
- *   constructor(@Opts options: any = {}) {
- *      console.log("Hello ", options.source); // log: Hello Service1 then Hello Service2
- *
- *      this.source = options.source;
- *   }
- * }
- *
- * @Injectable()
- * class MyService1 {
- *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service1
- *   }
- * }
- *
- * @Injectable()
- * class MyService2 {
- *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service2
- *   }
- * }
- * ```
- *
- * ::: warning
- * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.
- * :::
- *
- * @param target
- * @param propertyKey
- * @param index
- * @decorator
- */
-export function Opts(target: any, propertyKey: string | symbol | undefined, index: number) {
-  Scope(ProviderScope.INSTANCE)(classOf(target));
-  Inject(DI_USE_PARAM_OPTIONS)(target, propertyKey, index);
-}

package/src/common/decorators/overrideProvider.spec.ts

@@ -1,30 +0,0 @@
-import {Provider} from "../domain/Provider.js";
-import type {TokenProvider} from "../interfaces/TokenProvider.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-import {OverrideProvider} from "./overrideProvider.js";
-
-describe("OverrideProvider", () => {
-  class Test {}
-
-  class Test2 {}
-
-  beforeAll(() => {
-    vi.spyOn(GlobalProviders, "get");
-  });
-  it("should use OverrideProvider", () => {
-    // GIVEN
-    const provider = new Provider(Test);
-
-    vi.mocked(GlobalProviders.get).mockImplementation((token: TokenProvider) => {
-      if (token === Test) {
-        return provider;
-      }
-    });
-    // WHEN
-    OverrideProvider(Test)(Test2);
-
-    // THEN
-    expect(provider.token).toEqual(Test);
-    expect(provider.useClass).toEqual(Test2);
-  });
-});

package/src/common/decorators/overrideProvider.ts

@@ -1,15 +0,0 @@
-import {Type} from "@tsed/core/types/Type.js";
-
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-
-/**
- * Override a provider which is already registered in ProviderRegistry.
- * @returns {Function}
- * @decorators
- * @param originalProvider
- */
-export function OverrideProvider(originalProvider: Type<any>): Function {
-  return (target: Type<any>): void => {
-    GlobalProviders.get(originalProvider)!.useClass = target;
-  };
-}

package/src/common/decorators/scope.spec.ts

@@ -1,25 +0,0 @@
-import {Store} from "@tsed/core";
-
-import {Scope} from "./scope.js";
-
-class Test {}
-
-describe("Scope", () => {
-  describe("when parameters is given", () => {
-    it("should set metadata", () => {
-      Scope("request")(Test);
-
-      expect(Store.from(Test).get("scope")).toEqual("request");
-    });
-  });
-
-  describe("when parameters is not given", () => {
-    beforeAll(() => {});
-
-    it("should set metadata", () => {
-      Scope()(Test);
-
-      expect(Store.from(Test).get("scope")).toEqual("request");
-    });
-  });
-});

package/src/common/decorators/scope.ts

@@ -1,13 +0,0 @@
-import {StoreSet} from "@tsed/core/decorators/storeSet.js";
-
-import {ProviderScope} from "../domain/ProviderScope.js";
-
-/**
- *
- * @param {"request" | "singleton" | ProviderScope} scope
- * @returns {Function}
- * @constructor
- */
-export function Scope(scope: "request" | "singleton" | ProviderScope = ProviderScope.REQUEST) {
-  return StoreSet("scope", scope);
-}

package/src/common/decorators/service.ts

@@ -1,14 +0,0 @@
-import {Injectable} from "./injectable.js";
-
-/**
- * The decorators `@Service()` declare a new service can be injected in other service or controller on there `constructor`.
- * All services annotated with `@Service()` are constructed one time.
- *
- * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
- *
- * @returns {Function}
- * @decorator
- */
-export function Service(): Function {
-  return Injectable();
-}

package/src/common/decorators/useOpts.spec.ts

@@ -1,90 +0,0 @@
-import {descriptorOf} from "@tsed/core";
-
-import {DITest} from "../../node/index.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {Inject} from "./inject.js";
-import {Injectable} from "./injectable.js";
-import {Opts} from "./opts.js";
-import {Scope} from "./scope.js";
-import {UseOpts} from "./useOpts.js";
-
-describe("UseOpts", () => {
-  let testContext: any;
-
-  beforeEach(() => {
-    testContext = {};
-  });
-
-  beforeEach(() => DITest.create());
-  afterEach(() => DITest.reset());
-  it("should inject provider with options", async () => {
-    @Injectable()
-    class MyProvider {
-      source: any;
-
-      constructor(@Opts options: any = {}) {
-        testContext.source = options.source;
-        this.source = options.source;
-      }
-    }
-
-    @Injectable()
-    class MyService {
-      @Inject()
-      @UseOpts({
-        source: "test1"
-      })
-      service1: MyProvider;
-
-      constructor(@UseOpts({source: "test2"}) public service2: MyProvider) {}
-    }
-
-    const service = await DITest.invoke<MyService>(MyService);
-
-    expect(service.service2.source).toEqual("test2");
-    expect(service.service2).not.toEqual(service.service1);
-
-    expect(service.service1).toBeInstanceOf(MyProvider);
-    expect(service.service1.source).toEqual("test1");
-
-    expect(service.service2).toBeInstanceOf(MyProvider);
-  });
-  it("should invoke a service which use a configurable provider", async () => {
-    @Injectable()
-    class MyProvider {
-      source: any;
-
-      constructor(@Opts options: Partial<any> = {}) {
-        testContext.source = options.source;
-      }
-    }
-
-    @Injectable()
-    class MyService {
-      constructor(@UseOpts({source: "test2"}) public service2: MyProvider) {}
-    }
-
-    @Injectable()
-    @Scope(ProviderScope.SINGLETON)
-    class MyRepoService extends MyProvider {}
-
-    await DITest.invoke<MyRepoService>(MyRepoService);
-  });
-  it("should store metadata", () => {
-    // GIVEN
-    class Test {
-      test() {}
-    }
-
-    // WHEN
-    let actualError;
-    try {
-      UseOpts({})(Test, "test", descriptorOf(Test, "test"));
-    } catch (er) {
-      actualError = er;
-    }
-
-    // THEN
-    expect(actualError.message).toEqual("UseOpts cannot be used as method.static decorator on Test.test");
-  });
-});

package/src/common/decorators/useOpts.ts

@@ -1,64 +0,0 @@
-import {UnsupportedDecoratorType} from "@tsed/core/errors/UnsupportedDecoratorType.js";
-import {DecoratorTypes} from "@tsed/core/types/DecoratorTypes.js";
-import {Store} from "@tsed/core/types/Store.js";
-import {decoratorTypeOf} from "@tsed/core/utils/decoratorTypeOf.js";
-
-import {DI_USE_OPTIONS, DI_USE_PARAM_OPTIONS} from "../constants/constants.js";
-
-/**
- * Add options to invoke the Service.
- *
- * ```typescript
- * import {Injectable, Opts, UseOpts} from "@tsed/di";
- *
- * @Injectable()
- * class MyConfigurableService {
- *   source: string;
- *   constructor(@Opts options: any = {}) {
- *      console.log("Hello ", options.source); // log: Hello Service1 then Hello Service2
- *
- *      this.source = options.source;
- *   }
- * }
- *
- * @Injectable()
- * class MyService1 {
- *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service1
- *   }
- * }
- *
- * @Injectable()
- * class MyService2 {
- *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {
- *     console.log(service.source) // log: Service2
- *   }
- * }
- * ```
- *
- * ::: warning
- * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.
- * :::
- *
- * @returns {Function}
- * @decorator
- * @param options
- */
-export function UseOpts(options: {[key: string]: any}): Function {
-  return (target: Object, propertyKey: string | symbol, index?: number): any => {
-    const bindingType = decoratorTypeOf([target, propertyKey, index]);
-
-    switch (bindingType) {
-      case DecoratorTypes.PARAM_CTOR:
-        Store.from(target).merge(`${DI_USE_PARAM_OPTIONS}:${index}`, options);
-        break;
-
-      case DecoratorTypes.PROP:
-        Store.from(target, propertyKey).set(DI_USE_OPTIONS, options);
-        break;
-
-      default:
-        throw new UnsupportedDecoratorType(UseOpts, [target, propertyKey, index]);
-    }
-  };
-}

package/src/common/decorators/value.spec.ts

@@ -1,59 +0,0 @@
-import {DITest} from "../../node/index.js";
-import {configuration} from "../fn/configuration.js";
-import {Value} from "./value.js";
-
-describe("@Value()", () => {
-  beforeEach(() =>
-    DITest.create({
-      logger: {
-        level: "off"
-      }
-    })
-  );
-  afterEach(() => DITest.reset());
-  describe("when decorator is used as property decorator", () => {
-    it("should create a getter", async () => {
-      // WHEN
-      class Test {
-        @Value("logger.level", "default value")
-        test: string;
-      }
-
-      // THEN
-
-      const test = await DITest.invoke<Test>(Test);
-
-      expect(test.test).toEqual("off");
-    });
-    it("should create a getter with default value", async () => {
-      expect(configuration().get("logger.test")).toEqual(undefined);
-
-      // WHEN
-      class Test {
-        @Value("logger.test", "default value")
-        test: string;
-      }
-
-      // THEN
-
-      const test = await DITest.invoke<Test>(Test);
-
-      expect(test.test).toEqual("default value");
-      expect(configuration().get("logger.test")).toEqual(undefined);
-    });
-    it("should create a getter with native default value", async () => {
-      // WHEN
-      class Test {
-        @Value("logger.test")
-        test: string = "default prop";
-      }
-
-      // THEN
-
-      const test = await DITest.invoke<Test>(Test);
-
-      expect(test.test).toEqual("default prop");
-      expect(configuration().get("logger.test")).toEqual("default prop");
-    });
-  });
-});

package/src/common/decorators/value.ts

@@ -1,60 +0,0 @@
-import {catchError} from "@tsed/core/utils/catchError.js";
-
-import {injector} from "../fn/injector.js";
-
-export function bindValue(target: any, propertyKey: string | symbol, expression: string, defaultValue?: any) {
-  const descriptor = {
-    get() {
-      return injector().settings.get(expression, defaultValue);
-    },
-    set(value: unknown) {
-      injector().settings.set(expression, value);
-    },
-    enumerable: true,
-    configurable: true
-  };
-
-  catchError(() => Reflect.deleteProperty(target, propertyKey));
-  catchError(() => Reflect.defineProperty(target, propertyKey, descriptor));
-}
-
-/**
- * Return value from Configuration.
- *
- * ## Example
- *
- * ```typescript
- * import {Env} from "@tsed/core/domain/Env.js";
- * import {Constant, Value} from "@tsed/di";
- *
- * export class MyClass {
- *
- *    @Constant("env")
- *    env: Env;
- *
- *    @Value("swagger.path")
- *    swaggerPath: string;
- *
- *    @Value("swagger.path", "defaultValue")
- *    swaggerPath: string;
- *
- *    constructor() {
- *       console.log(this.swaggerPath) // undefined. Not available on constructor
- *    }
- *
- *    $onInit() {
- *      console.log(this.swaggerPath)  // something
- *    }
- * }
- * ```
- *
- * @param expression
- * @param defaultValue
- * @returns {(targetClass: any, attributeName: string) => any}
- * @decorator
- */
-export function Value(expression: string, defaultValue?: unknown): PropertyDecorator {
-  return (target, propertyKey) => {
-    return bindValue(target, propertyKey, expression, defaultValue);
-  };
-}

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

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

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

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