@tsed/di 8.18.1 → 8.19.0

package/lib/types/common/services/InjectorService.d.ts

@@ -5,24 +5,28 @@ import type { InvokeOptions } from "../interfaces/InvokeOptions.js";
 import type { TokenProvider } from "../interfaces/TokenProvider.js";
 import { DIConfiguration } from "./DIConfiguration.js";
 /**
- * This service contain all services collected by `@Service` or services declared manually with `InjectorService.factory()` or `InjectorService.service()`.
+ * Core dependency injection orchestrator managing provider lifecycle and resolution.
  *
- * ### Example:
+ * The main service responsible for registering, resolving, and managing all injectable providers.
+ * Handles dependency graph resolution, instance caching, scope management, and lifecycle hooks.
+ *
+ * ### Usage
  *
  * ```typescript
  * import {InjectorService} from "@tsed/di";
  *
- * // Import the services (all services are decorated with @Service()";
+ * // Import the services (all services are decorated with @Service())
  * import MyService1 from "./services/service1.js";
  * import MyService2 from "./services/service2.js";
  * import MyService3 from "./services/service3.js";
  *
- * // When all services are imported, you can load InjectorService.
- *
+ * // When all services are imported, you can load InjectorService
  * await injector().load();
  *
  * const myService1 = injector.get<MyService1>(MyService1);
  * ```
+ *
+ * @public
  */
 export declare class InjectorService extends Container {
     #private;
@@ -32,105 +36,147 @@ export declare class InjectorService extends Container {
     constructor();
     isLoaded(): boolean;
     /**
-     * Return a list of instance build by the injector.
+     * Return a list of all instances built by the injector.
+     *
+     * @returns An array of all cached provider instances
      */
     toArray(): any[];
     /**
-     * Get a service or factory already constructed from his symbol or class.
+     * Get a service or factory already constructed from its symbol or class.
      *
-     * #### Example
+     * Returns the cached instance if available, otherwise resolves and caches the provider.
+     *
+     * ### Usage
      *
      * ```typescript
      * import {InjectorService} from "@tsed/di";
      * import MyService from "./services.js";
      *
      * class OtherService {
-     *      constructor(injectorService: InjectorService) {
-     *          const myService = injectorService.get<MyService>(MyService);
-     *      }
+     *   constructor(injectorService: InjectorService) {
+     *     const myService = injectorService.get<MyService>(MyService);
+     *   }
      * }
      * ```
      *
-     * @param token The class or symbol registered in InjectorService.
-     * @param options
+     * @param token The class or symbol registered in InjectorService
+     * @param options Optional invocation options
+     * @returns The resolved provider instance
      */
     get<T = any>(token: TokenProvider<T>, options?: Partial<InvokeOptions>): T;
     /**
-     * Return all instance of the same provider type
+     * Return all instances of providers matching the specified type.
+     *
+     * Retrieves all providers of a given type and resolves their instances.
+     *
+     * @param type The provider type to filter by (e.g., ProviderType.CONTROLLER)
+     * @param options Optional invocation options
+     * @returns Array of resolved instances matching the type
      */
     getMany<Type = any>(type: any, options?: Partial<InvokeOptions>): Type[];
     /**
-     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+     * Check if a provider instance exists in the cache.
+     *
+     * @param token The token to check for
+     * @returns `true` if the instance is cached, `false` otherwise
      */
     has(token: TokenProvider): boolean;
     /**
-     * Declare an alias for a given token.
+     * Create an alias for a provider token.
+     *
+     * Allows the same provider instance to be retrieved using a different token.
+     *
+     * @param token The original provider token
+     * @param alias The alias token to register
+     * @returns The injector instance for chaining
      */
     alias(token: TokenProvider, alias: TokenProvider): this;
     /**
-     * Resolve the token depending on his provider configuration.
+     * Resolve a provider token and return its instance.
      *
-     * If the token isn't cached, the injector will invoke the provider and cache the result.
+     * If the token isn't cached, the injector creates the instance according to the provider configuration
+     * and caches it based on the provider's scope (singleton, request, or instance).
      *
-     * #### Example
+     * ### Usage
      *
      * ```typescript
      * import {InjectorService} from "@tsed/di";
      * import MyService from "./services.js";
      *
      * class OtherService {
-     *     constructor(injectorService: InjectorService) {
-     *          const myService = injectorService.invoke<MyService>(MyService);
-     *      }
-     *  }
+     *   constructor(injectorService: InjectorService) {
+     *     const myService = injectorService.resolve<MyService>(MyService);
+     *   }
+     * }
      * ```
      *
-     * @param token The injectable class to invoke. Class parameters are injected according constructor signature.
-     * @param options {InvokeOptions} Optional options to invoke the class.
-     * @returns {Type} The class constructed.
+     * @param token The injectable class to invoke. Constructor parameters are injected automatically
+     * @param options Optional invocation options (locals, rebuild, useOpts, etc.)
+     * @returns The resolved provider instance
      */
     resolve<Type = any>(token: TokenProvider<Type>, options?: Partial<InvokeOptions>): Type;
     /**
-     * Resolve the token depending on his provider configuration.
+     * Invoke a provider token and return its instance.
      *
-     * If the token isn't cached, the injector will invoke the provider and cache the result.
+     * Alias for `resolve()`. If the token isn't cached, the injector creates the instance
+     * according to the provider configuration.
      *
-     * #### Example
+     * ### Usage
      *
      * ```typescript
      * import {InjectorService} from "@tsed/di";
      * import MyService from "./services.js";
      *
      * class OtherService {
-     *     constructor(injectorService: InjectorService) {
-     *          const myService = injectorService.invoke<MyService>(MyService);
-     *      }
-     *  }
+     *   constructor(injectorService: InjectorService) {
+     *     const myService = injectorService.invoke<MyService>(MyService);
+     *   }
+     * }
      * ```
      *
-     * @param token The injectable class to invoke. Class parameters are injected according constructor signature.
-     * @param options {InvokeOptions} Optional options to invoke the class.
-     * @returns {Type} The class constructed.
-     * @alias InjectorService.resolve
+     * @param token The injectable class to invoke. Constructor parameters are injected automatically
+     * @param options Optional invocation options (locals, rebuild, useOpts, etc.)
+     * @returns The resolved provider instance
+     * @see resolve
      */
     invoke<Type = any>(token: TokenProvider<Type>, options?: Partial<InvokeOptions>): Type;
     /**
-     * Build only providers which are asynchronous.
+     * Build all asynchronous providers.
+     *
+     * Resolves providers that have async factories or async initialization.
+     * Called automatically during the `load()` process.
      */
     loadAsync(): Promise<void>;
     /**
-     * Build only providers which are synchronous.
+     * Build all synchronous singleton providers.
+     *
+     * Instantiates all singleton-scoped providers that haven't been cached yet.
+     * Called automatically during the `load()` process after async providers.
      */
     loadSync(): void;
     /**
-     * Build all providers from given container (or GlobalProviders) and emit `$onInit` event.
+     * Load and initialize all registered providers.
      *
-     * @param container
+     * Bootstraps the DI system by resolving configuration, building provider instances,
+     * and triggering lifecycle hooks (`$beforeInit`, `$onInit`).
+     *
+     * ### Usage
+     *
+     * ```typescript
+     * import {injector} from "@tsed/di";
+     *
+     * await injector().load();
+     * ```
+     *
+     * @param container Optional container with additional providers to merge
      */
     load(container?: Container): Promise<void>;
     /**
-     * Load all configurations registered on providers via @Configuration decorator.
-     * It inspects for each provider some fields like imports, mount, etc. to resolve the configuration.
+     * Resolve and merge all provider configurations.
+     *
+     * Collects configuration from all providers decorated with `@Configuration`,
+     * merges them, and stores the result in the injector settings.
+     * Called automatically during the load process.
      */
     resolveConfiguration(): Promise<void>;
     /**

package/lib/types/node/utils/asyncHookContext.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { DIContext } from "../../common/domain/DIContext.js";
 import { InjectorService } from "../../common/index.js";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/di",
   "description": "DI module for Ts.ED Framework",
   "type": "module",
-  "version": "8.18.1",
+  "version": "8.19.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -29,14 +29,14 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.18.1",
-    "@tsed/core": "8.18.1",
-    "@tsed/hooks": "8.18.1",
+    "@tsed/barrels": "8.19.0",
+    "@tsed/core": "8.19.0",
+    "@tsed/hooks": "8.19.0",
     "@tsed/logger": "^8.0.0",
-    "@tsed/typescript": "8.18.1",
+    "@tsed/typescript": "8.19.0",
     "cross-env": "7.0.3",
     "eslint": "9.12.0",
-    "typescript": "5.4.5",
+    "typescript": "5.9.3",
     "vite": "7.1.11",
     "vitest": "3.2.4"
   },