@tsed/di 7.79.4 → 7.80.0

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

@@ -0,0 +1,29 @@
+import type { ProviderScope } from "../domain/ProviderScope.js";
+import type { DIResolver } from "./DIResolver.js";
+import type { ImportTokenProviderOpts } from "./ImportTokenProviderOpts.js";
+import type { TokenProvider } from "./TokenProvider.js";
+declare global {
+    namespace TsED {
+        interface Context {
+        }
+        interface Configuration extends Record<string, any> {
+            scopes: {
+                [key: string]: ProviderScope;
+            };
+            /**
+             * Define a list of resolvers (it can be an external DI).
+             */
+            resolvers: DIResolver[];
+            /**
+             * Define dependencies to build the provider
+             */
+            imports: (TokenProvider | ImportTokenProviderOpts)[];
+            /**
+             * Mount controllers
+             */
+            mount: Record<string, TokenProvider[]>;
+        }
+    }
+}
+export interface DIConfigurationOptions extends TsED.Configuration {
+}

package/lib/types-esm/common/interfaces/DILogger.d.ts

@@ -0,0 +1,8 @@
+export interface DILogger {
+    info(...args: any[]): void | any;
+    warn(...args: any[]): void | any;
+    debug(...args: any[]): void | any;
+    error(...args: any[]): void | any;
+    trace(...args: any[]): void | any;
+    [key: string]: any;
+}

package/lib/types-esm/common/interfaces/DILoggerOptions.d.ts

@@ -0,0 +1,53 @@
+export interface DILoggerOptions {
+    /**
+     * Enable debug mode. By default debug is false.
+     */
+    debug?: boolean;
+    /**
+     * Enable info mode. By default debug is false.
+     */
+    level?: "debug" | "info" | "warn" | "error" | "off";
+    /**
+     * Enable log performance tracker and disable log server.
+     */
+    perf?: boolean;
+    /**
+     * List of regexp to ignore log.
+     */
+    ignoreUrlPatterns?: (string | RegExp)[];
+    /**
+     * The number of space characters to use as white space in JSON output. Default is 2 (0 in production).
+     */
+    jsonIndentation?: number;
+    /**
+     * A function called for each incoming request to create a request id.
+     * @returns {number}
+     */
+    reqIdBuilder?: (req: any) => string;
+    /**
+     * Disable routes table displayed in the logger. By default debug is `false`.
+     */
+    disableRoutesSummary?: boolean;
+    /**
+     * Disable bootstrap log displayed in the logger. By default debug is `false`.
+     */
+    disableBootstrapLog?: boolean;
+    /**
+     * Specify log format. Example: `%[%d{[yyyy-MM-dd hh:mm:ss,SSS}] %p%] %m`. See [@tsed/logger configuration](https://tsedio.github.io/logger/).
+     */
+    format?: string;
+    /**
+     * Specify the log stack size for the context.logger. When the stack.length is reach, the logger is flushed during the request.
+     * Default size is set to 30.
+     */
+    maxStackSize?: number;
+}
+declare global {
+    namespace TsED {
+        interface LoggerConfiguration extends DILoggerOptions {
+        }
+        interface Configuration extends Record<string, any> {
+            logger?: LoggerConfiguration;
+        }
+    }
+}

package/lib/types-esm/common/interfaces/DIResolver.d.ts

@@ -0,0 +1,5 @@
+import type { TokenProvider } from "./TokenProvider.js";
+export interface DIResolver {
+    deps?: TokenProvider[];
+    get<T = any>(type: TokenProvider, options: any): T | undefined;
+}

package/lib/types-esm/common/interfaces/ImportTokenProviderOpts.d.ts

@@ -0,0 +1,19 @@
+import type { Type } from "@tsed/core";
+import type { TokenProvider } from "./TokenProvider.js";
+export type UseImportTokenProviderOpts = {
+    token: TokenProvider;
+    use: unknown;
+};
+export type UseClassImportTokenProviderOpts = {
+    token: TokenProvider;
+    useClass: Type | Function;
+};
+export type UseFactoryImportTokenProviderOpts = {
+    token: TokenProvider;
+    useFactory: (...args: unknown[]) => unknown;
+};
+export type UseAsyncFactoryImportTokenProviderOpts = {
+    token: TokenProvider;
+    useAsyncFactory: (...args: unknown[]) => Promise<unknown>;
+};
+export type ImportTokenProviderOpts = UseImportTokenProviderOpts | UseClassImportTokenProviderOpts | UseFactoryImportTokenProviderOpts | UseAsyncFactoryImportTokenProviderOpts;

package/lib/types-esm/common/interfaces/InjectableProperties.d.ts

@@ -0,0 +1,25 @@
+import type { InjectablePropertyType } from "../domain/InjectablePropertyType.js";
+import type { LocalsContainer } from "../domain/LocalsContainer.js";
+import type { TokenProvider } from "./TokenProvider.js";
+import type { InjectorService } from "../services/InjectorService.js";
+import type { InvokeOptions } from "./InvokeOptions.js";
+export interface InjectableProperty {
+    propertyKey: string;
+}
+export interface InjectablePropertyOptions extends InjectableProperty {
+    bindingType: InjectablePropertyType.METHOD | InjectablePropertyType.PROPERTY | InjectablePropertyType.INTERCEPTOR;
+    propertyType: string;
+    useType?: TokenProvider;
+    resolver: (injector: InjectorService, locals: LocalsContainer, options: Partial<InvokeOptions> & {
+        options: any;
+    }) => () => any;
+    options?: any;
+}
+export interface InjectablePropertyValue extends InjectableProperty {
+    bindingType: InjectablePropertyType.CONSTANT | InjectablePropertyType.VALUE;
+    expression: string;
+    defaultValue?: any;
+}
+export interface InjectableProperties {
+    [key: string]: InjectablePropertyOptions | InjectablePropertyValue;
+}

package/lib/types-esm/common/interfaces/InterceptorContext.d.ts

@@ -0,0 +1,11 @@
+import type { Type } from "@tsed/core";
+export interface InterceptorNext {
+    <T>(err?: Error): T;
+}
+export interface InterceptorContext<Klass = Type, Opts = any> {
+    target: Klass;
+    propertyKey: string;
+    args: any[];
+    next: InterceptorNext;
+    options?: Opts;
+}

package/lib/types-esm/common/interfaces/InterceptorMethods.d.ts

@@ -0,0 +1,4 @@
+import type { InterceptorContext, InterceptorNext } from "./InterceptorContext.js";
+export interface InterceptorMethods {
+    intercept(context: InterceptorContext, next?: InterceptorNext): any;
+}

package/lib/types-esm/common/interfaces/InvokeOptions.d.ts

@@ -0,0 +1,10 @@
+import { ProviderScope } from "../domain/ProviderScope.js";
+import { TokenProvider } from "./TokenProvider.js";
+export interface InvokeOptions<T = any> {
+    deps: any[];
+    imports: any[];
+    parent?: TokenProvider;
+    scope: ProviderScope;
+    useScope: boolean;
+    rebuild?: boolean;
+}

package/lib/types-esm/common/interfaces/OnDestroy.d.ts

@@ -0,0 +1,3 @@
+export interface OnDestroy {
+    $onDestroy(): Promise<any> | void;
+}

package/lib/types-esm/common/interfaces/OnInit.d.ts

@@ -0,0 +1,3 @@
+export interface OnInit {
+    $onInit(): Promise<any> | void;
+}

package/lib/types-esm/common/interfaces/ProviderOpts.d.ts

@@ -0,0 +1,59 @@
+import type { Type } from "@tsed/core";
+import type { ProviderType } from "../domain/ProviderType.js";
+import type { DIResolver } from "./DIResolver.js";
+import type { ProviderScope } from "../domain/ProviderScope.js";
+import type { TokenProvider } from "./TokenProvider.js";
+export interface ProviderOpts<T = any> {
+    /**
+     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+     */
+    provide: TokenProvider;
+    /**
+     * Create alias token to retrieve the instance provider.
+     */
+    alias?: TokenProvider;
+    /**
+     * Provider type
+     */
+    type?: TokenProvider | ProviderType;
+    /**
+     * Instance build by the injector
+     */
+    instance?: T;
+    /**
+     * Define dependencies to build the provider
+     */
+    deps?: TokenProvider[];
+    /**
+     * Class to instantiate for the `token`.
+     */
+    useClass?: Type<T>;
+    /**
+     * Provide a function to build the provider
+     */
+    useFactory?: Function;
+    /**
+     * Provide an async function to build the provider
+     */
+    useAsyncFactory?: Function;
+    /**
+     * Provide predefined value
+     */
+    useValue?: any;
+    /**
+     * Scope used by the injector to build the provider.
+     */
+    scope?: ProviderScope;
+    /**
+     * A list of resolvers which will be used to resolve missing Symbol/Class when injector invoke a Class. This property allow external DI usage.
+     */
+    resolvers?: DIResolver[];
+    /**
+     * hooks to intercept custom events
+     */
+    hooks?: Record<string, (instance: T, ...args: any[]) => Promise<any> | any>;
+    /**
+     *
+     */
+    [key: string]: any;
+}

package/lib/types-esm/common/interfaces/RegistrySettings.d.ts

@@ -0,0 +1,20 @@
+import { Type } from "@tsed/core";
+import type { Provider } from "../domain/Provider.js";
+import type { InjectorService } from "../services/InjectorService.js";
+import type { ResolvedInvokeOptions } from "./ResolvedInvokeOptions.js";
+/**
+ * @ignore
+ */
+export interface RegistrySettings {
+    injectable?: boolean;
+    model?: Type<Provider>;
+    /**
+     *
+     * @param provider
+     * @param {Map<string | Function, any>} locals
+     * @param options
+     */
+    onInvoke?(provider: Provider, locals: Map<string | Function, any>, options: ResolvedInvokeOptions & {
+        injector: InjectorService;
+    }): void;
+}

package/lib/types-esm/common/interfaces/ResolvedInvokeOptions.d.ts

@@ -0,0 +1,12 @@
+import type { Provider } from "../domain/Provider.js";
+import type { ProviderScope } from "../domain/ProviderScope.js";
+import type { TokenProvider } from "./TokenProvider.js";
+export interface ResolvedInvokeOptions {
+    token: TokenProvider;
+    parent?: TokenProvider;
+    scope: ProviderScope;
+    deps: TokenProvider[];
+    imports: TokenProvider[];
+    provider: Provider;
+    construct(deps: TokenProvider[]): any;
+}

package/lib/types-esm/common/interfaces/TokenProvider.d.ts

@@ -0,0 +1,6 @@
+import type { Type } from "@tsed/core";
+export type TokenProvider<T = any> = string | symbol | Type<T> | Function | any;
+export interface TokenProviderOpts {
+    token?: TokenProvider;
+    use: any;
+}

package/lib/types-esm/common/interfaces/TokenRoute.d.ts

@@ -0,0 +1,5 @@
+import { TokenProvider } from "./TokenProvider.js";
+export interface TokenRoute {
+    token: TokenProvider;
+    route: string;
+}

package/lib/types-esm/common/registries/GlobalProviders.d.ts

@@ -0,0 +1,58 @@
+import { Type } from "@tsed/core";
+import type { LocalsContainer } from "../domain/LocalsContainer.js";
+import { Provider } from "../domain/Provider.js";
+import { ProviderOpts } from "../interfaces/ProviderOpts.js";
+import { RegistrySettings } from "../interfaces/RegistrySettings.js";
+import { ResolvedInvokeOptions } from "../interfaces/ResolvedInvokeOptions.js";
+import { TokenProvider } from "../interfaces/TokenProvider.js";
+import type { InjectorService } from "../services/InjectorService.js";
+export declare class GlobalProviderRegistry extends Map<TokenProvider, Provider> {
+    #private;
+    /**
+     * 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: TokenProvider): Provider | undefined;
+    /**
+     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key
+     * @returns {boolean}
+     */
+    has(key: TokenProvider): boolean;
+    /**
+     * 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: TokenProvider, metadata: Provider): this;
+    /**
+     *
+     * @param target
+     * @param options
+     */
+    merge(target: TokenProvider, options: Partial<ProviderOpts>): Provider<any>;
+    /**
+     * 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: TokenProvider): boolean;
+    createRegistry(type: string, model: Type<Provider>, options?: Partial<RegistrySettings>): this;
+    onInvoke(provider: Provider, locals: LocalsContainer, options: ResolvedInvokeOptions & {
+        injector: InjectorService;
+    }): void;
+    getRegistrySettings(target: string | TokenProvider): RegistrySettings;
+    createRegisterFn(type: string): (provider: any | ProviderOpts, instance?: any) => void;
+    /**
+     *
+     * @param key
+     * @param options
+     */
+    protected createIfNotExists(key: TokenProvider, options: Partial<ProviderOpts>): Provider;
+}
+/**
+ *
+ * @type {GlobalProviders}
+ */
+export declare const GlobalProviders: GlobalProviderRegistry;

package/lib/types-esm/common/registries/ProviderRegistry.d.ts

@@ -0,0 +1,58 @@
+import { Provider } from "../domain/Provider.js";
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+/**
+ * Register a provider configuration.
+ * @param {ProviderOpts<any>} provider
+ */
+export declare function registerProvider<Type = any>(provider: Partial<ProviderOpts<Type>>): Provider<any>;
+/**
+ * Add a new value in the `ProviderRegistry`.
+ *
+ * #### Example with symbol definition
+ *
+ *
+ * ```typescript
+ * import {registerValue, InjectorService} from "@tsed/di";
+ *
+ * const MyValue = Symbol.from("MyValue")
+ *
+ * registerValue({token: MyValue, useValue: "myValue"});
+ *
+ * @Service()
+ * export class OtherService {
+ *      constructor(@Inject(MyValue) myValue: string){
+ *          console.log(myValue); /// "myValue"
+ *      }
+ * }
+ * ```
+ */
+export declare const registerValue: (provider: any | ProviderOpts<any>, value?: any) => void;
+/**
+ * Add a new controller in the `ProviderRegistry`. This controller will be built when `InjectorService` will be loaded.
+ *
+ * #### Example
+ *
+ * ```typescript
+ * import {registerController, InjectorService} from "@tsed/di";
+ *
+ * export default class MyController {
+ *     constructor(){}
+ *     transform() {
+ *         return "test";
+ *     }
+ * }
+ *
+ * registerController({provide: MyController});
+ * // or
+ * registerController(MyController);
+ *
+ * const injector = new InjectorService();
+ * injector.load();
+ *
+ * const myController = injector.get<MyController>(MyController);
+ * myController.getFoo(); // test
+ * ```
+ *
+ * @param provider Provider configuration.
+ */
+export declare const registerController: (provider: any, instance?: any) => void;

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

@@ -0,0 +1,57 @@
+import { Env } from "@tsed/core";
+import type { ProviderScope } from "../domain/ProviderScope.js";
+import type { DILoggerOptions } from "../interfaces/DILoggerOptions.js";
+import type { DIResolver } from "../interfaces/DIResolver.js";
+import type { ImportTokenProviderOpts } from "../interfaces/ImportTokenProviderOpts.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+import type { TokenRoute } from "../interfaces/TokenRoute.js";
+export declare class DIConfiguration {
+    readonly default: Map<string, any>;
+    protected map: Map<string, any>;
+    constructor(initialProps?: {});
+    get version(): string;
+    set version(v: string);
+    get rootDir(): string;
+    set rootDir(value: string);
+    get env(): Env;
+    set env(value: Env);
+    get scopes(): Record<string, ProviderScope>;
+    set scopes(value: Record<string, ProviderScope>);
+    get resolvers(): DIResolver[];
+    set resolvers(resolvers: DIResolver[]);
+    get imports(): (TokenProvider | ImportTokenProviderOpts)[];
+    set imports(imports: (TokenProvider | ImportTokenProviderOpts)[]);
+    get routes(): TokenRoute[];
+    set routes(routes: TokenRoute[]);
+    get logger(): Partial<DILoggerOptions>;
+    set logger(value: Partial<DILoggerOptions>);
+    get debug(): boolean;
+    set debug(debug: boolean);
+    /**
+     *
+     * @param callbackfn
+     * @param thisArg
+     */
+    forEach(callbackfn: (value: any, index: string, map: Map<string, any>) => void, thisArg?: any): void;
+    /**
+     *
+     * @param propertyKey
+     * @param value
+     */
+    set(propertyKey: string | Partial<TsED.Configuration>, value?: any): this;
+    setRaw(propertyKey: string, value: any): this;
+    /**
+     *
+     * @param propertyKey
+     * @param defaultValue
+     * @returns {undefined|any}
+     */
+    get<T = any>(propertyKey: string, defaultValue?: T): T;
+    /**
+     *
+     * @param value
+     * @returns {any}
+     */
+    resolve(value: any): any;
+    protected getRaw(propertyKey: string, defaultValue?: any): any;
+}

package/lib/types-esm/common/services/DILogger.d.ts

@@ -0,0 +1,3 @@
+import { DILogger } from "../interfaces/DILogger.js";
+export declare const LOGGER: unique symbol;
+export type LOGGER = DILogger;