@tsed/di 7.0.0-beta.2 → 7.0.0-beta.20

package/lib/types/interfaces/DILoggerOptions.d.ts

@@ -0,0 +1,44 @@
+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;
+}

package/lib/types/interfaces/InjectableProperties.d.ts

@@ -1,4 +1,5 @@
 import type { InjectablePropertyType } from "../domain/InjectablePropertyType";
+import type { LocalsContainer } from "../domain/LocalsContainer";
 import type { TokenProvider } from "./TokenProvider";
 import type { InjectorService } from "../services/InjectorService";
 import type { InvokeOptions } from "./InvokeOptions";
@@ -9,7 +10,7 @@ export interface InjectablePropertyOptions extends InjectableProperty {
     bindingType: InjectablePropertyType.METHOD | InjectablePropertyType.PROPERTY | InjectablePropertyType.INTERCEPTOR;
     propertyType: string;
     useType?: TokenProvider;
-    resolver: (injector: InjectorService, locals: Map<TokenProvider, any>, options: Partial<InvokeOptions> & {
+    resolver: (injector: InjectorService, locals: LocalsContainer, options: Partial<InvokeOptions> & {
         options: any;
     }) => () => any;
     options?: any;

package/lib/types/interfaces/InterceptorMethods.d.ts

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

package/lib/types/interfaces/{IProvider.d.ts → ProviderOpts.d.ts}

@@ -3,10 +3,7 @@ import type { DIResolver } from "./DIResolver";
 import type { ProviderScope } from "../domain/ProviderScope";
 import type { ProviderType } from "../domain/ProviderType";
 import type { TokenProvider } from "./TokenProvider";
-/**
- *
- */
-export interface IProvider<T = any> {
+export interface ProviderOpts<T = any> {
     /**
      * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
      */
@@ -47,6 +44,10 @@ export interface IProvider<T = any> {
      * 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>;
     /**
      *
      */

package/lib/types/interfaces/RegistrySettings.d.ts

@@ -1,5 +1,5 @@
 import { Type } from "@tsed/core";
-import type { Provider } from "../domain";
+import type { Provider } from "../domain/Provider";
 import type { InjectorService } from "../services/InjectorService";
 import type { ResolvedInvokeOptions } from "./ResolvedInvokeOptions";
 /**

package/lib/types/interfaces/TokenProvider.d.ts

@@ -1,2 +1,2 @@
 import type { Type } from "@tsed/core";
-export declare type TokenProvider = string | symbol | Type | Function | any;
+export declare type TokenProvider<T = any> = string | symbol | Type<T> | Function | any;

package/lib/types/interfaces/TokenRoute.d.ts

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

package/lib/types/registries/GlobalProviders.d.ts

@@ -1,8 +1,11 @@
 import { Type } from "@tsed/core";
+import type { LocalsContainer } from "../domain/LocalsContainer";
 import { Provider } from "../domain/Provider";
-import type { IProvider, RegistrySettings, TokenProvider } from "../interfaces";
-import type { InjectorService } from "../services/InjectorService";
+import { ProviderOpts } from "../interfaces/ProviderOpts";
+import { RegistrySettings } from "../interfaces/RegistrySettings";
 import { ResolvedInvokeOptions } from "../interfaces/ResolvedInvokeOptions";
+import { TokenProvider } from "../interfaces/TokenProvider";
+import type { InjectorService } from "../services/InjectorService";
 export declare class GlobalProviderRegistry extends Map<TokenProvider, Provider> {
     #private;
     /**
@@ -28,7 +31,7 @@ export declare class GlobalProviderRegistry extends Map<TokenProvider, Provider>
      * @param target
      * @param options
      */
-    merge(target: TokenProvider, options: Partial<IProvider>): void;
+    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.
@@ -36,17 +39,17 @@ export declare class GlobalProviderRegistry extends Map<TokenProvider, Provider>
      */
     delete(key: TokenProvider): boolean;
     createRegistry(type: string, model: Type<Provider>, options?: Partial<RegistrySettings>): this;
-    onInvoke(provider: Provider, locals: Map<TokenProvider, any>, options: ResolvedInvokeOptions & {
+    onInvoke(provider: Provider, locals: LocalsContainer, options: ResolvedInvokeOptions & {
         injector: InjectorService;
     }): void;
     getRegistrySettings(target: string | TokenProvider): RegistrySettings;
-    createRegisterFn(type: string): (provider: any | IProvider, instance?: any) => void;
+    createRegisterFn(type: string): (provider: any | ProviderOpts, instance?: any) => void;
     /**
      *
      * @param key
      * @param options
      */
-    protected createIfNotExists(key: TokenProvider, options: Partial<IProvider>): Provider;
+    protected createIfNotExists(key: TokenProvider, options: Partial<ProviderOpts>): Provider;
 }
 /**
  *

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

@@ -1,9 +1,10 @@
-import type { IProvider } from "../interfaces";
+import { Provider } from "../domain/Provider";
+import type { ProviderOpts } from "../interfaces/ProviderOpts";
 /**
  * Register a provider configuration.
- * @param {IProvider<any>} provider
+ * @param {ProviderOpts<any>} provider
  */
-export declare function registerProvider(provider: Partial<IProvider>): void;
+export declare function registerProvider<Type = any>(provider: Partial<ProviderOpts<Type>>): Provider<any>;
 /**
  * Add a new value in the `ProviderRegistry`.
  *
@@ -25,7 +26,7 @@ export declare function registerProvider(provider: Partial<IProvider>): void;
  * }
  * ```
  */
-export declare const registerValue: (provider: any | IProvider<any>, value?: any) => void;
+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.
  *

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

@@ -1,20 +1,31 @@
-import { ProviderScope } from "../domain";
-import type { DIResolver, TokenProvider } from "../interfaces";
+import { Env } from "@tsed/core";
+import type { ProviderScope } from "../domain/ProviderScope";
+import type { DILoggerOptions } from "../interfaces/DILoggerOptions";
+import type { DIResolver } from "../interfaces/DIResolver";
+import type { TokenProvider } from "../interfaces/TokenProvider";
+import type { TokenRoute } from "../interfaces/TokenRoute";
 export declare class DIConfiguration {
     readonly default: Map<string, any>;
     protected map: Map<string, any>;
-    [key: string]: any;
     constructor(initialProps?: {});
-    get scopes(): {
-        [key: string]: ProviderScope;
-    };
-    set scopes(value: {
-        [key: string]: ProviderScope;
-    });
+    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[];
     set imports(imports: TokenProvider[]);
+    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
@@ -35,13 +46,11 @@ export declare class DIConfiguration {
      * @returns {undefined|any}
      */
     get<T = any>(propertyKey: string, defaultValue?: T): T;
-    getRaw(propertyKey: string, defaultValue?: any): any;
-    merge(obj: Partial<TsED.Configuration>): void;
+    protected getRaw(propertyKey: string, defaultValue?: any): any;
     /**
      *
      * @param value
      * @returns {any}
      */
     resolve(value: any): any;
-    build(): void;
 }

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

@@ -1,5 +1,6 @@
 import { TokenProvider } from "../interfaces/TokenProvider";
 import { InjectorService } from "./InjectorService";
+import { DIContext } from "../domain/DIContext";
 export interface DITestInvokeOptions {
     token?: TokenProvider;
     use: any;
@@ -37,5 +38,6 @@ export declare class DITest {
      * @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/services/InjectorService.d.ts

@@ -1,8 +1,11 @@
-import { DIContext, ProviderScope } from "../domain";
 import { Container } from "../domain/Container";
 import { LocalsContainer } from "../domain/LocalsContainer";
 import { Provider } from "../domain/Provider";
-import { DILogger, InjectablePropertyOptions, InjectablePropertyValue, InvokeOptions, IProvider, TokenProvider } from "../interfaces";
+import { ProviderScope } from "../domain/ProviderScope";
+import { DILogger } from "../interfaces/DILogger";
+import { InjectablePropertyOptions, InjectablePropertyValue } from "../interfaces/InjectableProperties";
+import { InvokeOptions } from "../interfaces/InvokeOptions";
+import { TokenProvider } from "../interfaces/TokenProvider";
 import { DIConfiguration } from "./DIConfiguration";
 /**
  * This service contain all services collected by `@Service` or services declared manually with `InjectorService.factory()` or `InjectorService.service()`.
@@ -17,7 +20,7 @@ import { DIConfiguration } from "./DIConfiguration";
  * import MyService2 from "./services/service2";
  * import MyService3 from "./services/service3";
  *
- * // When all services is imported you can load InjectorService.
+ * // When all services are imported, you can load InjectorService.
  * const injector = new InjectorService()
  *
  * await injector.load();
@@ -27,28 +30,17 @@ import { DIConfiguration } from "./DIConfiguration";
  */
 export declare class InjectorService extends Container {
     #private;
-    settings: TsED.Configuration & DIConfiguration;
+    settings: DIConfiguration;
     logger: DILogger;
     private resolvedConfiguration;
     constructor();
-    get resolvers(): import("../interfaces").DIResolver[];
-    get scopes(): {
-        [key: string]: ProviderScope;
-    } & {
-        [key: string]: ProviderScope;
-    };
+    get resolvers(): import("..").DIResolver[];
+    get scopes(): Record<string, ProviderScope>;
     /**
      * Retrieve default scope for a given provider.
      * @param provider
      */
     scopeOf(provider: Provider): ProviderScope;
-    /**
-     * Clone a provider from GlobalProviders and the given token. forkProvider method build automatically the provider if the instance parameter ins't given.
-     * @param token
-     * @param settings
-     * @deprecated
-     */
-    forkProvider(token: TokenProvider, settings?: Partial<IProvider<any>>): Provider;
     /**
      * Return a list of instance build by the injector.
      */
@@ -73,7 +65,12 @@ export declare class InjectorService extends Container {
      * @param options
      * @returns {boolean}
      */
-    get<T = any>(token: TokenProvider, options?: any): T | undefined;
+    get<T = any>(token: TokenProvider<T>, options?: any): T | undefined;
+    /**
+     * Return all instance of the same provider type
+     * @param type
+     */
+    getAll(type: string): any[];
     /**
      * The has() method returns a boolean indicating whether an element with the specified key exists or not.
      * @returns {boolean}
@@ -101,25 +98,29 @@ export declare class InjectorService extends Container {
      * @param options
      * @returns {T} The class constructed.
      */
-    invoke<T>(token: TokenProvider, locals?: Map<TokenProvider, any>, options?: Partial<InvokeOptions<T>>): T;
+    invoke<T = any>(token: TokenProvider, locals?: LocalsContainer, options?: Partial<InvokeOptions<T>>): T;
     /**
      * Build only providers which are asynchronous.
      */
-    loadAsync(locals?: LocalsContainer): Promise<LocalsContainer<any>>;
-    loadSync(locals?: LocalsContainer): LocalsContainer<any>;
+    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
-     * @param rootModule
      */
-    load(container?: Container, rootModule?: TokenProvider): Promise<LocalsContainer<any>>;
+    load(container?: Container): Promise<void>;
     /**
      * Load all configurations registered on providers
      */
@@ -130,9 +131,8 @@ export declare class InjectorService extends Container {
      * @param locals
      * @param options
      */
-    bindInjectableProperties(instance: any, locals: Map<TokenProvider, any>, options: Partial<InvokeOptions>): void;
+    bindInjectableProperties(instance: any, locals: LocalsContainer, options: Partial<InvokeOptions>): void;
     /**
-     *
      * @param instance
      * @param {string} propertyKey
      */
@@ -148,7 +148,7 @@ export declare class InjectorService extends Container {
      * @param locals
      * @param invokeOptions
      */
-    bindProperty(instance: any, { propertyKey, resolver, options }: InjectablePropertyOptions, locals: Map<TokenProvider, any>, invokeOptions: Partial<InvokeOptions>): void;
+    bindProperty(instance: any, { propertyKey, resolver, options }: InjectablePropertyOptions, locals: LocalsContainer, invokeOptions: Partial<InvokeOptions>): void;
     /**
      *
      * @param instance
@@ -171,18 +171,11 @@ export declare class InjectorService extends Container {
      * @param options
      */
     bindInterceptor(instance: any, { propertyKey, useType, options }: InjectablePropertyOptions): void;
-    /**
-     * Allow handler hack for AsyncHookContext plugin.
-     * @param ctx
-     * @param cb
-     * @protected
-     */
-    runInContext(ctx: DIContext, cb: any): any;
     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 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>;
@@ -226,4 +219,5 @@ export declare class InjectorService extends Container {
      * @param options
      */
     private mapInvokeOptions;
+    private registerHooks;
 }

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from "async_hooks";
+import type { DIContext } from "../domain/DIContext";
+import type { InjectorService } from "../services/InjectorService";
+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/utils/getConfiguration.d.ts

@@ -1,2 +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/utils/resolveControllers.d.ts

@@ -0,0 +1,12 @@
+import { TokenProvider } from "../interfaces/TokenProvider";
+import { TokenRoute } from "../interfaces/TokenRoute";
+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/utils/setLoggerConfiguration.d.ts

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

package/lib/types/utils/setLoggerFormat.d.ts

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

package/lib/types/utils/setLoggerLevel.d.ts

@@ -1,4 +1,4 @@
-import { InjectorService } from "../services/InjectorService";
+import type { InjectorService } from "../services/InjectorService";
 /**
  * @ignore
  * @param injector

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@tsed/di",
-  "version": "7.0.0-beta.2",
+  "version": "7.0.0-beta.20",
   "description": "DI module for Ts.ED Framework",
   "private": false,
   "source": "./src/index.ts",
   "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     "types": "./lib/types/index.d.ts",
@@ -13,26 +14,44 @@
     "default": "./lib/esm/index.js"
   },
   "scripts": {
-    "build": "yarn run build:esm && yarn run build:cjs",
+    "build": "yarn barrels && yarn run build:esm && yarn run build:cjs",
     "build:cjs": "tsc --build tsconfig.compile.json",
-    "build:esm": "tsc --build tsconfig.compile.esm.json"
+    "build:esm": "tsc --build tsconfig.compile.esm.json",
+    "barrels": "yarn barrelsby --delete -d ./src -e \"\\.spec\\.ts\" -e \"__mock__\"",
+    "test": "cross-env NODE_ENV=test yarn jest --max-workers=2"
   },
   "dependencies": {
-    "@tsed/core": "7.0.0-beta.2",
-    "@tsed/schema": "7.0.0-beta.2",
-    "tslib": "2.2.0"
+    "tslib": "2.4.0"
   },
   "devDependencies": {
-    "@tsed/logger": "^6.0.0"
+    "@tsed/core": "7.0.0-beta.20",
+    "@tsed/logger": ">=6.2.0",
+    "@tsed/schema": "7.0.0-beta.20"
   },
   "peerDependencies": {
-    "@tsed/logger": ">=6.0.0"
+    "@tsed/core": "^7.0.0-beta.20",
+    "@tsed/logger": ">=6.2.0",
+    "@tsed/schema": "^7.0.0-beta.20"
+  },
+  "peerDependenciesMeta": {
+    "@tsed/core": {
+      "optional": false
+    },
+    "@tsed/logger": {
+      "optional": false
+    },
+    "@tsed/schema": {
+      "optional": false
+    }
   },
   "repository": "https://github.com/tsedio/tsed",
   "bugs": {
     "url": "https://github.com/tsedio/tsed/issues"
   },
-  "homepage": "https://github.com/tsedio/tsed/tree/alpha/packages/di",
+  "homepage": "https://github.com/tsedio/tsed/tree/beta/packages/di",
   "author": "Romain Lenzotti",
-  "license": "MIT"
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "beta"
+  }
 }