@tsed/di 8.0.0-alpha.9 → 8.0.0-beta.10

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

@@ -1,5 +1,3 @@
-export declare function constant<Type>(expression: string): Type | undefined;
-export declare function constant<Type>(expression: string, defaultValue: Type | undefined): Type;
 export declare function bindConstant(target: any, propertyKey: string | symbol, expression: string, defaultValue?: any): void;
 /**
  * Return value from Configuration.

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

@@ -1,11 +1,7 @@
 import { Type } from "@tsed/core";
+import type { ControllerMiddlewares } from "../domain/ControllerProvider.js";
 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>[];

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

@@ -1,8 +1,5 @@
 import { type Type } from "@tsed/core";
-import type { InvokeOptions } from "../interfaces/InvokeOptions.js";
 import { TokenProvider } from "../interfaces/TokenProvider.js";
-export declare function inject<T>(token: TokenProvider<T>, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T;
-export declare function injectMany<T>(token: string | symbol, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T[];
 export type TransformInjectedProviderCB<T, Klass = any> = (instance: T, { target, propertyKey }: {
     self: Klass;
     target: Type<Klass>;

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

@@ -1,6 +1,6 @@
 /**
- * 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.
+ * The decorators `@Interceptor()` declare a new service can be injected in other service or controller on there `constructor`.
+ * All services annotated with `@Interceptor()` are constructed one time.
  *
  * > `@Service()` use the `reflect-metadata` to collect and inject service on controllers or other services.
  *

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

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

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

@@ -54,6 +54,7 @@ export declare class Provider<T = any> implements ProviderOpts<T> {
     get configuration(): Partial<TsED.Configuration>;
     set configuration(configuration: Partial<TsED.Configuration>);
     get children(): TokenProvider[];
+    set children(children: TokenProvider[]);
     get(key: string): any;
     isAsync(): boolean;
     clone(): Provider;

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

@@ -1,7 +1,5 @@
 export declare enum ProviderType {
     VALUE = "value",
-    FACTORY = "factory",
-    SERVICE = "service",
     PROVIDER = "provider",
     MODULE = "module",
     CONTROLLER = "controller",

package/lib/types/common/fn/configuration.d.ts

@@ -0,0 +1,2 @@
+import { DIConfiguration } from "../services/DIConfiguration.js";
+export declare function configuration(): TsED.DIConfiguration & DIConfiguration;

package/lib/types/common/fn/constant.d.ts

@@ -0,0 +1,2 @@
+export declare function constant<Type>(expression: string): Type | undefined;
+export declare function constant<Type>(expression: string, defaultValue: Type | undefined): Type;

package/lib/types/common/fn/events.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Alter value attached to an event asynchronously.
+ * @param eventName
+ * @param value
+ * @param args
+ * @param callThis
+ */
+export declare function $alterAsync<T = any>(eventName: string, value: any, ...args: unknown[]): Promise<T>;
+/**
+ * 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 A list of promises.
+ */
+export declare function $emit(eventName: string, ...args: unknown[]): Promise<void>;
+/**
+ * Alter value attached to an event.
+ * @param eventName
+ * @param value
+ * @param args
+ * @param callThis
+ */
+export declare function $alter<T = any>(eventName: string, value: unknown, ...args: unknown[]): T;

package/lib/types/common/fn/inject.d.ts

@@ -0,0 +1,20 @@
+import type { InvokeOptions } from "../interfaces/InvokeOptions.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+/**
+ * Inject a provider to another provider.
+ *
+ * Use this function to inject a custom provider on constructor parameter or property.
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   connection = inject(CONNECTION);
+ * }
+ * ```
+ *
+ * @param token A token provider or token provider group
+ * @param opts
+ * @returns {Function}
+ * @decorator
+ */
+export declare function inject<T>(token: TokenProvider<T>, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T;

package/lib/types/common/fn/injectMany.d.ts

@@ -0,0 +1,2 @@
+import type { InvokeOptions } from "../interfaces/InvokeOptions.js";
+export declare function injectMany<T>(token: string | symbol, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T[];

package/lib/types/common/fn/injectable.d.ts

@@ -0,0 +1,23 @@
+import "../registries/ProviderRegistry.js";
+import { Store, type Type } from "@tsed/core";
+import { ControllerProvider } from "../domain/ControllerProvider.js";
+import type { Provider } from "../domain/Provider.js";
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+type ProviderBuilder<Token extends TokenProvider, BaseProvider, T extends object> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<Token, BaseProvider, T>;
+} & {
+    inspect(): BaseProvider;
+    store(): Store;
+    token(): Token;
+    factory(f: (...args: unknown[]) => unknown): ProviderBuilder<Token, BaseProvider, T>;
+    asyncFactory(f: (...args: unknown[]) => Promise<unknown>): ProviderBuilder<Token, BaseProvider, T>;
+    value(v: unknown): ProviderBuilder<Token, BaseProvider, T>;
+    class(c: Type): ProviderBuilder<Token, BaseProvider, T>;
+};
+export declare function providerBuilder<Provider, Picked extends keyof Provider>(props: string[], baseOpts?: Partial<ProviderOpts<Provider>>): <Token extends TokenProvider>(token: Token, options?: Partial<ProviderOpts<Type>>) => ProviderBuilder<Token, Provider, Pick<Provider, Picked>>;
+type PickedProps = "scope" | "path" | "alias" | "hooks" | "deps" | "resolvers" | "imports" | "configuration";
+export declare const injectable: <Token extends TokenProvider>(token: Token, options?: Partial<ProviderOpts<Type>>) => ProviderBuilder<Token, Provider<any>, Pick<Provider<any>, "type" | PickedProps>>;
+export declare const interceptor: <Token extends TokenProvider>(token: Token, options?: Partial<ProviderOpts<Type>>) => ProviderBuilder<Token, Provider<any>, Pick<Provider<any>, "type" | PickedProps>>;
+export declare const controller: <Token extends TokenProvider>(token: Token, options?: Partial<ProviderOpts<Type>>) => ProviderBuilder<Token, ControllerProvider<any>, Pick<ControllerProvider<any>, "children" | "middlewares" | PickedProps>>;
+export {};

package/lib/types/common/fn/injector.d.ts

@@ -0,0 +1,24 @@
+import { InjectorService } from "../services/InjectorService.js";
+type InjectorFnOpts = {
+    rebuild?: boolean;
+    logger?: any;
+    settings?: Partial<TsED.Configuration>;
+};
+/**
+ * Create or return the existing injector service.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import {injector, Injectable} from "@tsed/di";
+ *
+ * @Injectable()
+ * class MyService {
+ *   injector = injector();
+ * }
+ * ```
+ */
+export declare function injector(opts?: InjectorFnOpts): InjectorService;
+export declare function hasInjector(): boolean;
+export declare function destroyInjector(): Promise<void>;
+export {};

package/lib/types/common/fn/localsContainer.d.ts

@@ -0,0 +1,15 @@
+import { LocalsContainer } from "../domain/LocalsContainer.js";
+import type { UseImportTokenProviderOpts } from "../interfaces/ImportTokenProviderOpts.js";
+/**
+ * Get the locals container initiated by DITest or .bootstrap() method.
+ */
+export declare function localsContainer({ providers, rebuild }?: {
+    providers?: UseImportTokenProviderOpts[];
+    rebuild?: boolean;
+}): LocalsContainer;
+export declare function invokeOptions(): any;
+/**
+ * Reset the locals container.
+ */
+export declare function detachLocalsContainer(): void;
+export declare function cleanAllLocalsContainer(): void;

package/lib/types/common/fn/refValue.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Get a value from the `injector.settings`.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import {refValue, Injectable} from "@tsed/di";
+ *
+ * @Injectable()
+ * class Test {
+ *   test = refValue("logger.level", "default value");
+ *
+ *   constructor() {
+ *     console.log(this.test.value); // "off"
+ *   }
+ * }
+ *
+ * @param expression The expression to get the value from the `injector.settings`.
+ */
+export declare function refValue<Type>(expression: string): {
+    value: Type | undefined;
+};
+export declare function refValue<Type>(expression: string, defaultValue: Type | undefined): {
+    value: Type;
+};

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

@@ -27,6 +27,15 @@ export * from "./domain/ProviderScope.js";
 export * from "./domain/ProviderType.js";
 export * from "./errors/InjectionError.js";
 export * from "./errors/InvalidPropertyTokenError.js";
+export * from "./fn/configuration.js";
+export * from "./fn/constant.js";
+export * from "./fn/events.js";
+export * from "./fn/inject.js";
+export * from "./fn/injectable.js";
+export * from "./fn/injectMany.js";
+export * from "./fn/injector.js";
+export * from "./fn/localsContainer.js";
+export * from "./fn/refValue.js";
 export * from "./interfaces/DIConfigurationOptions.js";
 export * from "./interfaces/DILogger.js";
 export * from "./interfaces/DILoggerOptions.js";

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

@@ -6,6 +6,11 @@ declare global {
     namespace TsED {
         interface Context {
         }
+        /**
+         * Here to allow extension on DIConfiguration base service
+         */
+        interface DIConfiguration {
+        }
         interface Configuration extends Record<string, any> {
             scopes: {
                 [key: string]: ProviderScope;

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

@@ -1,58 +1,6 @@
-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;
+export declare function registerProvider<Type = any>(provider: Partial<ProviderOpts<Type>> & Pick<ProviderOpts<Type>, "provide">): import("../index.js").Provider<any>;

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

@@ -47,11 +47,5 @@ export declare class DIConfiguration {
      * @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/common/services/InjectorService.d.ts

@@ -1,3 +1,4 @@
+import { Hooks } from "@tsed/core";
 import { Container } from "../domain/Container.js";
 import { LocalsContainer } from "../domain/LocalsContainer.js";
 import { Provider } from "../domain/Provider.js";
@@ -32,21 +33,10 @@ export declare class InjectorService extends Container {
     settings: DIConfiguration;
     logger: DILogger;
     private resolvedConfiguration;
+    readonly hooks: Hooks;
     constructor();
     get resolvers(): import("../index.js").DIResolver[];
     get scopes(): Record<string, ProviderScope>;
-    /**
-     * Return the current injector service.
-     */
-    static getInstance(): InjectorService;
-    /**
-     * Get the locals container initiated by DITest or .bootstrap() method.
-     */
-    static getLocals(): LocalsContainer;
-    /**
-     * Reset the locals container.
-     */
-    static unsetLocals(): void;
     /**
      * Retrieve default scope for a given provider.
      * @param provider

package/lib/types/node/fn/context.d.ts

@@ -0,0 +1,9 @@
+import { DIContext } from "../domain/DIContext.js";
+/**
+ * Get the current DIContext instance using async hook node.js api.
+ *
+ * ::: warning
+ * This function isn't available in the browser context.
+ * :::
+ */
+export declare function context<Ctx = DIContext>(): Ctx;

package/lib/types/node/fn/logger.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get the current `injector.logger` instance.
+ */
+export declare function logger(): import("../../common/index.js").DILogger;
+/**
+ * Get the current logger instance. If the logger() function is invoked in Request context, it will return the logger instance attached to the request context.
+ * Otherwise, it will return the logger instance attached to the DI context.
+ */
+export declare function contextLogger(): import("../index.js").ContextLogger;

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

@@ -4,6 +4,8 @@
 export * from "./decorators/injectContext.js";
 export * from "./domain/ContextLogger.js";
 export * from "./domain/DIContext.js";
+export * from "./fn/context.js";
+export * from "./fn/logger.js";
 export * from "./interfaces/AlterRunInContext.js";
 export * from "./services/DILogger.js";
 export * from "./services/DITest.js";

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

@@ -4,12 +4,7 @@ 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>;
     /**

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

@@ -8,8 +8,7 @@ export declare function getAsyncStore(): AsyncLocalStorage<{
 export declare function useContextRef(): {
     current: DIContext | undefined;
 } | undefined;
-export declare function useContext<Context = DIContext>(initialValue?: DIContext): Context | undefined;
-export declare const getContext: typeof useContext;
+export declare function getContext<Context = DIContext>(initialValue?: DIContext): Context | undefined;
 export declare function runInContext<Result = unknown>(ctx: DIContext | undefined, cb: (...args: unknown[]) => Result, injector?: InjectorService): Promise<Result>;
 export declare function setContext(ctx: DIContext): void;
 export declare function bindContext(cb: any): any;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/di",
   "description": "DI module for Ts.ED Framework",
   "type": "module",
-  "version": "8.0.0-alpha.9",
+  "version": "8.0.0-beta.10",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -26,24 +26,24 @@
   },
   "dependencies": {
     "tslib": "2.7.0",
-    "uuid": "9.0.1"
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.0-alpha.9",
-    "@tsed/core": "8.0.0-alpha.9",
-    "@tsed/logger": ">=6.7.5",
-    "@tsed/schema": "8.0.0-alpha.9",
-    "@tsed/typescript": "8.0.0-alpha.9",
+    "@tsed/barrels": "8.0.0-beta.10",
+    "@tsed/core": "8.0.0-beta.10",
+    "@tsed/logger": "^6.7.8",
+    "@tsed/schema": "8.0.0-beta.10",
+    "@tsed/typescript": "8.0.0-beta.10",
     "cross-env": "7.0.3",
-    "eslint": "9.11.1",
+    "eslint": "9.12.0",
     "typescript": "5.4.5",
-    "vitest": "2.0.4",
+    "vitest": "2.1.2",
     "webpack": "^5.75.0"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.0-alpha.9",
+    "@tsed/core": "8.0.0-beta.10",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/schema": "8.0.0-alpha.9"
+    "@tsed/schema": "8.0.0-beta.10"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {
@@ -64,6 +64,6 @@
   "author": "Romain Lenzotti",
   "license": "MIT",
   "publishConfig": {
-    "tag": "alpha"
+    "tag": "beta"
   }
 }

package/readme.md

@@ -91,7 +91,8 @@ The `@Injectable()` attaches the metadata, thereby Ts.ED knows that this class i
 Now we have the service class already done, let's use it inside a controller:
 
 ```typescript
-import {Controller, Post, Body, Get} from "@tsed/common";
+import {Controller} from "@tsed/di";
+import {Post, Body, Get} from "@tsed/schema";
 import {CalendarsService} from "./CalendarsService.js";
 import {Calendar} from "./models/Calendar.js";
 
@@ -111,9 +112,6 @@ export class CalendarCtrl {
 }
 ```
 
-> Note: Controller isn't a part of `@tsed/di`. `@Controller` decorator is exposed by `@tsed/common` package because it's a specific provider
-> used by the Ts.ED framework. Ts.ED DI allow you to define your own Provider and decorator.
-
 Finally, we can load the injector and use:
 
 ```typescript