Provider

@tsed/di

Usage

import { Provider } from "@tsed/di";

See /packages/di/src/common/domain/Provider.ts.

Overview

class Provider<T = any> implements ProviderOpts<T> {
    static readonly Registry: Map<any, Provider<any>>;
    type: ProviderType | TokenProvider;
    deps: TokenProvider[];
    imports: (TokenProvider | [TokenProvider])[];
    alias: string;
    priority: number;
    useFactory?: Function;
    useAsyncFactory?: Function;
    useValue?: unknown;
    hooks: Record<string, ProviderHookCallback<T>>;
    tokenRouter: string;
    [key: string]: any;
    constructor(token: TokenProvider<T>, options?: Partial<Provider>);
    get token(): TokenProvider;
    set token(value: TokenProvider);
    get provide(): TokenProvider;
    set provide(value: TokenProvider);
    get useClass(): Type<T>;
    set useClass(value: Type<T> | AbstractType<T>);
    get className(): string;
    get name(): string;
    get store(): Store;
    get path(): string;
    set path(path: string);
    get scope(): ProviderScope;
    set scope(scope: ProviderScope);
    get configuration(): Partial<TsED.Configuration>;
    set configuration(configuration: Partial<TsED.Configuration>);
    get children(): TokenProvider[];
    set children(children: TokenProvider[]);
    get middlewares(): Partial<ControllerMiddlewares>;
    set middlewares(middlewares: Partial<ControllerMiddlewares>);
    getArgOpts(index: number): any;
    get<Type = unknown>(key: string): Type | undefined;
    get<Type = unknown>(key: string, defaultValue: Type): Type;
    isAsync(): boolean;
    clone(): Provider;
    hasChildren(): boolean;
    hasParent(): boolean;
    toString(): string;
    reset(): this;
}

Description

Provider metadata class managing dependency injection configuration.

Encapsulates all information needed to create, configure, and manage a provider instance within the DI container. Tracks dependencies, lifecycle hooks, creation strategies, and metadata.

Usage

import {Provider, ProviderType} from "@tsed/di";

const provider = new Provider(MyService);
provider.type = ProviderType.PROVIDER;
provider.deps = [DatabaseService, LoggerService];

Constructor

constructor(token: TokenProvider<T>, options?: Partial<Provider>);

Creates a new Provider instance

static readonly Registry

static readonly Registry: Map<any, Provider<any>>;

Global registry for storing all providers in the dependency injection system. Maps provider tokens to their Provider instances.

type

type: ProviderType | TokenProvider;

Token group provider to retrieve all providers from the same type

deps

deps: TokenProvider[];

Array of token providers that this provider depends on

imports:

imports: (TokenProvider | [TokenProvider])[];

Array of providers or provider arrays to be imported

alias

alias: string;

Alternative name/alias for this provider

priority

priority: number;

Priority value affecting the order of provider initialization

useFactory

useFactory?: Function;

Optional factory function to create provider instances

useAsyncFactory

useAsyncFactory?: Function;

Optional async factory function to create provider instances

useValue

useValue?: unknown;

Optional static value to use instead of creating instances

hooks

hooks: Record<string, ProviderHookCallback<T>>;

Map of lifecycle hook callbacks for this provider

tokenRouter

tokenRouter: string;

Router token for routing-related providers

[key: string]

[key: string]: any;

get token

get token(): TokenProvider;

Get the provider's token

set token

set token(value: TokenProvider);

Set the provider's token and initialize stores

get provide

get provide(): TokenProvider;

set provide

set provide(value: TokenProvider);

get useClass

get useClass(): Type<T>;

Gets the class type used to instantiate this provider

set useClass

set useClass(value: Type<T> | AbstractType<T>);

Sets the class type and initializes store/hooks for this provider

get className

get className(): string;

get name

get name(): string;

get store

get store(): Store;

get path

get path(): string;

set path

set path(path: string);

get scope

get scope(): ProviderScope;

Get the scope of the provider.

Note

Async provider is always a SINGLETON

set scope

set scope(scope: ProviderScope);

Change the scope value of the provider.

get configuration

get configuration(): Partial<TsED.Configuration>;

Gets the provider configuration settings

set configuration

set configuration(configuration: Partial<TsED.Configuration>);

Sets the provider configuration settings

get children

get children(): TokenProvider[];

set children

set children(children: TokenProvider[]);

get middlewares

get middlewares(): Partial<ControllerMiddlewares>;

Gets the configured middleware stack for this provider

set middlewares

set middlewares(middlewares: Partial<ControllerMiddlewares>);

Sets middleware configuration, merging with existing middlewares

getArgOpts

getArgOpts(index: number): any;

get

get<Type = unknown>(key: string): Type | undefined;

• key (string): The key to look up

Retrieves a value from the provider's store.

get

get<Type = unknown>(key: string, defaultValue: Type): Type;

• key (string): The key to look up

• defaultValue (Type): The value to return if key is not found

Retrieves a value from the provider's store with a default fallback.

isAsync

isAsync(): boolean;

clone

clone(): Provider;

hasChildren

hasChildren(): boolean;

Checks if this provider has any child controllers

hasParent

hasParent(): boolean;

Checks if this provider has a parent controller

toString

toString(): string;

Returns a string representation of this provider

reset

reset(): this;

Resets the provider's factory configuration Clears useValue, useFactory and useAsyncFactory