@tsed/di 8.37.1 → 8.38.0-beta.2

package/lib/esm/common/domain/Container.js

@@ -13,15 +13,15 @@ import { Provider } from "./Provider.js";
  * const container = new Container();
  * container.add(MyService, {scope: ProviderScope.SINGLETON});
  *
- * const provider = container.getProvider(MyService);
- * const controllers = container.getProviders(ProviderType.CONTROLLER);
+ * const provider = container.get(MyService);
+ * const controllers = container.getMany(ProviderType.CONTROLLER);
  * ```
  *
  * @public
  */
 export class Container extends Map {
     /**
-     *
+     * Add a provider to the
      * @param token
      * @param settings
      */
@@ -30,35 +30,7 @@ export class Container extends Map {
         Object.assign(provider, settings);
         return super.set(token, provider);
     }
-    /**
-     * Add a provider to the
-     * @param token
-     * @param settings
-     */
-    addProvider(token, settings = {}) {
-        return this.add(token, settings);
-    }
-    /**
-     *
-     * @param token
-     */
-    hasProvider(token) {
-        return super.has(token);
-    }
-    /**
-     * Add a provider to the
-     * @param token
-     * @param provider
-     */
-    setProvider(token, 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
-     */
-    getProvider(token) {
+    get(token) {
         return super.get(token);
     }
     /**
@@ -67,7 +39,7 @@ export class Container extends Map {
      * @param type Filter the list by the given ProviderType.
      * @returns {[TokenProvider , Provider<any>][]}
      */
-    getProviders(type) {
+    getMany(type) {
         if (!type) {
             return [...this.values()];
         }
@@ -80,10 +52,10 @@ export class Container extends Map {
         }
         return providers;
     }
-    addProviders(container) {
+    merge(container) {
         container.forEach((provider) => {
-            if (!this.hasProvider(provider.token)) {
-                this.setProvider(provider.token, provider.clone());
+            if (!super.has(provider.token)) {
+                super.set(provider.token, provider.clone());
             }
         });
     }

package/lib/esm/common/domain/ContextLogger.js

@@ -37,6 +37,9 @@ export class ContextLogger {
         this.level = (LEVELS[(level || this.#logger.level || "").toUpperCase()] || LEVELS.ALL);
         this.maxStackSize = maxStackSize;
     }
+    get level() {
+        return this.#level;
+    }
     set level(level) {
         if (typeof level === "string") {
             this.#level = LEVELS[level.toUpperCase()];
@@ -45,9 +48,6 @@ export class ContextLogger {
             this.#level = level;
         }
     }
-    get level() {
-        return this.#level;
-    }
     get hooks() {
         return (this.#hooks = this.#hooks || new Hooks());
     }

package/lib/esm/common/services/DIConfiguration.js

@@ -27,11 +27,17 @@ import { setValue } from "@tsed/core/utils/setValue.js";
  * @public
  */
 export class DIConfiguration {
+    /**
+     * Creates a configuration service with the built-in defaults merged with the supplied initial properties.
+     *
+     * @param initialProps Initial configuration values that override built-in defaults.
+     */
     constructor(initialProps = {}) {
         this.default = new Map();
         this.map = new Map();
         Object.entries({
             imports: [],
+            lazyProviders: false,
             routes: [],
             mount: {},
             logger: {},
@@ -40,59 +46,138 @@ export class DIConfiguration {
             this.default.set(key, value);
         });
     }
+    /**
+     * Gets the application version.
+     */
     get version() {
         return this.get("version");
     }
+    /**
+     * Sets the application version.
+     *
+     * @param v Version to store in the configuration.
+     */
     set version(v) {
         this.map.set("version", v);
     }
+    /**
+     * Gets the application's root directory.
+     */
     get rootDir() {
         return this.get("rootDir");
     }
+    /**
+     * Sets the application's root directory.
+     *
+     * @param value Root directory to store in the configuration.
+     */
     set rootDir(value) {
         this.map.set("rootDir", value);
     }
+    /**
+     * Gets the active runtime environment.
+     */
     get env() {
         return this.map.get("env");
     }
+    /**
+     * Sets the active runtime environment.
+     *
+     * @param value Environment to store in the configuration.
+     */
     set env(value) {
         this.map.set("env", value);
     }
+    /**
+     * Gets the providers and modules imported by the application.
+     */
     get imports() {
         return this.get("imports");
     }
+    /**
+     * Sets the providers and modules imported by the application.
+     *
+     * @param imports Provider tokens or import options to configure.
+     */
     set imports(imports) {
         this.map.set("imports", imports);
     }
+    /**
+     * Indicates whether synchronous singleton providers without hooks are deferred until first use.
+     */
+    get lazyProviders() {
+        return this.get("lazyProviders");
+    }
+    /**
+     * Enables or disables deferred initialization of synchronous singleton providers without hooks.
+     *
+     * @param lazyProviders Whether to defer eligible providers.
+     */
+    set lazyProviders(lazyProviders) {
+        this.map.set("lazyProviders", lazyProviders);
+    }
+    /**
+     * Gets the route providers registered by the application.
+     */
     get routes() {
         return this.get("routes");
     }
+    /**
+     * Sets the route providers registered by the application.
+     *
+     * @param routes Route providers to configure.
+     */
     set routes(routes) {
         this.map.set("routes", routes);
     }
+    /**
+     * Gets the logger options.
+     */
     get logger() {
         return this.get("logger");
     }
+    /**
+     * Merges logger options into the current logger configuration.
+     *
+     * @param value Logger options to merge.
+     */
     set logger(value) {
         const logger = { ...this.logger, ...value };
         this.map.set("logger", logger);
     }
+    /**
+     * Indicates whether the logger is configured at the `debug` level.
+     */
     get debug() {
         return this.logger.level === "debug";
     }
+    /**
+     * Enables or disables debug-level logging.
+     *
+     * @param debug `true` to set the logger level to `debug`; `false` to set it to `info`.
+     */
     set debug(debug) {
         this.logger = { ...this.logger, level: debug ? "debug" : "info" };
     }
+    /**
+     * Gets route providers grouped by mount path.
+     */
     get mount() {
         return this.get("mount");
     }
+    /**
+     * Sets route providers grouped by mount path.
+     *
+     * @param value Route providers indexed by mount path.
+     */
     set mount(value) {
         this.setRaw("mount", value);
     }
     /**
+     * Invokes a callback once for each configured key, including default and overridden values.
      *
-     * @param callbackfn
-     * @param thisArg
+     * @param callbackfn Callback invoked with the resolved value, key, and override map.
+     * @param thisArg Value to use as `this` when invoking the callback.
      */
     forEach(callbackfn, thisArg) {
         return new Set([...Array.from(this.default.keys()), ...Array.from(this.map.keys())]).forEach((key) => {
@@ -117,19 +202,34 @@ export class DIConfiguration {
         }
         return this;
     }
+    /**
+     * Sets a configuration value directly in the override map, supporting nested property paths.
+     *
+     * @param propertyKey Configuration key or nested property path.
+     * @param value Value to store.
+     * @returns This configuration instance for chaining.
+     */
     setRaw(propertyKey, value) {
         setValue(this.map, propertyKey, value);
         return this;
     }
     /**
+     * Gets a resolved configuration value, preferring explicit overrides over default values.
      *
-     * @param propertyKey
-     * @param defaultValue
-     * @returns {undefined|any}
+     * @param propertyKey Configuration key or nested property path.
+     * @param defaultValue Value to return when neither the overrides nor defaults define the key.
+     * @returns The resolved configuration value.
      */
     get(propertyKey, defaultValue) {
         return this.getRaw(propertyKey, defaultValue);
     }
+    /**
+     * Defines a custom configuration member when a member with the same key does not already exist.
+     *
+     * @param key Name of the member to define.
+     * @param value Function or property descriptor to assign to the configuration prototype.
+     * @returns This configuration instance when the member already exists.
+     */
     decorate(key, value) {
         if (key in this) {
             return this;
@@ -140,6 +240,13 @@ export class DIConfiguration {
             }
             : value);
     }
+    /**
+     * Resolves a configuration value from overrides, defaults, or the supplied fallback in that order.
+     *
+     * @param propertyKey Configuration key or nested property path.
+     * @param defaultValue Value to return when no configured value exists.
+     * @returns The resolved configuration value.
+     */
     getRaw(propertyKey, defaultValue) {
         const value = getValue(this.map, propertyKey);
         if (value !== undefined) {

package/lib/esm/common/services/InjectorService.js

@@ -43,23 +43,88 @@ const EXCLUDED_CONFIGURATION_KEYS = ["mount", "imports"];
  *
  * @public
  */
-export class InjectorService extends Container {
+export class InjectorService {
+    /**
+     * Providers containers
+     * @private
+     */
+    #providers;
+    /**
+     * Cached instance
+     * @private
+     */
     #cache;
     #loaded;
+    #hooksReady;
+    #registeredSingletonHooks;
+    #resolvingProviders;
     constructor() {
-        super();
         this.logger = console;
         /*readonly */
         this.settings = new DIConfiguration();
-        this.resolvedConfiguration = false;
+        /**
+         * Providers containers
+         * @private
+         */
+        this.#providers = new Container();
+        /**
+         * Cached instance
+         * @private
+         */
         this.#cache = new LocalsContainer();
+        this.resolvedConfiguration = false;
         this.#loaded = false;
+        this.#hooksReady = false;
+        this.#registeredSingletonHooks = new Set();
+        this.#resolvingProviders = new Set();
         this.#cache.set(InjectorService, this);
         this.#cache.set(DIConfiguration, this.settings);
     }
+    get providers() {
+        return this.#providers;
+    }
     isLoaded() {
         return this.#loaded;
     }
+    add(token, settings = {}) {
+        this.#providers.add(token, settings);
+        this.setProvider(token, this.#providers.get(token));
+        return this;
+    }
+    /**
+     * @alias InjectorService.add
+     */
+    addProvider(token, settings = {}) {
+        return this.add(token, settings);
+    }
+    setProvider(token, provider) {
+        this.#providers.set(token, provider);
+        if (this.#registeredSingletonHooks.delete(token)) {
+            $off(token);
+        }
+        if (provider.scope === ProviderScope.SINGLETON && (!this.#loaded || this.#hooksReady)) {
+            this.registerHooks(provider, {});
+        }
+        return this;
+    }
+    /**
+     * Get a provider definition from the provider registry.
+     *
+     * Unlike `get()`, this method does not resolve the provider instance.
+     * @deprecated Since v8. Use injector().providers.get() instead
+     */
+    getProvider(token) {
+        return this.#providers.get(token);
+    }
+    /**
+     * Get provider definitions matching a type.
+     *
+     * Unlike `getMany()`, this method does not resolve provider instances.
+     * @deprecated Since v8. Use injector().providers.getMany() instead.
+     */
+    getProviders(type) {
+        return this.#providers.getMany(type);
+    }
     /**
      * Return a list of all instances built by the injector.
      *
@@ -107,7 +172,7 @@ export class InjectorService extends Container {
      * @returns Array of resolved instances matching the type
      */
     getMany(type, options) {
-        return this.getProviders(type).map((provider) => {
+        return this.#providers.getMany(type).map((provider) => {
             return this.resolve(provider.token, options);
         });
     }
@@ -118,7 +183,7 @@ export class InjectorService extends Container {
      * @returns `true` if the instance is cached, `false` otherwise
      */
     has(token) {
-        return this.#cache.get(token) !== undefined;
+        return this.#cache.has(token);
     }
     /**
      * Create an alias for a provider token.
@@ -157,9 +222,8 @@ export class InjectorService extends Container {
      * @returns The resolved provider instance
      */
     resolve(token, options = {}) {
-        let instance = options.locals ? options.locals.get(token) : undefined;
-        if (instance !== undefined) {
-            return instance;
+        if (options.locals?.has(token)) {
+            return options.locals.get(token);
         }
         if (token === DI_USE_PARAM_OPTIONS) {
             return options.useOpts;
@@ -168,25 +232,21 @@ export class InjectorService extends Container {
             // keep this configuration for legacy code that use as custom Configuration service
             return this.settings;
         }
-        instance = !options.rebuild ? this.#cache.get(token) : undefined;
-        if (instance != undefined) {
-            return instance;
+        if (!options.rebuild && this.#cache.has(token)) {
+            return this.#cache.get(token);
         }
         const provider = this.ensureProvider(token);
         // maybe not necessary
         if (!provider || options.rebuild) {
-            instance = this.invokeToken(token, options);
+            const instance = this.invokeToken(token, options);
             if (provider) {
                 return this.setToCache(provider, instance);
             }
             return instance;
         }
-        instance = this.invokeToken(token, options);
+        const instance = this.invokeToken(token, options);
         switch (provider.scope) {
             case ProviderScope.SINGLETON:
-                if (!options.rebuild) {
-                    this.registerHooks(provider, options);
-                }
                 return this.setToCache(provider, instance);
             case ProviderScope.REQUEST:
                 if (options.locals) {
@@ -231,8 +291,11 @@ export class InjectorService extends Container {
      * Called automatically during the `load()` process.
      */
     async loadAsync() {
-        for (const [, provider] of this) {
-            if (!this.has(provider.token) && provider.isAsync()) {
+        for (const [, provider] of this.#providers) {
+            if (!provider.isAsync()) {
+                continue;
+            }
+            if (!this.has(provider.token)) {
                 await this.resolve(provider.token);
             }
         }
@@ -244,9 +307,14 @@ export class InjectorService extends Container {
      * Called automatically during the `load()` process after async providers.
      */
     loadSync() {
-        for (const [, provider] of this) {
-            // TODO try to lazy provider instead initiate all providers (&& provider.hasRegisteredHooks())
-            if (!this.has(provider.token) && provider.scope === ProviderScope.SINGLETON) {
+        if (this.settings.lazyProviders) {
+            return;
+        }
+        for (const [, provider] of this.#providers) {
+            if (provider.scope !== ProviderScope.SINGLETON || provider.isAsync()) {
+                continue;
+            }
+            if (!this.has(provider.token)) {
                 this.resolve(provider.token);
             }
         }
@@ -271,6 +339,7 @@ export class InjectorService extends Container {
         // avoid provider registration in the GlobalContainer during the loading phase
         // using injectable() or providerBuilder()
         this.#loaded = true;
+        this.#hooksReady = true;
         await $asyncEmit("$beforeInit");
         await this.bootstrap(container);
         // build async and sync provider
@@ -291,7 +360,7 @@ export class InjectorService extends Container {
             return;
         }
         const mergedConfiguration = new Map();
-        super.forEach((provider) => {
+        this.#providers.forEach((provider) => {
             if (provider.configuration && provider.type !== "server:module") {
                 Object.entries(provider.configuration).forEach(([key, value]) => {
                     if (!EXCLUDED_CONFIGURATION_KEYS.includes(key)) {
@@ -345,6 +414,11 @@ export class InjectorService extends Container {
         this.#cache.forEach((_, token) => {
             $off(token);
         });
+        this.#registeredSingletonHooks.forEach((token) => {
+            $off(token);
+        });
+        this.#registeredSingletonHooks.clear();
+        this.#hooksReady = false;
     }
     /**
      * Bootstrap injector from container, resolve configuration and providers.
@@ -353,7 +427,7 @@ export class InjectorService extends Container {
      */
     async bootstrap(container = createContainer()) {
         // Clone all providers in the container
-        this.addProviders(container);
+        this.mergeProviders(container);
         // Resolve all configuration
         await this.resolveConfiguration();
         // allow mocking or changing provider instance before loading injector
@@ -361,10 +435,10 @@ export class InjectorService extends Container {
         return this;
     }
     ensureProvider(token, force = false) {
-        if (!this.hasProvider(token) && (Provider.Registry.has(token) || force)) {
-            this.addProvider(token);
+        if (!this.#providers.has(token) && (Provider.Registry.has(token) || force)) {
+            this.add(token);
         }
-        return this.getProvider(token);
+        return this.#providers.get(token);
     }
     /**
      * Invoke a class method and inject service.
@@ -388,44 +462,70 @@ export class InjectorService extends Container {
             return undefined;
         }
         const { token, deps, construct, imports, provider } = resolvedOpts;
-        $emit("$beforeInvoke", token, [resolvedOpts]);
-        $emit(`$beforeInvoke:${String(provider.type)}`, [resolvedOpts]);
-        let instance;
-        let currentDependency = false;
+        this.#resolvingProviders.add(provider.token);
         try {
-            const invokeDependency = (parent) => (token, index) => {
-                currentDependency = { token, index, deps };
-                if (isArray(token)) {
-                    return this.getMany(token[0], options);
+            $emit("$beforeInvoke", token, [resolvedOpts]);
+            $emit(`$beforeInvoke:${String(provider.type)}`, [resolvedOpts]);
+            let instance;
+            let currentDependency;
+            let currentDependencyIndex = -1;
+            let hasCurrentDependency = false;
+            try {
+                // Invoke manually imported providers
+                for (let index = 0; index < imports.length; index++) {
+                    currentDependency = imports[index];
+                    currentDependencyIndex = index;
+                    hasCurrentDependency = true;
+                    this.invokeDependency(currentDependency, index, undefined, provider, options);
                 }
-                return isInheritedFrom(token, Provider, 1)
-                    ? provider
-                    : this.resolve(token, {
-                        parent,
-                        locals: options.locals,
-                        useOpts: provider?.getArgOpts(index) || options.useOpts
-                    });
-            };
-            // Invoke manually imported providers
-            imports.forEach(invokeDependency());
-            // Inject dependencies
-            const services = deps.map(invokeDependency(token));
-            currentDependency = false;
-            instance = construct(services);
+                // Inject dependencies
+                const services = new Array(deps.length);
+                for (let index = 0; index < deps.length; index++) {
+                    currentDependency = deps[index];
+                    currentDependencyIndex = index;
+                    hasCurrentDependency = true;
+                    services[index] = this.invokeDependency(currentDependency, index, token, provider, options);
+                }
+                hasCurrentDependency = false;
+                instance = construct(services);
+            }
+            catch (error) {
+                const dependency = hasCurrentDependency ? { token: currentDependency, index: currentDependencyIndex, deps } : false;
+                InjectionError.throwInjectorError(token, dependency, error);
+            }
+            if (instance === undefined) {
+                throw new InjectionError(token, `Unable to create new instance from undefined value. Check your provider declaration for ${nameOf(token)}`);
+            }
+            if (instance && isClass(classOf(instance))) {
+                Reflect.defineProperty(instance, DI_INVOKE_OPTIONS, {
+                    get: () => ({ rebuild: options.rebuild, locals: options.locals })
+                });
+            }
+            $emit("$afterInvoke", token, [instance, resolvedOpts]);
+            return instance;
         }
-        catch (error) {
-            InjectionError.throwInjectorError(token, currentDependency, error);
+        finally {
+            this.#resolvingProviders.delete(provider.token);
         }
-        if (instance === undefined) {
-            throw new InjectionError(token, `Unable to create new instance from undefined value. Check your provider declaration for ${nameOf(token)}`);
+    }
+    mergeProviders(container) {
+        container.forEach((provider) => {
+            if (!this.#providers.has(provider.token)) {
+                this.setProvider(provider.token, provider.clone());
+            }
+        });
+    }
+    invokeDependency(token, index, parent, provider, options) {
+        if (isArray(token)) {
+            return this.getMany(token[0], options);
         }
-        if (instance && isClass(classOf(instance))) {
-            Reflect.defineProperty(instance, DI_INVOKE_OPTIONS, {
-                get: () => ({ rebuild: options.rebuild, locals: options.locals })
+        return isInheritedFrom(token, Provider, 1)
+            ? provider
+            : this.resolve(token, {
+                parent,
+                locals: options.locals,
+                useOpts: provider.getArgOpts(index) || options.useOpts
             });
-        }
-        $emit("$afterInvoke", token, [instance, resolvedOpts]);
-        return instance;
     }
     resolveImportsProviders() {
         const imports = this.settings.imports;
@@ -444,18 +544,22 @@ export class InjectorService extends Container {
             provider.useFactory = undefined;
             if ("useClass" in props) {
                 provider.useClass = props.useClass;
+                this.setProvider(token, provider);
                 continue;
             }
             if ("useFactory" in props) {
                 provider.useFactory = props.useFactory;
+                this.setProvider(token, provider);
                 continue;
             }
             if ("useAsyncFactory" in props) {
                 provider.useAsyncFactory = props.useAsyncFactory;
+                this.setProvider(token, provider);
                 continue;
             }
             if ("use" in props) {
                 provider.useValue = props.use;
+                this.setProvider(token, provider);
                 continue;
             }
             resolvedImports.push(meta);
@@ -476,13 +580,7 @@ export class InjectorService extends Container {
         if (!token || token === Object) {
             throw new Error("Given token is undefined. Could mean a circular dependency problem. Try to use @Inject(() => Token) to solve it.");
         }
-        let provider;
-        if (!this.hasProvider(token)) {
-            provider = new Provider(token);
-        }
-        else {
-            provider = this.getProvider(token);
-        }
+        const provider = this.#providers.get(token) || new Provider(token);
         deps = deps || provider.deps;
         imports = imports || provider.imports;
         if (provider.useValue !== undefined) {
@@ -525,9 +623,20 @@ export class InjectorService extends Container {
                 }
                 return;
             }
+            if (this.#registeredSingletonHooks.has(provider.token)) {
+                return;
+            }
+            this.#registeredSingletonHooks.add(provider.token);
             Object.entries(provider.hooks).forEach(([event, cb]) => {
                 const callback = (...args) => {
-                    return cb(this.#cache.get(provider.token), ...args);
+                    let instance = this.#cache.get(provider.token);
+                    if (instance === undefined) {
+                        if (event === "$onDestroy" || this.#resolvingProviders.has(provider.token)) {
+                            return;
+                        }
+                        instance = this.resolve(provider.token);
+                    }
+                    return cb(instance, ...args);
                 };
                 $on(event, provider.token, callback);
             });

package/lib/esm/node/services/DITest.js

@@ -1,4 +1,4 @@
-import { DI_INJECTABLE_PROPS, createContainer, destroyInjector, inject, injector } from "../../common/index.js";
+import { createContainer, destroyInjector, DI_INJECTABLE_PROPS, inject, injector } from "../../common/index.js";
 import { cleanAllLocalsContainer, detachLocalsContainer, localsContainer } from "../../common/fn/localsContainer.js";
 import { $log } from "@tsed/logger";
 import { DIContext } from "../../common/domain/DIContext.js";

package/lib/types/common/domain/Container.d.ts

@@ -16,48 +16,26 @@ import type { TokenProvider } from "../interfaces/TokenProvider.js";
  * const container = new Container();
  * container.add(MyService, {scope: ProviderScope.SINGLETON});
  *
- * const provider = container.getProvider(MyService);
- * const controllers = container.getProviders(ProviderType.CONTROLLER);
+ * const provider = container.get(MyService);
+ * const controllers = container.getMany(ProviderType.CONTROLLER);
  * ```
  *
  * @public
  */
 export declare class Container extends Map<TokenProvider, Provider> {
-    /**
-     *
-     * @param token
-     * @param settings
-     */
-    add(token: TokenProvider, settings?: Partial<ProviderOpts>): this;
     /**
      * Add a provider to the
      * @param token
      * @param settings
      */
-    addProvider(token: TokenProvider, settings?: Partial<ProviderOpts>): this;
-    /**
-     *
-     * @param token
-     */
-    hasProvider(token: TokenProvider): boolean;
-    /**
-     * Add a provider to the
-     * @param token
-     * @param provider
-     */
-    setProvider(token: TokenProvider, provider: Provider): this;
-    /**
-     * 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
-     */
-    getProvider<T extends Provider = Provider>(token: TokenProvider | undefined): T | undefined;
+    add(token: TokenProvider, settings?: Partial<ProviderOpts>): this;
+    get<T extends Provider = Provider>(token: TokenProvider | undefined): T | undefined;
     /**
      * Get all providers registered in the injector container.
      *
      * @param type Filter the list by the given ProviderType.
      * @returns {[TokenProvider , Provider<any>][]}
      */
-    getProviders(type?: TokenProvider | ProviderType | string | string[]): Provider[];
-    addProviders(container: Map<TokenProvider, Provider>): void;
+    getMany(type?: TokenProvider | ProviderType | string | string[]): Provider[];
+    merge(container: Map<TokenProvider, Provider>): void;
 }

package/lib/types/common/domain/ContextLogger.d.ts

@@ -1,5 +1,5 @@
 import { DILogger } from "../../common/index.js";
-import { LogLevel } from "@tsed/logger";
+import type { LogLevel } from "@tsed/logger";
 import { Hooks } from "@tsed/hooks";
 /**
  * Options for creating a context logger instance.
@@ -40,8 +40,8 @@ export declare class ContextLogger {
     readonly id: string;
     maxStackSize: number;
     constructor({ id, logger, dateStart, level, maxStackSize, additionalProps }: ContextLoggerOptions);
-    set level(level: "debug" | "info" | "warn" | "error" | "off" | "all" | LogLevel);
     get level(): "debug" | "info" | "warn" | "error" | "off" | "all" | LogLevel;
+    set level(level: "debug" | "info" | "warn" | "error" | "off" | "all" | LogLevel);
     get hooks(): Hooks;
     private get stack();
     alterLog(cb: (data: any, level: "debug" | "info" | "warn" | "error" | "all", withRequest: boolean) => any): Hooks;

package/lib/types/common/interfaces/DIConfigurationOptions.d.ts

@@ -9,6 +9,11 @@ declare global {
             scopes: {
                 [key: string]: ProviderScope;
             };
+            /**
+             * Defer construction of synchronous singleton providers without lifecycle hooks until first use.
+             * @default false
+             */
+            lazyProviders?: boolean;
             /**
              * Define dependencies to build the provider
              */

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

@@ -30,39 +30,150 @@ import type { TokenRoute } from "../interfaces/TokenRoute.js";
 export declare class DIConfiguration {
     readonly default: Map<string, any>;
     protected map: Map<string, any>;
+    /**
+     * Creates a configuration service with the built-in defaults merged with the supplied initial properties.
+     *
+     * @param initialProps Initial configuration values that override built-in defaults.
+     */
     constructor(initialProps?: {});
+    /**
+     * Gets the application version.
+     */
     get version(): string;
+    /**
+     * Sets the application version.
+     *
+     * @param v Version to store in the configuration.
+     */
     set version(v: string);
+    /**
+     * Gets the application's root directory.
+     */
     get rootDir(): string;
+    /**
+     * Sets the application's root directory.
+     *
+     * @param value Root directory to store in the configuration.
+     */
     set rootDir(value: string);
+    /**
+     * Gets the active runtime environment.
+     */
     get env(): Env;
+    /**
+     * Sets the active runtime environment.
+     *
+     * @param value Environment to store in the configuration.
+     */
     set env(value: Env);
+    /**
+     * Gets the providers and modules imported by the application.
+     */
     get imports(): (TokenProvider | ImportTokenProviderOpts)[];
+    /**
+     * Sets the providers and modules imported by the application.
+     *
+     * @param imports Provider tokens or import options to configure.
+     */
     set imports(imports: (TokenProvider | ImportTokenProviderOpts)[]);
+    /**
+     * Indicates whether synchronous singleton providers without hooks are deferred until first use.
+     */
+    get lazyProviders(): boolean;
+    /**
+     * Enables or disables deferred initialization of synchronous singleton providers without hooks.
+     *
+     * @param lazyProviders Whether to defer eligible providers.
+     */
+    set lazyProviders(lazyProviders: boolean);
+    /**
+     * Gets the route providers registered by the application.
+     */
     get routes(): TokenRoute[];
+    /**
+     * Sets the route providers registered by the application.
+     *
+     * @param routes Route providers to configure.
+     */
     set routes(routes: TokenRoute[]);
+    /**
+     * Gets the logger options.
+     */
     get logger(): Partial<DILoggerOptions>;
+    /**
+     * Merges logger options into the current logger configuration.
+     *
+     * @param value Logger options to merge.
+     */
     set logger(value: Partial<DILoggerOptions>);
+    /**
+     * Indicates whether the logger is configured at the `debug` level.
+     */
     get debug(): boolean;
+    /**
+     * Enables or disables debug-level logging.
+     *
+     * @param debug `true` to set the logger level to `debug`; `false` to set it to `info`.
+     */
     set debug(debug: boolean);
+    /**
+     * Gets route providers grouped by mount path.
+     */
     get mount(): Record<string, TokenProvider[]>;
+    /**
+     * Sets route providers grouped by mount path.
+     *
+     * @param value Route providers indexed by mount path.
+     */
     set mount(value: Record<string, TokenProvider[]>);
     /**
+     * Invokes a callback once for each configured key, including default and overridden values.
      *
-     * @param callbackfn
-     * @param thisArg
+     * @param callbackfn Callback invoked with the resolved value, key, and override map.
+     * @param thisArg Value to use as `this` when invoking the callback.
      */
     forEach(callbackfn: (value: any, index: string, map: Map<string, any>) => void, thisArg?: any): void;
+    /**
+     * Sets one or more configuration values.
+     *
+     * Property names matching a configuration accessor are delegated to that accessor; other keys support nested paths.
+     *
+     * @param propertyKey Configuration key and value, or an object containing multiple values.
+     * @param value Value to assign when `propertyKey` is a string.
+     * @returns This configuration instance for chaining.
+     */
     set(obj: Partial<TsED.Configuration>): this;
     set(propertyKey: string, value?: unknown): this;
+    /**
+     * Sets a configuration value directly in the override map, supporting nested property paths.
+     *
+     * @param propertyKey Configuration key or nested property path.
+     * @param value Value to store.
+     * @returns This configuration instance for chaining.
+     */
     setRaw(propertyKey: string, value: any): this;
     /**
+     * Gets a resolved configuration value, preferring explicit overrides over default values.
      *
-     * @param propertyKey
-     * @param defaultValue
-     * @returns {undefined|any}
+     * @param propertyKey Configuration key or nested property path.
+     * @param defaultValue Value to return when neither the overrides nor defaults define the key.
+     * @returns The resolved configuration value.
      */
     get<T = any>(propertyKey: string, defaultValue?: T): T;
+    /**
+     * Defines a custom configuration member when a member with the same key does not already exist.
+     *
+     * @param key Name of the member to define.
+     * @param value Function or property descriptor to assign to the configuration prototype.
+     * @returns This configuration instance when the member already exists.
+     */
     decorate(key: string, value: ((...args: unknown[]) => unknown) | PropertyDescriptor): this | undefined;
+    /**
+     * Resolves a configuration value from overrides, defaults, or the supplied fallback in that order.
+     *
+     * @param propertyKey Configuration key or nested property path.
+     * @param defaultValue Value to return when no configured value exists.
+     * @returns The resolved configuration value.
+     */
     protected getRaw(propertyKey: string, defaultValue?: any): any;
 }

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

@@ -1,9 +1,11 @@
 import { Container } from "../domain/Container.js";
 import { DIConfiguration } from "./DIConfiguration.js";
 import type { DILogger } from "../interfaces/DILogger.js";
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
 import type { InvokeOptions } from "../interfaces/InvokeOptions.js";
 import { Provider } from "../domain/Provider.js";
 import type { TokenProvider } from "../interfaces/TokenProvider.js";
+import type { ProviderType } from "../domain/ProviderType.js";
 /**
  * Core dependency injection orchestrator managing provider lifecycle and resolution.
  *
@@ -28,13 +30,34 @@ import type { TokenProvider } from "../interfaces/TokenProvider.js";
  *
  * @public
  */
-export declare class InjectorService extends Container {
+export declare class InjectorService {
     #private;
     logger: DILogger;
     settings: DIConfiguration;
     private resolvedConfiguration;
     constructor();
+    get providers(): Pick<Container, "get" | "has" | "getMany">;
     isLoaded(): boolean;
+    add(token: TokenProvider, settings?: Partial<ProviderOpts>): this;
+    /**
+     * @alias InjectorService.add
+     */
+    addProvider(token: TokenProvider, settings?: Partial<ProviderOpts>): this;
+    setProvider(token: TokenProvider, provider: Provider): this;
+    /**
+     * Get a provider definition from the provider registry.
+     *
+     * Unlike `get()`, this method does not resolve the provider instance.
+     * @deprecated Since v8. Use injector().providers.get() instead
+     */
+    getProvider<T extends Provider = Provider>(token: TokenProvider | undefined): T | undefined;
+    /**
+     * Get provider definitions matching a type.
+     *
+     * Unlike `getMany()`, this method does not resolve provider instances.
+     * @deprecated Since v8. Use injector().providers.getMany() instead.
+     */
+    getProviders(type?: TokenProvider | ProviderType | string | string[]): Provider[];
     /**
      * Return a list of all instances built by the injector.
      *
@@ -237,6 +260,8 @@ export declare class InjectorService extends Container {
      * @private
      */
     protected invokeToken<T>(target: TokenProvider, options?: Partial<InvokeOptions>): T | Promise<T>;
+    private mergeProviders;
+    private invokeDependency;
     private resolveImportsProviders;
     /**
      * Create options to invoke a provider or class.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/di",
-  "version": "8.37.1",
+  "version": "8.38.0-beta.2",
   "description": "DI module for Ts.ED Framework",
   "source": "./src/index.ts",
   "type": "module",
@@ -29,11 +29,11 @@
     "uuid": "^14.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.37.1",
-    "@tsed/core": "8.37.1",
-    "@tsed/hooks": "8.37.1",
+    "@tsed/barrels": "8.38.0-beta.2",
+    "@tsed/core": "8.38.0-beta.2",
+    "@tsed/hooks": "8.38.0-beta.2",
     "@tsed/logger": "^8.0.0",
-    "@tsed/typescript": "8.37.1",
+    "@tsed/typescript": "8.38.0-beta.2",
     "cross-env": "7.0.3",
     "typescript": "6.0.2",
     "vite": "7.3.2",
@@ -61,5 +61,8 @@
   },
   "homepage": "https://github.com/tsedio/tsed/tree/production/packages/di",
   "author": "Romain Lenzotti",
-  "license": "MIT"
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "beta"
+  }
 }