@tsed/di 7.79.4 → 7.80.1

package/lib/types-esm/common/constants/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const INJECTABLE_PROP = "DI:INJECTABLE_PROP";
+export declare const DI_PARAMS = "DI:PARAMS";
+export declare const DI_PARAM_OPTIONS = "DI:PARAM:OPTIONS";

package/lib/types-esm/common/decorators/configuration.d.ts

@@ -0,0 +1,8 @@
+import { DIConfiguration } from "../services/DIConfiguration.js";
+/**
+ * Get or set Configuration on a class.
+ *
+ * @decorator
+ */
+export declare function Configuration(configuration?: Partial<TsED.Configuration>): Function;
+export type Configuration = TsED.Configuration & DIConfiguration;

package/lib/types-esm/common/decorators/constant.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Return value from Configuration.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * import {Env} from "@tsed/core";
+ * import {Constant, Value} from "@tsed/di";
+ *
+ * export class MyClass {
+ *
+ *    @Constant("env")
+ *    env: Env;
+ *
+ *    @Value("swagger.path")
+ *    swaggerPath: string;
+ *
+ *    @Value("swagger.path", "defaultValue")
+ *    swaggerPath: string;
+ *
+ *    constructor() {
+ *       console.log(this.swaggerPath) // undefined. Not available on constructor
+ *    }
+ *
+ *    $onInit() {
+ *      console.log(this.swaggerPath)  // something
+ *    }
+ * }
+ * ```
+ *
+ * @param {string} expression
+ * @param defaultValue
+ * @returns {(targetClass: any, attributeName: string) => any}
+ * @decorator
+ */
+export declare function Constant(expression: string, defaultValue?: any): any;

package/lib/types-esm/common/decorators/controller.d.ts

@@ -0,0 +1,42 @@
+import { Type } from "@tsed/core";
+import { ProviderOpts } from "../interfaces/ProviderOpts.js";
+export type PathType = string | RegExp | (string | RegExp)[];
+export interface ControllerMiddlewares {
+    useBefore: any[];
+    use: any[];
+    useAfter: any[];
+}
+export interface ControllerOptions extends Partial<ProviderOpts<any>> {
+    path?: PathType;
+    children?: Type<any>[];
+    middlewares?: Partial<ControllerMiddlewares>;
+}
+/**
+ * Declare a new controller with his Rest path. His methods annotated will be collected to build the routing list.
+ * This routing listing will be built with the `express.Router` object.
+ *
+ * ::: tip
+ * See [Controllers](/docs/controllers.md) section for more details
+ * :::
+ *
+ * ```typescript
+ *  @Controller("/calendars")
+ *  export provide CalendarCtrl {
+ *
+ *    @Get("/:id")
+ *    public get(
+ *      @Req() request: Req,
+ *      @Res() response: Res,
+ *      @Next() next: Next
+ *    ): void {
+ *
+ *    }
+ *  }
+ * ```
+ *
+ * @param options
+ * @controller
+ * @decorator
+ * @classDecorator
+ */
+export declare function Controller(options: PathType | ControllerOptions): ClassDecorator;

package/lib/types-esm/common/decorators/inject.d.ts

@@ -0,0 +1,22 @@
+import type { InjectablePropertyOptions } from "../interfaces/InjectableProperties.js";
+import { TokenProvider } from "../interfaces/TokenProvider.js";
+export declare function injectProperty(target: any, propertyKey: string, options: Partial<InjectablePropertyOptions>): void;
+/**
+ * Inject a provider to another provider.
+ *
+ * Use this decorator to inject a custom provider on constructor parameter or property.
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   @Inject(CONNECTION)
+ *   connection: CONNECTION;
+ * }
+ * ```
+ *
+ * @param token A token provider or token provider group
+ * @param onGet Use the given name method to inject
+ * @returns {Function}
+ * @decorator
+ */
+export declare function Inject(token?: TokenProvider | (() => TokenProvider), onGet?: (bean: any) => any): Function;

package/lib/types-esm/common/decorators/injectable.d.ts

@@ -0,0 +1,20 @@
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+/**
+ * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
+ * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
+ *
+ * ::: tip
+ * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
+ * :::
+ *
+ * ### Options
+ *
+ * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
+ * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
+ * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
+ * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export declare function Injectable(options?: Partial<ProviderOpts>): ClassDecorator;

package/lib/types-esm/common/decorators/intercept.d.ts

@@ -0,0 +1,10 @@
+import { Type } from "@tsed/core";
+import type { InterceptorMethods } from "../interfaces/InterceptorMethods.js";
+/**
+ * Attaches interceptor to method call and executes the before and after methods
+ *
+ * @param interceptor
+ * @param options
+ * @decorator
+ */
+export declare function Intercept<T extends InterceptorMethods>(interceptor: Type<T>, options?: any): any;

package/lib/types-esm/common/decorators/interceptor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The decorators `@Service()` declare a new service can be injected in other service or controller on there `constructor`.
+ * All services annotated with `@Service()` are constructed one time.
+ *
+ * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export declare function Interceptor(): Function;

package/lib/types-esm/common/decorators/lazyInject.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Lazy load a provider from his package and invoke only when the provider is used
+ *
+ * ```typescript
+ * import type {PlatformException} from "@tsed/platform-exceptions";
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @LazyInject("PlatformException", () => import("@tsed/platform-exceptions"))
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param key
+ * @param packageName
+ * @param resolver
+ * @param optional
+ * @returns {Function}
+ * @decorator
+ */
+export declare function LazyInject(key: string, resolver: () => any, { optional, packageName }?: {
+    optional?: boolean;
+    packageName?: string;
+}): PropertyDecorator;
+/**
+ * Optionally Lazy load a provider from his package and invoke only when the provider is used
+ *
+ * ```typescript
+ * import type {PlatformException} from "@tsed/platform-exceptions";
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @OptionalLazyInject("@tsed/platform-exceptions")
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param key
+ * @param resolver
+ * @returns {Function}
+ * @decorator
+ */
+export declare function OptionalLazyInject(key: string, resolver: () => any): PropertyDecorator;

package/lib/types-esm/common/decorators/module.d.ts

@@ -0,0 +1,37 @@
+import { ProviderScope } from "../domain/ProviderScope.js";
+import { TokenProvider } from "../interfaces/TokenProvider.js";
+import { DIResolver } from "../interfaces/DIResolver.js";
+export interface ModuleOptions extends Omit<TsED.Configuration, "scopes"> {
+    /**
+     * Provider scope
+     */
+    scope?: ProviderScope;
+    /**
+     * Providers must be initialized before building this module
+     */
+    imports?: TokenProvider[];
+    /**
+     * Explicit token must be injected in the constructor
+     */
+    deps?: TokenProvider[];
+    /**
+     * A list of resolvers to inject provider from external DI.
+     */
+    resolvers?: DIResolver[];
+    /**
+     * Additional properties are stored as provider configuration.
+     */
+    [key: string]: any;
+}
+/**
+ * Declare a new Ts.ED module
+ *
+ * ## Options
+ * - imports: List of Provider which must be built by injector before invoking the module
+ * - resolvers: List of external DI must be used to resolve unknown provider
+ * - deps: List of provider must be injected to the module constructor (explicit declaration)
+ *
+ * @param options
+ * @decorator
+ */
+export declare function Module(options?: Partial<ModuleOptions>): any;

package/lib/types-esm/common/decorators/opts.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Get instance options. This options depending on his invocation context.
+ *
+ * ```typescript
+ * import {Injectable, Opts, UseOpts} from "@tsed/di";
+ *
+ * @Injectable()
+ * class MyConfigurableService {
+ *   source: string;
+ *   constructor(@Opts options: any = {}) {
+ *      console.log("Hello ", options.source); // log: Hello Service1 then Hello Service2
+ *
+ *      this.source = options.source;
+ *   }
+ * }
+ *
+ * @Injectable()
+ * class MyService1 {
+ *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {
+ *     console.log(service.source) // log: Service1
+ *   }
+ * }
+ *
+ * @Injectable()
+ * class MyService2 {
+ *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {
+ *     console.log(service.source) // log: Service2
+ *   }
+ * }
+ * ```
+ *
+ * ::: warning
+ * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.
+ * :::
+ *
+ * @param target
+ * @param propertyKey
+ * @param index
+ * @decorator
+ */
+export declare function Opts(target: any, propertyKey: string | symbol | undefined, index: number): void;

package/lib/types-esm/common/decorators/overrideProvider.d.ts

@@ -0,0 +1,8 @@
+import { Type } from "@tsed/core";
+/**
+ * Override a provider which is already registered in ProviderRegistry.
+ * @returns {Function}
+ * @decorators
+ * @param originalProvider
+ */
+export declare function OverrideProvider(originalProvider: Type<any>): Function;

package/lib/types-esm/common/decorators/scope.d.ts

@@ -0,0 +1,8 @@
+import { ProviderScope } from "../domain/ProviderScope.js";
+/**
+ *
+ * @param {"request" | "singleton" | ProviderScope} scope
+ * @returns {Function}
+ * @constructor
+ */
+export declare function Scope(scope?: "request" | "singleton" | ProviderScope): Function;

package/lib/types-esm/common/decorators/service.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The decorators `@Service()` declare a new service can be injected in other service or controller on there `constructor`.
+ * All services annotated with `@Service()` are constructed one time.
+ *
+ * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export declare function Service(): Function;

package/lib/types-esm/common/decorators/useOpts.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Add options to invoke the Service.
+ *
+ * ```typescript
+ * import {Injectable, Opts, UseOpts} from "@tsed/di";
+ *
+ * @Injectable()
+ * class MyConfigurableService {
+ *   source: string;
+ *   constructor(@Opts options: any = {}) {
+ *      console.log("Hello ", options.source); // log: Hello Service1 then Hello Service2
+ *
+ *      this.source = options.source;
+ *   }
+ * }
+ *
+ * @Injectable()
+ * class MyService1 {
+ *   constructor(@UseOpts({source: 'Service1'}) service: MyConfigurableService) {
+ *     console.log(service.source) // log: Service1
+ *   }
+ * }
+ *
+ * @Injectable()
+ * class MyService2 {
+ *   constructor(@UseOpts({source: 'Service2'}) service: MyConfigurableService) {
+ *     console.log(service.source) // log: Service2
+ *   }
+ * }
+ * ```
+ *
+ * ::: warning
+ * Using @@Opts@@ decorator on a constructor parameter change the Scope of the provider to `ProviderScope.INSTANCE`.
+ * :::
+ *
+ * @returns {Function}
+ * @decorator
+ * @param options
+ */
+export declare function UseOpts(options: {
+    [key: string]: any;
+}): Function;

package/lib/types-esm/common/decorators/value.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Return value from Configuration.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * import {Env} from "@tsed/core";
+ * import {Constant, Value} from "@tsed/di";
+ *
+ * export class MyClass {
+ *
+ *    @Constant("env")
+ *    env: Env;
+ *
+ *    @Value("swagger.path")
+ *    swaggerPath: string;
+ *
+ *    @Value("swagger.path", "defaultValue")
+ *    swaggerPath: string;
+ *
+ *    constructor() {
+ *       console.log(this.swaggerPath) // undefined. Not available on constructor
+ *    }
+ *
+ *    $onInit() {
+ *      console.log(this.swaggerPath)  // something
+ *    }
+ * }
+ * ```
+ *
+ * @param expression
+ * @param defaultValue
+ * @returns {(targetClass: any, attributeName: string) => any}
+ * @decorator
+ */
+export declare function Value(expression: any, defaultValue?: any): (target: any, propertyKey: string) => void;

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

@@ -0,0 +1,43 @@
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+import type { ProviderType } from "./ProviderType.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+import { Provider } from "./Provider.js";
+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): T | undefined;
+    /**
+     * Get all providers registered in the injector container.
+     *
+     * @param {ProviderType} type Filter the list by the given ProviderType.
+     * @returns {[TokenProvider , Provider<any>][]}
+     */
+    getProviders(type?: ProviderType | string | string[]): Provider[];
+    addProviders(container: Map<TokenProvider, Provider>): void;
+}

package/lib/types-esm/common/domain/ControllerProvider.d.ts

@@ -0,0 +1,17 @@
+import { ControllerMiddlewares } from "../decorators/controller.js";
+import { TokenProvider } from "../interfaces/TokenProvider.js";
+import { Provider } from "./Provider.js";
+export declare class ControllerProvider<T = any> extends Provider<T> {
+    tokenRouter: string;
+    constructor(provide: TokenProvider, options?: Partial<Provider>);
+    /**
+     *
+     * @returns {any[]}
+     */
+    get middlewares(): ControllerMiddlewares;
+    /**
+     *
+     * @param middlewares
+     */
+    set middlewares(middlewares: ControllerMiddlewares);
+}

package/lib/types-esm/common/domain/InjectablePropertyType.d.ts

@@ -0,0 +1,7 @@
+export declare enum InjectablePropertyType {
+    METHOD = "method",
+    PROPERTY = "property",
+    CONSTANT = "constant",
+    VALUE = "value",
+    INTERCEPTOR = "interceptor"
+}

package/lib/types-esm/common/domain/LocalsContainer.d.ts

@@ -0,0 +1,6 @@
+import { Hooks } from "@tsed/core";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+export declare class LocalsContainer extends Map<TokenProvider, any> {
+    readonly hooks: Hooks;
+    destroy(): Promise<void>;
+}

package/lib/types-esm/common/domain/Provider.d.ts

@@ -0,0 +1,71 @@
+import { Store, Type } from "@tsed/core";
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+import { ProviderScope } from "./ProviderScope.js";
+import { ProviderType } from "./ProviderType.js";
+export type ProviderHookCallback<T = any> = (instance: T, ...args: unknown[]) => Promise<void> | void;
+export declare class Provider<T = any> implements ProviderOpts<T> {
+    /**
+     * Token group provider to retrieve all provider from the same type
+     */
+    type: TokenProvider | ProviderType;
+    deps: TokenProvider[];
+    imports: (TokenProvider | [TokenProvider])[];
+    alias?: string;
+    useFactory?: Function;
+    useAsyncFactory?: Function;
+    useValue?: unknown;
+    hooks?: Record<string, ProviderHookCallback<T>>;
+    private _useClass;
+    private _provide;
+    private _store;
+    private _tokenStore;
+    [key: string]: any;
+    constructor(token: TokenProvider, options?: Partial<Provider>);
+    get token(): any;
+    get provide(): TokenProvider;
+    set provide(value: TokenProvider);
+    get useClass(): Type<T>;
+    /**
+     * Create a new store if the given value is a class. Otherwise the value is ignored.
+     * @param value
+     */
+    set useClass(value: Type<T>);
+    get className(): string;
+    get name(): string;
+    get store(): Store;
+    get path(): string;
+    set path(path: string);
+    /**
+     * Get the scope of the provider.
+     *
+     * ::: tip Note
+     * Async provider is always a SINGLETON
+     * :::
+     *
+     * @returns {boolean}
+     */
+    get scope(): ProviderScope;
+    /**
+     * Change the scope value of the provider.
+     * @param scope
+     */
+    set scope(scope: ProviderScope);
+    get configuration(): Partial<TsED.Configuration>;
+    set configuration(configuration: Partial<TsED.Configuration>);
+    get children(): TokenProvider[];
+    get(key: string): any;
+    isAsync(): boolean;
+    clone(): Provider;
+    /**
+     *
+     * @returns {boolean}
+     */
+    hasChildren(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    hasParent(): boolean;
+    toString(): string;
+}

package/lib/types-esm/common/domain/ProviderScope.d.ts

@@ -0,0 +1,5 @@
+export declare enum ProviderScope {
+    SINGLETON = "singleton",
+    REQUEST = "request",
+    INSTANCE = "instance"
+}

package/lib/types-esm/common/domain/ProviderType.d.ts

@@ -0,0 +1,10 @@
+export declare enum ProviderType {
+    VALUE = "value",
+    FACTORY = "factory",
+    SERVICE = "service",
+    PROVIDER = "provider",
+    MODULE = "module",
+    CONTROLLER = "controller",
+    INTERCEPTOR = "interceptor",
+    MIDDLEWARE = "middleware"
+}

package/lib/types-esm/common/errors/InjectionError.d.ts

@@ -0,0 +1,8 @@
+import { TokenProvider } from "../interfaces/TokenProvider.js";
+export declare class InjectionError extends Error {
+    name: string;
+    tokens: TokenProvider[];
+    origin: any;
+    constructor(token: TokenProvider, origin?: any);
+    static throwInjectorError(token: any, currentDependency: any, error: any): void;
+}

package/lib/types-esm/common/errors/InvalidPropertyTokenError.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidPropertyTokenError extends Error {
+    name: string;
+    constructor(target: any, propertyKey: string);
+}

package/lib/types-esm/common/errors/UndefinedTokenError.d.ts

@@ -0,0 +1,4 @@
+export declare class UndefinedTokenError extends Error {
+    name: string;
+    constructor();
+}

package/lib/types-esm/common/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./constants/constants.js";
+export * from "./decorators/configuration.js";
+export * from "./decorators/constant.js";
+export * from "./decorators/controller.js";
+export * from "./decorators/inject.js";
+export * from "./decorators/injectable.js";
+export * from "./decorators/intercept.js";
+export * from "./decorators/interceptor.js";
+export * from "./decorators/lazyInject.js";
+export * from "./decorators/module.js";
+export * from "./decorators/opts.js";
+export * from "./decorators/overrideProvider.js";
+export * from "./decorators/scope.js";
+export * from "./decorators/service.js";
+export * from "./decorators/useOpts.js";
+export * from "./decorators/value.js";
+export * from "./domain/Container.js";
+export * from "./domain/ControllerProvider.js";
+export * from "./domain/InjectablePropertyType.js";
+export * from "./domain/LocalsContainer.js";
+export * from "./domain/Provider.js";
+export * from "./domain/ProviderScope.js";
+export * from "./domain/ProviderType.js";
+export * from "./errors/InjectionError.js";
+export * from "./errors/InvalidPropertyTokenError.js";
+export * from "./errors/UndefinedTokenError.js";
+export * from "./interfaces/DIConfigurationOptions.js";
+export * from "./interfaces/DILogger.js";
+export * from "./interfaces/DILoggerOptions.js";
+export * from "./interfaces/DIResolver.js";
+export * from "./interfaces/ImportTokenProviderOpts.js";
+export * from "./interfaces/InjectableProperties.js";
+export * from "./interfaces/InterceptorContext.js";
+export * from "./interfaces/InterceptorMethods.js";
+export * from "./interfaces/InvokeOptions.js";
+export * from "./interfaces/OnDestroy.js";
+export * from "./interfaces/OnInit.js";
+export * from "./interfaces/ProviderOpts.js";
+export * from "./interfaces/RegistrySettings.js";
+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";
+export * from "./utils/colors.js";
+export * from "./utils/createContainer.js";
+export * from "./utils/getConfiguration.js";
+export * from "./utils/getConstructorDependencies.js";
+export * from "./utils/resolveControllers.js";