@tsed/di 8.11.1 → 8.11.2-rc.1

package/src/common/decorators/configuration.ts

@@ -1,36 +0,0 @@
-import {DecoratorParameters} from "@tsed/core/types/DecoratorParameters.js";
-import {DecoratorTypes} from "@tsed/core/types/DecoratorTypes.js";
-import {decoratorTypeOf} from "@tsed/core/utils/decoratorTypeOf.js";
-
-import {configuration} from "../fn/configuration.js";
-import {injectable} from "../fn/injectable.js";
-import {injector} from "../fn/injector.js";
-import {DIConfiguration} from "../services/DIConfiguration.js";
-import {Inject} from "./inject.js";
-
-/**
- * Get or set Configuration on a class.
- *
- * @decorator
- */
-export function Configuration(): any;
-export function Configuration(settings: Partial<TsED.Configuration>): ClassDecorator;
-export function Configuration(settings: Partial<TsED.Configuration> = {}): Function {
-  return (...args: DecoratorParameters) => {
-    switch (decoratorTypeOf(args)) {
-      case DecoratorTypes.CLASS:
-        configuration(args[0], settings);
-
-        break;
-      default:
-      case DecoratorTypes.PARAM_CTOR:
-        return Inject(DIConfiguration)(args[0], args[1], args[2] as number);
-    }
-  };
-}
-
-export type Configuration = TsED.DIConfiguration & DIConfiguration;
-
-// To maintain compatibility with the previous implementation, we need to declare Configuration as
-// injectable token.
-injectable(Configuration).factory(() => injector().settings);

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

@@ -1,67 +0,0 @@
-import {DITest} from "../../node/index.js";
-import {Constant} from "./constant.js";
-
-describe("@Constant()", () => {
-  beforeEach(() =>
-    DITest.create({
-      logger: {
-        level: "off"
-      }
-    })
-  );
-  afterEach(() => DITest.reset());
-  it("should create a getter", async () => {
-    // WHEN
-    class Test {
-      @Constant("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 () => {
-    // WHEN
-    class Test {
-      @Constant("logger.test", "default value")
-      test: string;
-    }
-
-    // THEN
-
-    const test = await DITest.invoke<Test>(Test);
-
-    expect(test.test).toEqual("default value");
-  });
-  it("shouldn't be possible to modify injected value from injector.settings", async () => {
-    // WHEN
-    class Test {
-      @Constant("logger.level")
-      test: string;
-    }
-
-    // THEN
-
-    const test = await DITest.invoke<Test>(Test);
-
-    test.test = "new value";
-
-    expect(test.test).toEqual("off");
-  });
-  it("should create a getter with native default value", async () => {
-    // WHEN
-    class Test {
-      @Constant("logger.test")
-      test: string = "default prop";
-    }
-
-    // THEN
-
-    const test = await DITest.invoke<Test>(Test);
-
-    expect(test.test).toEqual("default prop");
-  });
-});

package/src/common/decorators/constant.ts

@@ -1,73 +0,0 @@
-import {catchError} from "@tsed/core/utils/catchError.js";
-import {deepClone} from "@tsed/core/utils/deepClone.js";
-
-import {constant} from "../fn/constant.js";
-
-export function bindConstant(target: any, propertyKey: string | symbol, expression: string, defaultValue?: any) {
-  const symbol = Symbol();
-
-  catchError(() => Reflect.deleteProperty(target, propertyKey));
-  Reflect.defineProperty(target, propertyKey, {
-    get() {
-      if (this[symbol] !== undefined) {
-        return this[symbol];
-      }
-
-      const value = constant(expression, defaultValue);
-
-      this[symbol] = Object.freeze(deepClone(value));
-
-      return this[symbol];
-    },
-    set(value: unknown) {
-      const bean = constant(expression, defaultValue) || this[symbol];
-
-      if (bean === undefined && value !== undefined) {
-        this[symbol] = value;
-      }
-    },
-    enumerable: true,
-    configurable: true
-  });
-}
-
-/**
- * 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 {string} expression
- * @param defaultValue
- * @returns {(targetClass: any, attributeName: string) => any}
- * @decorator
- */
-export function Constant<Type = unknown>(expression: string, defaultValue?: Type): PropertyDecorator {
-  return (target, propertyKey) => {
-    return bindConstant(target, propertyKey, expression, defaultValue);
-  };
-}

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

@@ -1,43 +0,0 @@
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {ProviderType} from "../domain/ProviderType.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-import {Controller} from "./controller.js";
-
-class Test {}
-
-class Dep {}
-
-describe("@Controller", () => {
-  afterAll(() => {
-    GlobalProviders.delete(Test);
-  });
-  it("should register a controller with his path and Dependency", () => {
-    // WHEN
-    Controller("/test")(Test);
-
-    // THEN
-    const provider = GlobalProviders.get(Test)!;
-
-    // THEN
-    expect(provider.type).toEqual(ProviderType.CONTROLLER);
-    expect(provider.path).toEqual("/test");
-  });
-
-  it("should register a controller with customer provider options", () => {
-    // WHEN
-    Controller({
-      path: "/test",
-      children: [Dep],
-      scope: ProviderScope.REQUEST
-    })(Test);
-
-    // THEN
-    const provider = GlobalProviders.get(Test)!;
-
-    // THEN
-    expect(provider.type).toEqual(ProviderType.CONTROLLER);
-    expect(provider.scope).toEqual(ProviderScope.REQUEST);
-    expect(provider.path).toEqual("/test");
-    expect(provider.children).toEqual([Dep]);
-  });
-});

package/src/common/decorators/controller.ts

@@ -1,73 +0,0 @@
-import {Store} from "@tsed/core/types/Store.js";
-import {Type} from "@tsed/core/types/Type.js";
-import {classOf} from "@tsed/core/utils/classOf.js";
-import {isArrayOrArrayClass} from "@tsed/core/utils/isArray.js";
-import {useDecorators} from "@tsed/core/utils/useDecorators.js";
-
-import type {ControllerMiddlewares} from "../domain/ControllerProvider.js";
-import {controller} from "../fn/injectable.js";
-import {ProviderOpts} from "../interfaces/ProviderOpts.js";
-
-export type PathType = string | RegExp | (string | RegExp)[];
-
-export interface ControllerOptions extends Partial<ProviderOpts<any>> {
-  path?: PathType;
-  children?: Type<any>[];
-  middlewares?: Partial<ControllerMiddlewares>;
-}
-
-function mapOptions(options: any): ControllerOptions {
-  if (typeof options === "string" || options instanceof RegExp || isArrayOrArrayClass(options)) {
-    return {
-      path: options
-    };
-  }
-
-  return options;
-}
-
-/**
- * Declare a new controller with his Rest path. His methods annotated will be collected to build the routing list.
- * This routing listing will be built with the `express.Router` object.
- *
- * ::: tip
- * See [Controllers](/docs/controllers.md) section for more details
- * :::
- *
- * ```typescript
- *  @Controller("/calendars")
- *  export class CalendarCtrl {
- *
- *    @Get("/:id")
- *    public get(
- *      @Req() request: Req,
- *      @Res() response: Res,
- *      @Next() next: Next
- *    ): void {
- *
- *    }
- *  }
- * ```
- *
- * @param options
- * @controller
- * @decorator
- * @classDecorator
- */
-export function Controller(options: PathType | ControllerOptions): ClassDecorator {
-  const {children = [], path, ...opts} = mapOptions(options);
-
-  return useDecorators((target: Type) => {
-    const factory = controller(target, opts);
-
-    if (path) {
-      factory.store().set("path", path);
-    }
-
-    factory.store().set("childrenControllers", children);
-
-    children.forEach((childToken) => {
-      Store.from(childToken).set("parentController", classOf(target));
-    });
-  });
-}

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

@@ -1,298 +0,0 @@
-import {catchAsyncError} from "@tsed/core";
-
-import {DITest} from "../../node/index.js";
-import {inject} from "../fn/inject.js";
-import {injector} from "../fn/injector.js";
-import {registerProvider} from "../registries/ProviderRegistry.js";
-import {InjectorService} from "../services/InjectorService.js";
-import {Inject} from "./inject.js";
-import {Injectable} from "./injectable.js";
-
-@Injectable()
-class ProvidersList extends Map<string, string> {}
-
-@Injectable()
-class MyService {
-  @Inject(ProvidersList)
-  providersList: ProvidersList;
-
-  getValue() {
-    return this.providersList.get("key");
-  }
-}
-
-describe("@Inject()", () => {
-  beforeEach(() => DITest.create());
-  afterEach(() => DITest.reset());
-
-  describe("when the decorator used on property", () => {
-    it("should inject service", async () => {
-      // GIVEN
-      @Injectable()
-      class Test {
-        @Inject()
-        test: InjectorService;
-      }
-
-      const instance = inject<Test>(Test);
-
-      expect(instance).toBeInstanceOf(Test);
-      expect(instance.test).toBeInstanceOf(InjectorService);
-    });
-    it("should inject service and async factory", async () => {
-      // GIVEN
-      class Test {
-        constructor(public type: string) {}
-      }
-
-      const TokenAsync = Symbol.for("MyService");
-
-      registerProvider<Test>({
-        token: TokenAsync,
-        type: "test:async",
-        deps: [],
-        useAsyncFactory() {
-          return Promise.resolve(new Test("async"));
-        }
-      });
-
-      @Injectable()
-      class Parent1 {
-        @Inject(TokenAsync)
-        test: Test;
-      }
-
-      @Injectable()
-      class Parent2 {
-        @Inject(TokenAsync)
-        test: Test;
-      }
-
-      await injector().load();
-
-      const parent1 = inject<Parent1>(Parent1);
-      const parent2 = inject<Parent2>(Parent2);
-
-      expect(parent1.test).toBeInstanceOf(Test);
-      expect(parent2.test).toBeInstanceOf(Test);
-    });
-    it("should inject service and use onGet option to transform injected service", async () => {
-      // GIVEN
-      @Injectable()
-      class Test {
-        @Inject(InjectorService, {transform: (instance) => instance.get(InjectorService)})
-        test: InjectorService;
-      }
-
-      const instance = inject(Test);
-
-      expect(instance).toBeInstanceOf(Test);
-      expect(instance.test).toBeInstanceOf(InjectorService);
-    });
-    it("should inject service and use onGet option to transform injected service (legacy)", async () => {
-      // GIVEN
-      @Injectable()
-      class Test {
-        @Inject(InjectorService, (instance) => instance.get(InjectorService))
-        test: InjectorService;
-      }
-
-      const instance = inject<Test>(Test);
-
-      expect(instance).toBeInstanceOf(Test);
-      expect(instance.test).toBeInstanceOf(InjectorService);
-    });
-    it("should inject many services", async () => {
-      const TOKEN_GROUPS = Symbol.for("groups:1");
-
-      interface InterfaceGroup {
-        type: string;
-      }
-
-      @Injectable({
-        type: TOKEN_GROUPS
-      })
-      class MyService1 implements InterfaceGroup {
-        readonly type: string = "service1";
-
-        constructor(@Inject(InjectorService) readonly injector: any) {}
-      }
-
-      @Injectable({
-        type: TOKEN_GROUPS
-      })
-      class MyService2 implements InterfaceGroup {
-        readonly type: string = "service2";
-
-        constructor(@Inject(InjectorService) readonly injector: any) {}
-      }
-
-      const TokenAsync = Symbol.for("MyService2");
-
-      registerProvider({
-        token: TokenAsync,
-        type: TOKEN_GROUPS,
-        deps: [],
-        useAsyncFactory() {
-          return Promise.resolve({
-            type: "async"
-          });
-        }
-      });
-
-      @Injectable()
-      class MyInjectable {
-        @Inject(TOKEN_GROUPS)
-        instances: InterfaceGroup[];
-      }
-
-      await injector().load();
-
-      const instance = inject<MyInjectable>(MyInjectable);
-
-      expect(instance.instances).toBeInstanceOf(Array);
-      expect(instance.instances).toHaveLength(3);
-      expect(instance.instances[0].type).toEqual("service1");
-      expect(instance.instances[1].type).toEqual("service2");
-      expect(instance.instances[2].type).toEqual("async");
-    });
-    it("should throw error", () => {
-      try {
-        // GIVEN
-        @Injectable()
-        class Test {
-          @Inject()
-          test: Object;
-        }
-      } catch (er) {
-        expect(er.message).toContain("Object isn't a valid token. Please check the token set on Test.test");
-      }
-    });
-    it("should inject service and use mock", async () => {
-      @Injectable()
-      class Nested {
-        get cache() {
-          return true;
-        }
-      }
-
-      @Injectable()
-      class Test {
-        @Inject()
-        nested: Nested;
-      }
-
-      const instance = await DITest.invoke(Test, [
-        {
-          token: Nested,
-          use: {
-            cache: false
-          }
-        }
-      ]);
-
-      expect(instance.nested.cache).toEqual(false);
-
-      const instance2 = await DITest.invoke(Test, []);
-      expect(instance2.nested.cache).toEqual(true);
-    });
-  });
-  describe("when the decorator is used on constructor parameter", () => {
-    describe("when token is given on constructor", () => {
-      it("should inject the expected provider", async () => {
-        @Injectable()
-        class MyInjectable {
-          constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
-        }
-
-        const instance = inject(MyInjectable);
-
-        expect(instance.injector).toBeInstanceOf(InjectorService);
-      });
-    });
-
-    describe("when a group token is given on constructor", () => {
-      it("should inject the expected provider", async () => {
-        const TOKEN_GROUPS = Symbol.for("groups:2");
-
-        interface InterfaceGroup {
-          type: string;
-        }
-
-        @Injectable({
-          type: TOKEN_GROUPS
-        })
-        class MyService1 implements InterfaceGroup {
-          readonly type: string = "service1";
-
-          constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
-        }
-
-        @Injectable({
-          type: TOKEN_GROUPS
-        })
-        class MyService2 implements InterfaceGroup {
-          readonly type: string = "service2";
-
-          constructor(@Inject(InjectorService) readonly injector: InjectorService) {}
-        }
-
-        const TokenAsync = Symbol.for("MyService1");
-
-        registerProvider({
-          token: TokenAsync,
-          type: TOKEN_GROUPS,
-          deps: [],
-          useAsyncFactory() {
-            return Promise.resolve({
-              type: "async"
-            });
-          }
-        });
-
-        @Injectable()
-        class MyInjectable {
-          constructor(@Inject(TOKEN_GROUPS) readonly instances: InterfaceGroup[]) {}
-        }
-
-        await injector().load();
-
-        const instance = inject(MyInjectable);
-
-        expect(instance.instances).toBeInstanceOf(Array);
-        expect(instance.instances).toHaveLength(3);
-        expect(instance.instances[0].type).toEqual("service1");
-        expect(instance.instances[1].type).toEqual("service2");
-        expect(instance.instances[2].type).toEqual("async");
-      });
-    });
-  });
-  describe("when token is Object", () => {
-    it("should throw error", async () => {
-      class Test {
-        @Inject()
-        test: any;
-      }
-
-      const error = await catchAsyncError(async () => {
-        const instance = await DITest.invoke(Test);
-
-        return instance.test;
-      });
-
-      expect(error?.message).toContain("Object isn't a valid token. Please check the token set on Test.test");
-    });
-  });
-  it("should rebuild all dependencies using invoke", async () => {
-    const providersList = inject(ProvidersList);
-    const myService = inject(MyService);
-    providersList.set("key", "value");
-
-    expect(inject(ProvidersList).get("key")).toEqual("value");
-    expect(myService.getValue()).toEqual("value");
-
-    const newMyService = await DITest.invoke(MyService, []);
-    expect(newMyService.getValue()).toEqual(undefined);
-    expect(myService.getValue()).toEqual("value");
-  });
-});