@tsed/di 8.0.1 → 8.0.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/di",
   "description": "DI module for Ts.ED Framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -10,6 +10,7 @@
   "browser": "./lib/browser/di.umd.min.js",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "browser": "./lib/browser/di.umd.min.js",
       "import": "./lib/esm/index.js",
@@ -29,12 +30,12 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/hooks": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/hooks": "8.0.3",
     "@tsed/logger": "^6.7.8",
-    "@tsed/schema": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/schema": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "cross-env": "7.0.3",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
@@ -42,10 +43,10 @@
     "webpack": "^5.75.0"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/hooks": "8.0.1",
+    "@tsed/core": "8.0.3",
+    "@tsed/hooks": "8.0.3",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/schema": "8.0.1"
+    "@tsed/schema": "8.0.3"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/readme.md

@@ -1,5 +1,5 @@
 <p style="text-align: center" align="center">
- <a href="https://tsed.io" target="_blank"><img src="https://tsed.io/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
 </p>
 
 <div align="center">
@@ -16,9 +16,9 @@
 </div>
 
 <div align="center">
-  <a href="https://tsed.io/">Website</a>
+  <a href="https://tsed.dev/">Website</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://tsed.io/getting-started/">Getting started</a>
+  <a href="https://tsed.dev/getting-started/">Getting started</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://api.tsed.io/rest/slack/tsedio/tsed">Slack</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
@@ -27,7 +27,7 @@
 
 <hr />
 
-A package of Ts.ED framework. See website: https://tsed.io/
+A package of Ts.ED framework. See website: https://tsed.dev/
 
 # Installation
 
@@ -150,11 +150,11 @@ To organize your code Ts.ED DI provide different kind of providers:
 - Interceptor can be declared with `@Interceptor`,
 - Factory and Value can be declared with `registerProvider` and `registerValue`.
 
-See more details on our documentation https://tsed.io/providers.html
+See more details on our documentation https://tsed.dev/providers.html
 
 ## Contributors
 
-Please read [contributing guidelines here](https://tsed.io/contributing.html)
+Please read [contributing guidelines here](https://tsed.dev/contributing.html)
 
 <a href="https://github.com/tsedio/tsed/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
 

package/src/common/constants/constants.ts

@@ -0,0 +1,5 @@
+export const DI_INVOKE_OPTIONS = Symbol("DI_INVOKE_OPTIONS");
+export const DI_INJECTABLE_PROPS = Symbol("DI_INJECTABLE_PROPS");
+export const DI_USE_OPTIONS = "DI_USE_OPTIONS";
+export const DI_USE_PARAM_OPTIONS = "DI_USE_PARAM_OPTIONS";
+export const DI_INTERCEPTOR_OPTIONS = "DI_INTERCEPTOR_OPTIONS";

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

@@ -0,0 +1,135 @@
+import {Logger} from "@tsed/logger";
+import {beforeEach} from "vitest";
+
+import {DITest} from "../../node/index.js";
+import {registerProvider} from "../registries/ProviderRegistry.js";
+import {InjectorService} from "../services/InjectorService.js";
+import {AutoInjectable} from "./autoInjectable.js";
+import {Inject} from "./inject.js";
+import {Injectable} from "./injectable.js";
+
+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"
+    });
+  }
+});
+
+describe("AutoInjectable", () => {
+  describe("when the instance is created during an injection context", () => {
+    beforeEach(() => DITest.create());
+    afterEach(() => DITest.reset());
+    it("should return a class that extends the original class", () => {
+      @AutoInjectable()
+      class Test {
+        @Inject(Logger)
+        logger: Logger;
+
+        foo() {
+          this.logger.info("test");
+        }
+      }
+
+      const test = new Test();
+      const test2 = new Test();
+
+      expect(test).toBeInstanceOf(Test);
+      expect(test2).toBeInstanceOf(Test);
+      expect(test).not.toBe(test2);
+
+      vi.spyOn(test.logger, "info").mockResolvedValue(undefined as never);
+
+      test.foo();
+
+      expect(test.logger.info).toHaveBeenCalledWith("test");
+    });
+    it("should return a class that extends the original class (with additional args)", () => {
+      @AutoInjectable()
+      class Test {
+        @Inject(Logger)
+        logger: Logger;
+
+        private value: string;
+
+        constructor(initialValue: string, @Inject(InjectorService) injector?: InjectorService) {
+          this.value = initialValue;
+          expect(injector).toBeInstanceOf(InjectorService);
+        }
+
+        foo() {
+          this.logger.info("test_" + this.value);
+        }
+      }
+
+      const test = new Test("test");
+
+      vi.spyOn(test.logger, "info").mockResolvedValue(undefined as never);
+
+      test.foo();
+
+      expect(test.logger.info).toHaveBeenCalledWith("test_test");
+    });
+    it("should return a class that extends the original class (with inject many)", () => {
+      @AutoInjectable()
+      class Test {
+        @Inject(Logger)
+        logger: Logger;
+        instances?: InterfaceGroup[];
+        private value: string;
+
+        constructor(initialValue: string, @Inject(TOKEN_GROUPS) instances?: InterfaceGroup[]) {
+          this.value = initialValue;
+          this.instances = instances;
+        }
+      }
+
+      expect(new Test("test").instances).toHaveLength(3);
+    });
+    it("should return a class that extends the original class (with 3 arguments)", () => {
+      @AutoInjectable()
+      class Test {
+        constructor(
+          public items: string[],
+          public group: string,
+          @Inject() logger?: Logger
+        ) {
+          expect(items).toEqual(["item1", "item2", "item3"]);
+          expect(group).toBe("group");
+          expect(logger).toBeInstanceOf(Logger);
+        }
+      }
+
+      new Test(["item1", "item2", "item3"], "group");
+    });
+  });
+});

package/src/common/decorators/autoInjectable.ts

@@ -0,0 +1,59 @@
+import {isArray, type Type} from "@tsed/core";
+
+import {LocalsContainer} from "../domain/LocalsContainer.js";
+import {injector} from "../fn/injector.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import {getConstructorDependencies} from "../utils/getConstructorDependencies.js";
+
+function resolveAutoInjectableArgs(token: Type, args: unknown[]) {
+  const inj = injector();
+  const locals = new LocalsContainer();
+  const deps: TokenProvider[] = getConstructorDependencies(token);
+  const list: any[] = [];
+  const length = Math.max(deps.length, args.length);
+
+  for (let i = 0; i < length; i++) {
+    if (args[i] !== undefined) {
+      list.push(args[i]);
+    } else {
+      const value = deps[i];
+      const instance = isArray(value) ? inj.getMany(value[0], {locals, parent: token}) : inj.invoke(value, {locals, parent: token});
+
+      list.push(instance);
+    }
+  }
+
+  return list;
+}
+
+/**
+ * AutoInjectable decorator is used to automatically inject dependencies in the constructor.
+ *
+ * @example
+ * ```typescript
+ * @AutoInjectable()
+ * class UserService {
+ *   constructor(
+ *     private database: Database,  // automatically injected
+ *     customConfig?: Config        // can be passed manually
+ *   ) {}
+ * }
+ * ```
+ *
+ * @description
+ * When applied to a class, this decorator:
+ * - Automatically resolves and injects dependencies based on constructor parameter types
+ * - Preserves the ability to manually pass arguments which override automatic injection
+ *
+ * @decorator
+ * @returns {ClassDecorator} A class decorator that enables automatic dependency injection
+ */
+export function AutoInjectable() {
+  return <T extends {new (...args: any[]): NonNullable<unknown>}>(constr: T): T => {
+    return class AutoInjectable extends constr {
+      constructor(...args: any[]) {
+        super(...resolveAutoInjectableArgs(constr, args));
+      }
+    } as unknown as T;
+  };
+}

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

@@ -0,0 +1,45 @@
+import {Store} from "@tsed/core";
+import {afterEach} from "vitest";
+
+import {Container} from "../domain/Container.js";
+import {Provider} from "../domain/Provider.js";
+import {destroyInjector, injector} from "../fn/injector.js";
+import {GlobalProviders} from "../registries/GlobalProviders.js";
+import {InjectorService} from "../services/InjectorService.js";
+import {Configuration} from "./configuration.js";
+import {Injectable} from "./injectable.js";
+
+describe("@Configuration", () => {
+  afterEach(() => destroyInjector());
+  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({});
+  });
+
+  it("should inject configuration", async () => {
+    @Configuration({
+      feature: "feature"
+    })
+    @Injectable()
+    class Test {
+      constructor(@Configuration() public config: Configuration) {}
+    }
+
+    const container = new Container();
+
+    injector().setProvider(Test, GlobalProviders.get(Test)!.clone());
+
+    await injector().load(container);
+
+    const instance = injector().invoke<Test>(Test);
+
+    expect(instance.config).toEqual(injector().settings);
+    expect(instance.config.get("feature")).toEqual("feature");
+  });
+});

package/src/common/decorators/configuration.ts

@@ -0,0 +1,34 @@
+import {DecoratorParameters, decoratorTypeOf, DecoratorTypes} from "@tsed/core";
+
+import {configuration} from "../fn/configuration.js";
+import {injectable} from "../fn/injectable.js";
+import {injector} from "../fn/injector.js";
+import {CONFIGURATION, 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

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

@@ -0,0 +1,72 @@
+import {catchError, deepClone} from "@tsed/core";
+
+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";
+ * 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

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

@@ -0,0 +1,64 @@
+import {isArrayOrArrayClass, Type, useDecorators} from "@tsed/core";
+import {Children, Path} from "@tsed/schema";
+
+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) => {
+      controller(target, opts);
+    },
+    path && Path(path as any),
+    Children(...children)
+  );
+}