@tsed/di 8.19.5 → 8.20.0

package/lib/esm/common/decorators/controller.js

@@ -66,7 +66,7 @@ export function Controller(options) {
         if (path) {
             factory.store().set("path", path);
         }
-        factory.store().set("childrenControllers", children);
+        factory.children(children);
         children.forEach((childToken) => {
             Store.from(childToken).set("parentController", classOf(target));
         });

package/lib/esm/common/decorators/overrideProvider.js

@@ -1,4 +1,5 @@
-import { GlobalProviders } from "../registries/GlobalProviders.js";
+import { nameOf } from "@tsed/core";
+import { Provider } from "../domain/Provider.js";
 /**
  * Override an existing provider registration with a new implementation.
  *
@@ -41,6 +42,13 @@ import { GlobalProviders } from "../registries/GlobalProviders.js";
  */
 export function OverrideProvider(originalProvider) {
     return (target) => {
-        GlobalProviders.get(originalProvider).useClass = target;
+        const provider = Provider.Registry.get(originalProvider);
+        if (provider) {
+            provider.useClass = target;
+        }
+        else {
+            throw new Error(`Cannot override provider ${nameOf(originalProvider)}: Provider not found in registry. ` +
+                `Ensure the original provider is decorated with @Injectable() or registered before applying @OverrideProvider.`);
+        }
     };
 }

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

@@ -1,4 +1,3 @@
-import { GlobalProviders } from "../registries/GlobalProviders.js";
 import { Provider } from "./Provider.js";
 /**
  * Provider container managing registered providers and their metadata.
@@ -27,7 +26,7 @@ export class Container extends Map {
      * @param settings
      */
     add(token, settings = {}) {
-        const provider = GlobalProviders.get(token)?.clone() || new Provider(token);
+        const provider = Provider.Registry.get(token)?.clone() || new Provider(token);
         Object.assign(provider, settings);
         return super.set(token, provider);
     }

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

@@ -1,5 +1,4 @@
 import { Provider } from "./Provider.js";
-import { ProviderType } from "./ProviderType.js";
 /**
  * Specialized provider for HTTP controllers.
  *
@@ -21,33 +20,6 @@ import { ProviderType } from "./ProviderType.js";
  *
  * @typeParam T - The type of controller class
  * @public
+ * @deprecated Use Provider instead.
  */
-export class ControllerProvider extends Provider {
-    constructor(token, options = {}) {
-        super(token, options);
-        this.type = ProviderType.CONTROLLER;
-    }
-    /**
-     *
-     * @returns {any[]}
-     */
-    get middlewares() {
-        return Object.assign({
-            use: [],
-            useAfter: [],
-            useBefore: []
-        }, this.store.get("middlewares", {}));
-    }
-    /**
-     *
-     * @param middlewares
-     */
-    set middlewares(middlewares) {
-        const mdlwrs = this.middlewares;
-        const concat = (key, a, b) => (a[key] = a[key].concat(b[key]));
-        Object.keys(middlewares).forEach((key) => {
-            concat(key, mdlwrs, middlewares);
-        });
-        this.store.set("middlewares", mdlwrs);
-    }
-}
+export const ControllerProvider = Provider;

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

@@ -27,15 +27,40 @@ import { ProviderType } from "./ProviderType.js";
  * @public
  */
 export class Provider {
+    /**
+     * Global registry for storing all providers in the dependency injection system.
+     * Maps provider tokens to their Provider instances.
+     */
+    static { this.Registry = new Map(); }
+    /**
+     * The class type used to instantiate this provider
+     */
     #useClass;
+    /**
+     * The token used to identify this provider
+     */
     #token;
+    /**
+     * Store instance for provider metadata
+     */
     #store;
+    /**
+     * Store instance for token-specific metadata
+     */
     #tokenStore;
+    /**
+     * Creates a new Provider instance
+     * @param token - The token used to identify this provider
+     * @param options - Optional configuration options for the provider
+     */
     constructor(token, options = {}) {
         /**
-         * Token group provider to retrieve all provider from the same type
+         * Token group provider to retrieve all providers from the same type
          */
         this.type = ProviderType.PROVIDER;
+        /**
+         * Map of lifecycle hook callbacks for this provider
+         */
         this.hooks = {};
         this.token = token;
         this.useClass = token;
@@ -46,9 +71,16 @@ export class Provider {
             this.#tokenStore = options.#tokenStore;
         }
     }
+    /**
+     * Get the provider's token
+     */
     get token() {
         return this.#token;
     }
+    /**
+     * Set the provider's token and initialize stores
+     * @param value - The token to set
+     */
     set token(value) {
         if (value) {
             this.#token = getClassOrSymbol(value);
@@ -68,12 +100,15 @@ export class Provider {
     set provide(value) {
         this.token = value;
     }
+    /**
+     * Gets the class type used to instantiate this provider
+     */
     get useClass() {
         return this.#useClass;
     }
     /**
-     * Create a new store if the given value is a class. Otherwise, the value is ignored.
-     * @param value
+     * Sets the class type and initializes store/hooks for this provider
+     * @param value - The class type to use for instantiation
      */
     set useClass(value) {
         if (isClass(value)) {
@@ -119,9 +154,16 @@ export class Provider {
     set scope(scope) {
         this.store.set("scope", scope);
     }
+    /**
+     * Gets the provider configuration settings
+     */
     get configuration() {
         return this.get("configuration");
     }
+    /**
+     * Sets the provider configuration settings
+     * @param configuration - The configuration object to set
+     */
     set configuration(configuration) {
         this.store.set("configuration", configuration);
     }
@@ -131,6 +173,28 @@ export class Provider {
     set children(children) {
         this.store.set("childrenControllers", children);
     }
+    /**
+     * Gets the configured middleware stack for this provider
+     */
+    get middlewares() {
+        return Object.assign({
+            use: [],
+            useAfter: [],
+            useBefore: []
+        }, this.store.get("middlewares", {}));
+    }
+    /**
+     * Sets middleware configuration, merging with existing middlewares
+     * @param middlewares - The middleware configuration to apply
+     */
+    set middlewares(middlewares) {
+        const mdlwrs = this.middlewares;
+        const concat = (key, a, b) => (a[key] = a[key].concat(b[key]));
+        Object.keys(middlewares).forEach((key) => {
+            concat(key, mdlwrs, middlewares);
+        });
+        this.store.set("middlewares", mdlwrs);
+    }
     getArgOpts(index) {
         return this.store.get(`${DI_USE_PARAM_OPTIONS}:${index}`);
     }
@@ -144,19 +208,23 @@ export class Provider {
         return new (classOf(this))(this.token, this);
     }
     /**
-     *
-     * @returns {boolean}
+     * Checks if this provider has any child controllers
+     * @returns True if provider has children, false otherwise
      */
     hasChildren() {
         return !!this.children.length;
     }
     /**
-     *
-     * @returns {boolean}
+     * Checks if this provider has a parent controller
+     * @returns True if provider has a parent, false otherwise
      */
     hasParent() {
         return !!this.store.get("parentController");
     }
+    /**
+     * Returns a string representation of this provider
+     * @returns A string containing the provider's token, class and factory information
+     */
     toString() {
         return [
             "Token",
@@ -169,6 +237,11 @@ export class Provider {
             .filter(Boolean)
             .join(":");
     }
+    /**
+     * Resets the provider's factory configuration
+     * Clears useValue, useFactory and useAsyncFactory
+     * @returns This provider instance
+     */
     reset() {
         this.useValue = undefined;
         this.useFactory = undefined;

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

@@ -0,0 +1,213 @@
+import { Provider } from "../domain/Provider.js";
+import { ProviderType } from "../domain/ProviderType.js";
+import { injector } from "../fn/injector.js";
+export class ProviderBuilder {
+    /**
+     * Creates a new Provider Builder instance
+     * @param options - Provider options including token and configuration
+     */
+    constructor(options) {
+        options.global ||= !injector().isLoaded();
+        let provider = Provider.Registry.get(options.token);
+        if (!provider) {
+            provider = new Provider(options.token, options);
+            options.global && Provider.Registry.set(options.token, provider);
+        }
+        else {
+            Object.keys(options).forEach((key) => {
+                provider[key] = options[key];
+            });
+        }
+        if (!options.global) {
+            injector().setProvider(options.token, provider);
+        }
+        this.provider = provider;
+    }
+    static add(property, method) {
+        Object.defineProperty(ProviderBuilder.prototype, property, {
+            value: method
+        });
+        return ProviderBuilder;
+    }
+    /**
+     * Sets the provider scope
+     * @param scope - The scope to set for this provider
+     * @returns Current builder instance
+     */
+    scope(scope) {
+        this.provider.scope = scope;
+        return this;
+    }
+    /**
+     * Sets the provider path
+     * @param path - The path to set for this provider
+     * @returns Current builder instance
+     */
+    path(path) {
+        this.provider.path = path;
+        return this;
+    }
+    /**
+     * Sets the provider alias
+     * @param alias - The alias to set for this provider
+     * @returns Current builder instance
+     */
+    alias(alias) {
+        this.provider.alias = alias;
+        return this;
+    }
+    /**
+     * Sets the provider hooks
+     * @param hooks - The hooks to set for this provider
+     * @returns Current builder instance
+     */
+    hooks(hooks) {
+        this.provider.hooks = hooks;
+        return this;
+    }
+    /**
+     * Sets the provider dependencies
+     * @param deps - The dependencies to set for this provider
+     * @returns Current builder instance
+     */
+    deps(deps) {
+        this.provider.deps = deps;
+        return this;
+    }
+    /**
+     * Sets the provider imports
+     * @param imports - The imports to set for this provider
+     * @returns Current builder instance
+     */
+    imports(imports) {
+        this.provider.imports = imports;
+        return this;
+    }
+    /**
+     * Sets the provider configuration
+     * @param configuration - The configuration to set for this provider
+     * @returns Current builder instance
+     */
+    configuration(configuration) {
+        this.provider.configuration = configuration;
+        return this;
+    }
+    /**
+     * Sets the provider priority
+     * @param priority - The priority to set for this provider
+     * @returns Current builder instance
+     */
+    priority(priority) {
+        this.provider.priority = priority;
+        return this;
+    }
+    /**
+     * Sets the provider type
+     * @param type - The type to set for this provider
+     * @returns Current builder instance
+     */
+    type(type) {
+        this.provider.type = type;
+        return this;
+    }
+    /**
+     * Sets the provider children
+     * @param children - The children to set for this provider
+     * @returns Current builder instance
+     */
+    children(children) {
+        this.provider.children = children;
+        return this;
+    }
+    /**
+     * Sets the provider middlewares
+     * @param middlewares - The middlewares to set for this provider
+     * @returns Current builder instance
+     */
+    middlewares(middlewares) {
+        this.provider.middlewares = middlewares;
+        return this;
+    }
+    /**
+     * Sets a factory function for the provider
+     * @param factory - Factory function that creates provider instances
+     * @returns Builder instance with updated factory type
+     */
+    factory(factory) {
+        this.provider.reset();
+        this.provider.useFactory = factory;
+        return this;
+    }
+    /**
+     * Sets an async factory function for the provider
+     * @param asyncFactory - Async factory function that creates provider instances
+     * @returns Builder instance with updated factory type
+     */
+    asyncFactory(asyncFactory) {
+        this.provider.reset();
+        this.provider.useAsyncFactory = asyncFactory;
+        return this;
+    }
+    /**
+     * Sets a static value for the provider
+     * @param value - Value to be provided
+     * @returns Builder instance with value type
+     */
+    value(value) {
+        this.provider.reset();
+        this.provider.useValue = value;
+        this.provider.type = ProviderType.VALUE;
+        return this;
+    }
+    /**
+     * Sets the class to be used by the provider
+     * @param k - Class type to be provided
+     * @returns Builder instance with class type
+     */
+    class(k) {
+        this.provider.reset();
+        this.provider.useClass = k;
+        return this;
+    }
+    /**
+     * Gets the provider's store
+     * @returns Provider store instance
+     */
+    store() {
+        return this.provider.store;
+    }
+    /**
+     * Gets the underlying provider instance
+     * @returns Provider instance
+     */
+    inspect() {
+        return this.provider;
+    }
+    /**
+     * Gets the provider's token
+     * @returns Provider token
+     */
+    token() {
+        return this.provider.token;
+    }
+    /**
+     * Sets a value in the provider's store
+     * @param key - Key to store the value under
+     * @param value - Value to store
+     * @returns Current builder instance
+     */
+    set(key, value) {
+        this.store().set(key, value);
+        return this;
+    }
+}
+export function providerBuilder(baseOpts = {}) {
+    function factory(token, options = {}) {
+        return new ProviderBuilder({
+            token,
+            ...baseOpts,
+            ...options
+        });
+    }
+    return factory;
+}

package/lib/esm/common/extends/intercept.js

@@ -0,0 +1,7 @@
+import { classOf } from "@tsed/core";
+import { bindIntercept } from "../decorators/intercept.js";
+import { ProviderBuilder } from "../domain/ProviderBuilder.js";
+ProviderBuilder.add("intercept", function intercept(propertyKey, interceptorToken, options) {
+    bindIntercept(classOf(this.inspect().useClass), propertyKey, interceptorToken, options);
+    return this;
+});

package/lib/esm/common/fn/injectable.js

@@ -1,6 +1,5 @@
+import { providerBuilder } from "../domain/ProviderBuilder.js";
 import { ProviderType } from "../domain/ProviderType.js";
-import { providerBuilder } from "../utils/providerBuilder.js";
-const Props = ["type", "scope", "path", "alias", "hooks", "deps", "imports", "configuration", "priority"];
 /**
  * Fluent builder for registering providers programmatically.
  *
@@ -25,7 +24,7 @@ const Props = ["type", "scope", "path", "alias", "hooks", "deps", "imports", "co
  *
  * @public
  */
-export const injectable = providerBuilder(Props);
+export const injectable = providerBuilder({ type: ProviderType.PROVIDER });
 /**
  * Fluent builder for registering interceptor providers.
  *
@@ -41,7 +40,7 @@ export const injectable = providerBuilder(Props);
  *
  * @public
  */
-export const interceptor = providerBuilder(Props, {
+export const interceptor = providerBuilder({
     type: ProviderType.INTERCEPTOR
 });
 /**
@@ -62,6 +61,16 @@ export const interceptor = providerBuilder(Props, {
  *
  * @public
  */
-export const controller = providerBuilder([...Props, "middlewares"], {
+export const controller = providerBuilder({
     type: ProviderType.CONTROLLER
 });
+/**
+ * Register a provider configuration.
+ * @deprecated Since v8. Use injectable() function instead.
+ */
+export function registerProvider({ token, provide, ...opts }) {
+    return injectable(token || provide, {
+        ...opts,
+        token: token || provide
+    }).inspect();
+}

package/lib/esm/common/index.js

@@ -25,10 +25,12 @@ export * from "./domain/DIContext.js";
 export * from "./domain/InjectablePropertyType.js";
 export * from "./domain/LocalsContainer.js";
 export * from "./domain/Provider.js";
+export * from "./domain/ProviderBuilder.js";
 export * from "./domain/ProviderScope.js";
 export * from "./domain/ProviderType.js";
 export * from "./errors/InjectionError.js";
 export * from "./errors/InvalidPropertyTokenError.js";
+export * from "./extends/intercept.js";
 export * from "./fn/configuration.js";
 export * from "./fn/constant.js";
 export * from "./fn/inject.js";
@@ -55,7 +57,6 @@ export * from "./interfaces/ResolvedInvokeOptions.js";
 export * from "./interfaces/TokenProvider.js";
 export * from "./interfaces/TokenRoute.js";
 export * from "./registries/GlobalProviders.js";
-export * from "./registries/ProviderRegistry.js";
 export * from "./services/DIConfiguration.js";
 export * from "./services/DILogger.js";
 export * from "./services/InjectorService.js";
@@ -65,7 +66,6 @@ export * from "./utils/createContainer.js";
 export * from "./utils/discoverHooks.js";
 export * from "./utils/getConfiguration.js";
 export * from "./utils/getConstructorDependencies.js";
-export * from "./utils/providerBuilder.js";
 export * from "./utils/setLoggerConfiguration.js";
 export * from "./utils/setLoggerFormat.js";
 export * from "./utils/setLoggerLevel.js";

package/lib/esm/common/registries/GlobalProviders.js

@@ -1,102 +1,8 @@
-import { getClassOrSymbol } from "@tsed/core/utils/getClassOrSymbol.js";
 import { Provider } from "../domain/Provider.js";
-import { ProviderType } from "../domain/ProviderType.js";
-export class GlobalProviderRegistry extends Map {
-    #settings = new Map();
-    /**
-     * The get() method returns a specified element from a Map object.
-     * @param key Required. The key of the element to return from the 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.
-     */
-    get(key) {
-        return super.get(getClassOrSymbol(key));
-    }
-    /**
-     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
-     * @param key
-     * @returns {boolean}
-     */
-    has(key) {
-        return super.has(getClassOrSymbol(key));
-    }
-    /**
-     * The set() method adds or updates an element with a specified key and value to a Map object.
-     * @param key Required. The key of the element to add to the Map object.
-     * @param metadata Required. The value of the element to add to the Map object.
-     */
-    set(key, metadata) {
-        super.set(getClassOrSymbol(key), metadata);
-        return this;
-    }
-    /**
-     *
-     * @param target
-     * @param options
-     */
-    merge(target, options) {
-        if (options.global === false) {
-            return GlobalProviders.createProvider(target, options);
-        }
-        const meta = this.createIfNotExists(target, options);
-        Object.keys(options).forEach((key) => {
-            meta[key] = options[key];
-        });
-        this.set(target, meta);
-        return meta;
-    }
-    /**
-     * The delete() method removes the specified element from a Map object.
-     * @param key Required. The key of the element to remove from the Map object.
-     * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
-     */
-    delete(key) {
-        return super.delete(getClassOrSymbol(key));
-    }
-    createRegistry(type, model, options = {}) {
-        const defaultOptions = this.getRegistrySettings(type);
-        options = Object.assign(defaultOptions, {
-            ...options,
-            model
-        });
-        this.#settings.set(type, options);
-        return this;
-    }
-    getRegistrySettings(target) {
-        let type = ProviderType.PROVIDER;
-        if (typeof target === "string") {
-            type = target;
-        }
-        else {
-            const provider = this.get(target);
-            if (provider) {
-                type = provider.type;
-            }
-        }
-        return (this.#settings.get(type) || {
-            model: Provider
-        });
-    }
-    createProvider(key, options) {
-        const type = options.type || ProviderType.PROVIDER;
-        const { model = Provider } = this.#settings.get(type) || {};
-        return new model(key, options);
-    }
-    /**
-     *
-     * @param key
-     * @param options
-     */
-    createIfNotExists(key, options) {
-        if (!this.has(key)) {
-            const item = this.createProvider(key, options);
-            this.set(key, item);
-        }
-        return this.get(key);
-    }
-}
 /**
- *
- * @type {GlobalProviders}
+ * Registry for managing global providers in the dependency injection system.
+ * Extends the Map class to store TokenProvider-Provider pairs.
+ * @deprecated Use Provider.Registry instead
  */
 // tslint:disable-next-line: variable-name
-export const GlobalProviders = new GlobalProviderRegistry();
+export const GlobalProviders = Provider.Registry;

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

@@ -15,7 +15,6 @@ import { LocalsContainer } from "../domain/LocalsContainer.js";
 import { Provider } from "../domain/Provider.js";
 import { ProviderScope } from "../domain/ProviderScope.js";
 import { InjectionError } from "../errors/InjectionError.js";
-import { GlobalProviders } from "../registries/GlobalProviders.js";
 import { createContainer } from "../utils/createContainer.js";
 import { getConstructorDependencies } from "../utils/getConstructorDependencies.js";
 import { DIConfiguration } from "./DIConfiguration.js";
@@ -361,7 +360,7 @@ export class InjectorService extends Container {
         return this;
     }
     ensureProvider(token, force = false) {
-        if (!this.hasProvider(token) && (GlobalProviders.has(token) || force)) {
+        if (!this.hasProvider(token) && (Provider.Registry.has(token) || force)) {
             this.addProvider(token);
         }
         return this.getProvider(token);
@@ -534,7 +533,7 @@ export class InjectorService extends Container {
     setToCache(provider, instance) {
         const set = (instance) => {
             this.#cache.set(provider.token, instance);
-            provider?.alias && this.alias(provider.token, provider.alias);
+            provider.alias && this.alias(provider.token, provider.alias);
         };
         if ("isAsync" in provider && !provider.isAsync() && !isPromise(instance)) {
             set(instance);

package/lib/esm/common/utils/createContainer.js

@@ -1,7 +1,7 @@
 import { Container } from "../domain/Container.js";
-import { GlobalProviders } from "../registries/GlobalProviders.js";
+import { Provider } from "../domain/Provider.js";
 export function createContainer(rootModule) {
-    const container = new Container(GlobalProviders.entries());
+    const container = new Container(Provider.Registry.entries());
     if (rootModule) {
         container.delete(rootModule);
     }