@tsed/di 7.79.4 → 7.80.1

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

@@ -0,0 +1,224 @@
+import { Container } from "../domain/Container.js";
+import { LocalsContainer } from "../domain/LocalsContainer.js";
+import { Provider } from "../domain/Provider.js";
+import { ProviderScope } from "../domain/ProviderScope.js";
+import type { DILogger } from "../interfaces/DILogger.js";
+import { InjectablePropertyOptions, InjectablePropertyValue } from "../interfaces/InjectableProperties.js";
+import type { InvokeOptions } from "../interfaces/InvokeOptions.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+import { DIConfiguration } from "./DIConfiguration.js";
+/**
+ * This service contain all services collected by `@Service` or services declared manually with `InjectorService.factory()` or `InjectorService.service()`.
+ *
+ * ### Example:
+ *
+ * ```typescript
+ * import {InjectorService} from "@tsed/di";
+ *
+ * // Import the services (all services are decorated with @Service()";
+ * import MyService1 from "./services/service1.js";
+ * import MyService2 from "./services/service2.js";
+ * import MyService3 from "./services/service3.js";
+ *
+ * // When all services are imported, you can load InjectorService.
+ * const injector = new InjectorService()
+ *
+ * await injector.load();
+ *
+ * const myService1 = injector.get<MyService1>(MyServcice1);
+ * ```
+ */
+export declare class InjectorService extends Container {
+    #private;
+    settings: DIConfiguration;
+    logger: DILogger;
+    private resolvedConfiguration;
+    constructor();
+    get resolvers(): import("../index.js").DIResolver[];
+    get scopes(): Record<string, ProviderScope>;
+    /**
+     * Retrieve default scope for a given provider.
+     * @param provider
+     */
+    scopeOf(provider: Provider): ProviderScope;
+    /**
+     * Return a list of instance build by the injector.
+     */
+    toArray(): any[];
+    /**
+     * Get a service or factory already constructed from his symbol or class.
+     *
+     * #### Example
+     *
+     * ```typescript
+     * import {InjectorService} from "@tsed/di";
+     * import MyService from "./services.js";
+     *
+     * class OtherService {
+     *      constructor(injectorService: InjectorService) {
+     *          const myService = injectorService.get<MyService>(MyService);
+     *      }
+     * }
+     * ```
+     *
+     * @param token The class or symbol registered in InjectorService.
+     * @param options
+     * @returns {boolean}
+     */
+    get<T = any>(token: TokenProvider<T>, options?: any): T | undefined;
+    /**
+     * Return all instance of the same provider type
+     * @param type
+     * @param locals
+     * @param options
+     */
+    getMany<Type = any>(type: any, locals?: LocalsContainer, options?: Partial<InvokeOptions<Type>>): Type[];
+    /**
+     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+     * @returns {boolean}
+     * @param token
+     */
+    has(token: TokenProvider): boolean;
+    alias(token: TokenProvider, alias: TokenProvider): this;
+    /**
+     * Invoke the class and inject all services that required by the class constructor.
+     *
+     * #### Example
+     *
+     * ```typescript
+     * import {InjectorService} from "@tsed/di";
+     * import MyService from "./services.js";
+     *
+     * class OtherService {
+     *     constructor(injectorService: InjectorService) {
+     *          const myService = injectorService.invoke<MyService>(MyService);
+     *      }
+     *  }
+     * ```
+     *
+     * @param token The injectable class to invoke. Class parameters are injected according constructor signature.
+     * @param locals  Optional object. If preset then any argument Class are read from this object first, before the `InjectorService` is consulted.
+     * @param options
+     * @returns {T} The class constructed.
+     */
+    invoke<T = any>(token: TokenProvider, locals?: LocalsContainer, options?: Partial<InvokeOptions<T>>): T;
+    /**
+     * Build only providers which are asynchronous.
+     */
+    loadAsync(): Promise<void>;
+    loadSync(): void;
+    /**
+     * Boostrap injector from container and resolve configuration.
+     *
+     * @param container
+     */
+    bootstrap(container?: Container): this;
+    /**
+     * Load injector from a given module
+     * @param rootModule
+     */
+    loadModule(rootModule: TokenProvider): Promise<void>;
+    /**
+     * Build all providers from given container (or GlobalProviders) and emit `$onInit` event.
+     *
+     * @param container
+     */
+    load(container?: Container): Promise<void>;
+    /**
+     * Load all configurations registered on providers
+     */
+    resolveConfiguration(): void;
+    /**
+     *
+     * @param instance
+     * @param locals
+     * @param options
+     */
+    bindInjectableProperties(instance: any, locals: LocalsContainer, options: Partial<InvokeOptions>): void;
+    /**
+     * Create an injectable property.
+     *
+     * @param instance
+     * @param {string} propertyKey
+     * @param {any} useType
+     * @param resolver
+     * @param options
+     * @param locals
+     * @param invokeOptions
+     */
+    bindProperty(instance: any, { propertyKey, resolver, options }: InjectablePropertyOptions, locals: LocalsContainer, invokeOptions: Partial<InvokeOptions>): void;
+    /**
+     *
+     * @param instance
+     * @param {string} propertyKey
+     * @param {any} useType
+     */
+    bindValue(instance: any, { propertyKey, expression, defaultValue }: InjectablePropertyValue): void;
+    /**
+     *
+     * @param instance
+     * @param {string} propertyKey
+     * @param {any} useType
+     */
+    bindConstant(instance: any, { propertyKey, expression, defaultValue }: InjectablePropertyValue): void;
+    /**
+     *
+     * @param instance
+     * @param propertyKey
+     * @param useType
+     * @param options
+     */
+    bindInterceptor(instance: any, { propertyKey, useType, options }: InjectablePropertyOptions): void;
+    lazyInvoke<T = any>(token: TokenProvider): Promise<any>;
+    /**
+     * Emit an event to all service. See service [lifecycle hooks](/docs/services.md#lifecycle-hooks).
+     * @param eventName The event name to emit at all services.
+     * @param args List of the parameters to give to each service.
+     * @returns {Promise<any[]>} A list of promises.
+     */
+    emit(eventName: string, ...args: any[]): Promise<void>;
+    /**
+     * @param eventName
+     * @param value
+     * @param args
+     */
+    alter<T = any>(eventName: string, value: any, ...args: any[]): T;
+    /**
+     * @param eventName
+     * @param value
+     * @param args
+     */
+    alterAsync<T = any>(eventName: string, value: any, ...args: any[]): Promise<T>;
+    destroy(): Promise<void>;
+    protected ensureProvider(token: TokenProvider, force: true): Provider;
+    protected ensureProvider(token: TokenProvider, force: false): Provider | undefined;
+    protected ensureProvider(token: TokenProvider): Provider | undefined;
+    protected getInstance(token: any): any;
+    /**
+     * Invoke a class method and inject service.
+     *
+     * #### IInjectableMethod options
+     *
+     * * **target**: Optional. The class instance.
+     * * **methodName**: `string` Optional. The method name.
+     * * **designParamTypes**: `any[]` Optional. List of injectable types.
+     * * **locals**: `Map<Function, any>` Optional. If preset then any argument Class are read from this object first, before the `InjectorService` is consulted.
+     *
+     * #### Example
+     *
+     * @param target
+     * @param locals
+     * @param options
+     * @private
+     */
+    protected resolve<T>(target: TokenProvider, locals?: LocalsContainer, options?: Partial<InvokeOptions<T>>): T | Promise<T>;
+    private resolveImportsProviders;
+    /**
+     * Create options to invoke a provider or class.
+     * @param token
+     * @param locals
+     * @param options
+     */
+    private mapInvokeOptions;
+    private registerHooks;
+}

package/lib/types-esm/common/utils/colors.d.ts

@@ -0,0 +1,5 @@
+export declare const colors: {
+    red: (text: string) => string;
+    yellow: (text: string) => string;
+    green: (text: string) => string;
+};

package/lib/types-esm/common/utils/createContainer.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "@tsed/core";
+import { Container } from "../domain/Container.js";
+export declare function createContainer(rootModule?: Type<any>): Container;

package/lib/types-esm/common/utils/getConfiguration.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "@tsed/core";
+export declare function mergeMount(m1?: any, m2?: any): any;
+export declare function getConfiguration(module: Type<any>, configuration?: any): any;

package/lib/types-esm/common/utils/getConstructorDependencies.d.ts

@@ -0,0 +1,2 @@
+export declare function getConstructorDependencies(target: any, propertyKey?: string | symbol | undefined): any;
+export declare function setConstructorDependencies(target: any, deps: any[]): void;

package/lib/types-esm/common/utils/resolveControllers.d.ts

@@ -0,0 +1,12 @@
+import { TokenProvider } from "../interfaces/TokenProvider.js";
+import { TokenRoute } from "../interfaces/TokenRoute.js";
+export declare function getTokens(config: any): {
+    route?: string;
+    token: TokenProvider;
+}[];
+/**
+ * Return controllers and is base route according to his configuration in module configuration.
+ *
+ * @param settings
+ */
+export declare function resolveControllers(settings: Partial<TsED.Configuration>): TokenRoute[];

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

@@ -0,0 +1,2 @@
+export * from "./common/index.js";
+export * from "./node/index.js";

package/lib/types-esm/node/decorators/injectContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Inject a context like PlatformContext or any BaseContext.
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   @InjectContext()
+ *   ctx?: Context;
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export declare function InjectContext(): PropertyDecorator;

package/lib/types-esm/node/domain/ContextLogger.d.ts

@@ -0,0 +1,37 @@
+import { DILogger } from "../../common/index.js";
+import { Hooks } from "@tsed/core";
+import { LogLevel } from "@tsed/logger";
+export interface ContextLoggerOptions extends Record<string, any> {
+    id: string;
+    logger?: DILogger;
+    level?: "debug" | "info" | "warn" | "error" | "off" | "all";
+    maxStackSize?: number;
+    additionalProps?: Record<any, any>;
+}
+export declare class ContextLogger {
+    #private;
+    readonly dateStart: Date;
+    readonly id: string;
+    maxStackSize: number;
+    level: LogLevel;
+    constructor({ id, logger, dateStart, level, maxStackSize, additionalProps }: ContextLoggerOptions);
+    get hooks(): Hooks;
+    private get stack();
+    alterLog(cb: (data: any, level: "debug" | "info" | "warn" | "error" | "off" | "all", withRequest: boolean) => any): Hooks;
+    alterIgnoreLog(cb: (ignore: boolean, data: any) => boolean): Hooks;
+    info(obj: any): this;
+    debug(obj: any, withRequest?: boolean): this;
+    warn(obj: any): this;
+    error(obj: any): this;
+    fatal(obj: any): this;
+    trace(obj: any): this;
+    flush(stream?: boolean): void;
+    isLevelEnabled(otherLevel: string | LogLevel): boolean;
+    /**
+     * Return the duration between the time when LogIncomingRequest has handle the request and now.
+     * @returns {number}
+     */
+    protected getDuration(): number;
+    protected getData(obj: any): any;
+    protected run(level: LogLevel, obj: any, withRequest?: boolean): void;
+}

package/lib/types-esm/node/domain/DIContext.d.ts

@@ -0,0 +1,61 @@
+import { InjectorService, LocalsContainer } from "../../common/index.js";
+import { ContextLogger, ContextLoggerOptions } from "./ContextLogger.js";
+export interface DIContextOptions extends Omit<ContextLoggerOptions, "dateStart"> {
+    id: string;
+    injector: InjectorService;
+    logger: any;
+    platform?: string;
+}
+export declare class DIContext {
+    #private;
+    opts: DIContextOptions;
+    [x: string]: any;
+    readonly PLATFORM: string;
+    constructor(opts: DIContextOptions);
+    /**
+     * Logger attached to the context request.
+     */
+    get logger(): ContextLogger;
+    /**
+     * Request id generated by @@contextMiddleware@@.
+     *
+     * ::: tip
+     * By default Ts.ED generate uuid like that `uuidv4().replace(/-/gi, ""))`.
+     * Dash are removed to simplify tracking logs in Kibana
+     * :::
+     *
+     * ::: tip
+     * Request id can by customized by changing the server configuration.
+     *
+     * ```typescript
+     * @Configuration({
+     *   logger: {
+     *     reqIdBuilder: createUniqId // give your own id generator function
+     *   }
+     * })
+     * class Server {
+     *
+     * }
+     * ```
+     * :::
+     *
+     */
+    get id(): string;
+    get dateStart(): Date;
+    get injector(): InjectorService;
+    get env(): any;
+    /**
+     * The request container used by the Ts.ED DI. It contains all services annotated with `@Scope(ProviderScope.REQUEST)`
+     */
+    get container(): LocalsContainer;
+    destroy(): Promise<any>;
+    emit(eventName: string, ...args: any[]): Promise<void>;
+    runInContext(next: Function): Promise<any>;
+    cache<Value = any>(key: string, cb: () => Value): Value;
+    cacheAsync<Value = any>(key: string, cb: () => Promise<Value>): Promise<Value>;
+    delete(key: any): boolean;
+    get<T = any>(key: any): T;
+    has(key: any): boolean;
+    set(key: any, value: any): this;
+}
+export type BaseContext = DIContext & TsED.Context;

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

@@ -0,0 +1,14 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./decorators/injectContext.js";
+export * from "./domain/ContextLogger.js";
+export * from "./domain/DIContext.js";
+export * from "./interfaces/AlterRunInContext.js";
+export * from "./services/DILogger.js";
+export * from "./services/DITest.js";
+export * from "./utils/asyncHookContext.js";
+export * from "./utils/attachLogger.js";
+export * from "./utils/setLoggerConfiguration.js";
+export * from "./utils/setLoggerFormat.js";
+export * from "./utils/setLoggerLevel.js";

package/lib/types-esm/node/interfaces/AlterRunInContext.d.ts

@@ -0,0 +1,3 @@
+export interface AlterRunInContext {
+    $alterRunInContext(next: (...args: unknown[]) => unknown): () => unknown | Promise<() => unknown>;
+}

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

@@ -0,0 +1 @@
+export {};

package/lib/types-esm/node/services/DITest.d.ts

@@ -0,0 +1,37 @@
+import { InjectorService, TokenProvider, type UseImportTokenProviderOpts } from "../../common/index.js";
+import { DIContext } from "../domain/DIContext.js";
+/**
+ * Tool to run test with lightweight DI sandbox.
+ */
+export declare class DITest {
+    static options: Partial<TsED.Configuration>;
+    protected static _injector: InjectorService | null;
+    static get injector(): InjectorService;
+    static set injector(injector: InjectorService);
+    static set(key: string, value: any): void;
+    static hasInjector(): boolean;
+    static create(settings?: Partial<TsED.Configuration>): Promise<void>;
+    static createContainer(): Promise<void>;
+    /**
+     * Create a new injector with the right default services
+     */
+    static createInjector(settings?: any): InjectorService;
+    /**
+     * Resets the test injector of the test context, so it won't pollute your next test. Call this in your `tearDown` logic.
+     */
+    static reset(): Promise<void>;
+    /**
+     * Invoke a provider and return a fresh instance
+     * @param target
+     * @param providers
+     */
+    static invoke<T = any>(target: TokenProvider, providers?: UseImportTokenProviderOpts[]): Promise<T>;
+    /**
+     * Return the instance from injector registry
+     * @param target
+     * @param options
+     */
+    static get<T = any>(target: TokenProvider, options?: any): T;
+    static createDIContext(): DIContext;
+    protected static configure(settings?: Partial<TsED.Configuration>): Partial<TsED.Configuration>;
+}

package/lib/types-esm/node/utils/asyncHookContext.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from "async_hooks";
+import { InjectorService } from "../../common/index.js";
+import type { DIContext } from "../domain/DIContext.js";
+export declare function getAsyncStore(): AsyncLocalStorage<{
+    current: DIContext | undefined;
+}>;
+export declare function useContextRef(): {
+    current: DIContext | undefined;
+} | undefined;
+export declare function getContext<Context = DIContext>(): Context | undefined;
+export declare function runInContext(ctx: DIContext | undefined, cb: any, injector?: InjectorService): Promise<any>;
+export declare function setContext(ctx: DIContext): void;
+export declare function bindContext(cb: any): any;

package/lib/types-esm/node/utils/attachLogger.d.ts

@@ -0,0 +1,2 @@
+import { DILogger, InjectorService } from "../../common/index.js";
+export declare function attachLogger(injector: InjectorService, $log: DILogger): void;

package/lib/types-esm/node/utils/setLoggerConfiguration.d.ts

@@ -0,0 +1,2 @@
+import type { InjectorService } from "../../common/index.js";
+export declare function setLoggerConfiguration(injector: InjectorService): void;

package/lib/types-esm/node/utils/setLoggerFormat.d.ts

@@ -0,0 +1,6 @@
+import type { InjectorService } from "../../common/index.js";
+/**
+ * @ignore
+ * @param injector
+ */
+export declare function setLoggerFormat(injector: InjectorService): void;

package/lib/types-esm/node/utils/setLoggerLevel.d.ts

@@ -0,0 +1,6 @@
+import type { InjectorService } from "../../common/index.js";
+/**
+ * @ignore
+ * @param injector
+ */
+export declare function setLoggerLevel(injector: InjectorService): void;

package/package.json

@@ -1,45 +1,48 @@
 {
   "name": "@tsed/di",
-  "version": "7.79.4",
   "description": "DI module for Ts.ED Framework",
+  "type": "commonjs",
+  "version": "7.80.1",
   "source": "./src/index.ts",
-  "main": "lib/cjs/index.js",
+  "main": "lib/esm/index.js",
   "module": "lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "browser": "./lib/browser/di.umd.min.js",
   "exports": {
-    "types": "./lib/types/index.d.ts",
-    "browser": "./lib/browser/di.umd.min.js",
-    "import": "./lib/esm/index.js",
-    "require": "./lib/cjs/index.js",
-    "default": "./lib/esm/index.js"
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "browser": "./lib/browser/di.umd.min.js",
+      "import": "./lib/esm/index.js",
+      "default": "./lib/cjs/index.js"
+    }
   },
   "scripts": {
     "build": "yarn barrels && yarn build:ts && yarn run build:browser",
     "build:browser": "webpack",
     "barrels": "barrels",
-    "test": "jest --max-workers=2 && jest-coverage-thresholds-bumper",
-    "build:ts": "tsc --build tsconfig.json && tsc --build tsconfig.esm.json"
+    "test": "vitest run",
+    "build:ts": "tsc --build tsconfig.json",
+    "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
     "tslib": "2.6.2"
   },
   "devDependencies": {
-    "@tsed/barrels": "7.79.4",
-    "@tsed/core": "7.79.4",
+    "@tsed/barrels": "7.80.1",
+    "@tsed/core": "7.80.1",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/schema": "7.79.4",
-    "@tsed/typescript": "7.79.4",
+    "@tsed/schema": "7.80.1",
+    "@tsed/typescript": "7.80.1",
     "cross-env": "7.0.3",
     "eslint": "^8.57.0",
-    "jest": "^29.7.0",
     "typescript": "4.9.5",
+    "vitest": "2.0.4",
     "webpack": "^5.75.0"
   },
   "peerDependencies": {
-    "@tsed/core": "7.79.4",
+    "@tsed/core": "7.80.1",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/schema": "7.79.4"
+    "@tsed/schema": "7.80.1"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/vitest.config.mts

@@ -0,0 +1,21 @@
+// @ts-ignore
+import {presets} from "@tsed/vitest/presets";
+import {defineConfig} from "vitest/config";
+
+export default defineConfig(
+  {
+    ...presets,
+    test: {
+      ...presets.test,
+      coverage: {
+        ...presets.test.coverage,
+        thresholds: {
+          statements: 0,
+          branches: 0,
+          functions: 0,
+          lines: 0
+        }
+      }
+    }
+  }
+);

package/jest.config.js

@@ -1,14 +0,0 @@
-// For a detailed explanation regarding each configuration property, visit:
-// https://jestjs.io/docs/en/configuration.html
-
-module.exports = {
-  ...require("@tsed/jest-config"),
-  coverageThreshold: {
-    global: {
-      statements: 99.27,
-      branches: 96.99,
-      lines: 99.27,
-      functions: 99.17
-    }
-  }
-};

package/lib/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/lib/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/tsconfig.esm.json

@@ -1,39 +0,0 @@
-{
-  "extends": "@tsed/typescript/tsconfig.node.json",
-  "compilerOptions": {
-    "baseUrl": "./",
-    "module": "ES2020",
-    "rootDir": "src",
-    "outDir": "./lib/esm",
-    "declaration": true,
-    "declarationDir": "./lib/types",
-    "composite": true,
-    "noEmit": false
-  },
-  "include": ["src", "src/**/*.json"],
-  "exclude": [
-    "node_modules",
-    "test",
-    "lib",
-    "benchmark",
-    "coverage",
-    "spec",
-    "**/*.benchmark.ts",
-    "**/*.spec.ts",
-    "keys",
-    "jest.config.js",
-    "**/__mock__/**",
-    "webpack.config.js"
-  ],
-  "references": [
-    {
-      "path": "../core"
-    },
-    {
-      "path": "../core"
-    },
-    {
-      "path": "../specs/schema"
-    }
-  ]
-}