@tsed/di 8.8.2 → 8.8.4

package/lib/types/common/utils/providerBuilder.d.ts

@@ -1,17 +1,19 @@
 import "../registries/ProviderRegistry.js";
 import { Store, type Type } from "@tsed/core";
 import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
-import type { TokenProvider } from "../interfaces/TokenProvider.js";
-type ProviderBuilder<Token extends TokenProvider, BaseProvider, T extends object> = {
-    [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<Token, BaseProvider, T>;
-} & {
+import type { FactoryTokenProvider, TokenProvider } from "../interfaces/TokenProvider.js";
+type BaseMethodsProvider<TypeOf, BaseProvider, T extends object> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<TypeOf, BaseProvider, T>;
+};
+type ProviderBuilder<TypeOf, BaseProvider, T extends object> = BaseMethodsProvider<TypeOf, BaseProvider, T> & {
     inspect(): BaseProvider;
     store(): Store;
-    token(): Token;
-    factory(f: (...args: unknown[]) => unknown): ProviderBuilder<Token, BaseProvider, T>;
-    asyncFactory(f: (...args: unknown[]) => Promise<unknown>): ProviderBuilder<Token, BaseProvider, T>;
-    value(v: unknown): ProviderBuilder<Token, BaseProvider, T>;
-    class(c: Type): ProviderBuilder<Token, BaseProvider, T>;
+    token(): TypeOf;
+    factory<FactoryReturn>(f: (...args: unknown[]) => FactoryReturn): ProviderBuilder<FactoryTokenProvider<FactoryReturn>, BaseProvider, T>;
+    asyncFactory<FactoryReturn>(f: (...args: unknown[]) => Promise<FactoryReturn>): ProviderBuilder<FactoryTokenProvider<FactoryReturn>, BaseProvider, T>;
+    value<Value>(v: Value): ProviderBuilder<FactoryTokenProvider<Value>, BaseProvider, T>;
+    class<TokenKlass>(c: Type<TokenKlass>): ProviderBuilder<TokenKlass, BaseProvider, T>;
 };
-export declare function providerBuilder<Provider, Picked extends keyof Provider>(props: string[], baseOpts?: Partial<ProviderOpts<Provider>>): <Token extends TokenProvider>(token: Token, options?: Partial<ProviderOpts<Type>>) => ProviderBuilder<Token, Provider, Pick<Provider, Picked>>;
+export type ProviderBuilderFn<Provider, Picked extends keyof Provider> = <TypeOf extends TokenProvider>(token: TypeOf, options?: Partial<ProviderOpts<Type>>) => ProviderBuilder<TypeOf, Provider, Pick<Provider, Picked>>;
+export declare function providerBuilder<Provider, Picked extends keyof Provider>(props: string[], baseOpts?: Partial<ProviderOpts<Provider>>): ProviderBuilderFn<Provider, Picked>;
 export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/di",
   "description": "DI module for Ts.ED Framework",
   "type": "module",
-  "version": "8.8.2",
+  "version": "8.8.4",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -30,12 +30,12 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.8.2",
-    "@tsed/core": "8.8.2",
-    "@tsed/hooks": "8.8.2",
+    "@tsed/barrels": "8.8.4",
+    "@tsed/core": "8.8.4",
+    "@tsed/hooks": "8.8.4",
     "@tsed/logger": "^7.0.1",
-    "@tsed/schema": "8.8.2",
-    "@tsed/typescript": "8.8.2",
+    "@tsed/schema": "8.8.4",
+    "@tsed/typescript": "8.8.4",
     "cross-env": "7.0.3",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
@@ -43,10 +43,10 @@
     "webpack": "^5.75.0"
   },
   "peerDependencies": {
-    "@tsed/core": ">=8.8.2",
-    "@tsed/hooks": ">=8.8.2",
+    "@tsed/core": ">=8.8.4",
+    "@tsed/hooks": ">=8.8.4",
     "@tsed/logger": ">=7.0.1",
-    "@tsed/schema": ">=8.8.2"
+    "@tsed/schema": ">=8.8.4"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

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

@@ -14,7 +14,7 @@ describe("LazyInject", () => {
       lazy: Promise<MyLazyModule>;
     }
 
-    const service = inject<MyInjectable>(MyInjectable);
+    const service = inject(MyInjectable);
     const nbProviders = injector().getProviders().length;
 
     const lazyService = await service.lazy;

package/src/common/domain/Provider.ts

@@ -202,4 +202,12 @@ export class Provider<T = any> implements ProviderOpts<T> {
       .filter(Boolean)
       .join(":");
   }
+
+  reset() {
+    this.useValue = undefined;
+    this.useFactory = undefined;
+    this.useAsyncFactory = undefined;
+
+    return this;
+  }
 }

package/src/common/fn/inject.ts

@@ -20,7 +20,10 @@ import {invokeOptions, localsContainer} from "./localsContainer.js";
  * @returns {Function}
  * @decorator
  */
-export function inject<T>(token: TokenProvider<T>, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T {
+export function inject<TokenType>(
+  token: TokenProvider<TokenType>,
+  opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>
+): TokenType {
   return injector().resolve(token, {
     ...opts,
     ...invokeOptions(),

package/src/common/interfaces/TokenProvider.ts

@@ -1,3 +1,8 @@
 import type {AbstractType, Type} from "@tsed/core";
 
-export type TokenProvider<T = any> = string | symbol | Type<T> | AbstractType<T> | Function;
+/**
+ * A token is a unique identifier for a provider in the dependency injection system.
+ * It solves the inference problem when using `inject()` function.
+ */
+export type FactoryTokenProvider<T = any> = T & {readonly __type: "token_factory"};
+export type TokenProvider<T = any> = string | symbol | Type<T> | AbstractType<T> | FactoryTokenProvider<T>;

package/src/common/services/InjectorService.ts

@@ -469,7 +469,7 @@ export class InjectorService extends Container {
             provider.useFactory = undefined;
 
             if ("useClass" in props) {
-              provider.useClass = props.useClass;
+              provider.useClass = props.useClass as TokenProvider;
               return;
             }
 
@@ -484,7 +484,7 @@ export class InjectorService extends Container {
             }
 
             if ("use" in props) {
-              provider.useValue = props.use;
+              provider.useValue = props.use as unknown;
               return;
             }
           }

package/src/common/utils/providerBuilder.ts

@@ -5,26 +5,35 @@ import {Store, type Type} from "@tsed/core";
 import {ProviderType} from "../domain/ProviderType.js";
 import {injector} from "../fn/injector.js";
 import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
-import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import type {FactoryTokenProvider, TokenProvider} from "../interfaces/TokenProvider.js";
 import {GlobalProviders} from "../registries/GlobalProviders.js";
 
-type ProviderBuilder<Token extends TokenProvider, BaseProvider, T extends object> = {
-  [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<Token, BaseProvider, T>;
-} & {
+type BaseMethodsProvider<TypeOf, BaseProvider, T extends object> = {
+  [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<TypeOf, BaseProvider, T>;
+};
+
+type ProviderBuilder<TypeOf, BaseProvider, T extends object> = BaseMethodsProvider<TypeOf, BaseProvider, T> & {
   inspect(): BaseProvider;
   store(): Store;
-  token(): Token;
-  factory(f: (...args: unknown[]) => unknown): ProviderBuilder<Token, BaseProvider, T>;
-  asyncFactory(f: (...args: unknown[]) => Promise<unknown>): ProviderBuilder<Token, BaseProvider, T>;
-  value(v: unknown): ProviderBuilder<Token, BaseProvider, T>;
-  class(c: Type): ProviderBuilder<Token, BaseProvider, T>;
+  token(): TypeOf;
+  factory<FactoryReturn>(f: (...args: unknown[]) => FactoryReturn): ProviderBuilder<FactoryTokenProvider<FactoryReturn>, BaseProvider, T>;
+  asyncFactory<FactoryReturn>(
+    f: (...args: unknown[]) => Promise<FactoryReturn>
+  ): ProviderBuilder<FactoryTokenProvider<FactoryReturn>, BaseProvider, T>;
+  value<Value>(v: Value): ProviderBuilder<FactoryTokenProvider<Value>, BaseProvider, T>;
+  class<TokenKlass>(c: Type<TokenKlass>): ProviderBuilder<TokenKlass, BaseProvider, T>;
 };
 
-export function providerBuilder<Provider, Picked extends keyof Provider>(props: string[], baseOpts: Partial<ProviderOpts<Provider>> = {}) {
-  return <Token extends TokenProvider>(
-    token: Token,
-    options: Partial<ProviderOpts<Type>> = {}
-  ): ProviderBuilder<Token, Provider, Pick<Provider, Picked>> => {
+export type ProviderBuilderFn<Provider, Picked extends keyof Provider> = <TypeOf extends TokenProvider>(
+  token: TypeOf,
+  options?: Partial<ProviderOpts<Type>>
+) => ProviderBuilder<TypeOf, Provider, Pick<Provider, Picked>>;
+
+export function providerBuilder<Provider, Picked extends keyof Provider>(
+  props: string[],
+  baseOpts: Partial<ProviderOpts<Provider>> = {}
+): ProviderBuilderFn<Provider, Picked> {
+  return <TypeOf extends TokenProvider>(token: TypeOf, options: Partial<ProviderOpts<Type>> = {}) => {
     const merged = {
       global: !injector().isLoaded(),
       ...options,
@@ -49,20 +58,24 @@ export function providerBuilder<Provider, Picked extends keyof Provider>(props:
         };
       },
       {
-        factory(factory: any) {
+        factory(factory: Function) {
+          provider.reset();
           provider.useFactory = factory;
           return this;
         },
-        asyncFactory(asyncFactory: any) {
+        asyncFactory(asyncFactory: Function) {
+          provider.reset();
           provider.useAsyncFactory = asyncFactory;
           return this;
         },
         value(value: any) {
+          provider.reset();
           provider.useValue = value;
           provider.type = ProviderType.VALUE;
           return this;
         },
         class(k: any) {
+          provider.reset();
           provider.useClass = k;
           return this;
         },
@@ -73,9 +86,9 @@ export function providerBuilder<Provider, Picked extends keyof Provider>(props:
           return provider;
         },
         token() {
-          return provider.token as Token;
+          return provider.token as TypeOf;
         }
-      } as ProviderBuilder<Token, Provider, Pick<Provider, Picked>>
+      } as ProviderBuilder<TypeOf, Provider, Pick<Provider, Picked>>
     );
   };
 }

package/src/node/services/DITest.ts

@@ -63,9 +63,9 @@ export class DITest {
   static async invoke<T = any>(target: TokenProvider<T>, providers: UseImportTokenProviderOpts[] = []): Promise<T> {
     const locals = localsContainer({providers, rebuild: true});
 
-    const instance: T & OnInit = inject<T & OnInit>(target, {locals, rebuild: true});
+    const instance: T & Partial<OnInit> = inject(target as any, {locals, rebuild: true});
 
-    if (instance && isObject(instance) && "$onInit" in instance) {
+    if (instance && isObject(instance) && instance?.$onInit) {
       const result = instance.$onInit();
 
       if (result instanceof Promise) {