@tsed/di 7.0.0-alpha.2 → 7.0.0-beta.11

package/lib/{registries → types/registries}/GlobalProviders.d.ts

@@ -1,6 +1,10 @@
 import { Type } from "@tsed/core";
 import { Provider } from "../domain/Provider";
-import type { IProvider, RegistrySettings, TokenProvider } from "../interfaces";
+import type { InjectorService } from "../services/InjectorService";
+import { ResolvedInvokeOptions } from "../interfaces/ResolvedInvokeOptions";
+import { TokenProvider } from "../interfaces/TokenProvider";
+import { RegistrySettings } from "../interfaces/RegistrySettings";
+import { ProviderOpts } from "../interfaces/ProviderOpts";
 export declare class GlobalProviderRegistry extends Map<TokenProvider, Provider> {
     #private;
     /**
@@ -26,7 +30,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>): void;
     /**
      * 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.
@@ -34,15 +38,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>, deps: any[]): void;
+    onInvoke(provider: Provider, locals: Map<TokenProvider, any>, 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/{registries → types/registries}/ProviderRegistry.d.ts

@@ -1,9 +1,9 @@
-import type { IProvider } from "../interfaces";
+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>>): void;
 /**
  * Add a new value in the `ProviderRegistry`.
  *
@@ -25,7 +25,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/{services → types/services}/DIConfiguration.d.ts

@@ -1,5 +1,7 @@
-import { ProviderScope } from "../domain";
-import type { DIResolver, TokenProvider } from "../interfaces";
+import { ProviderScope } from "../domain/ProviderScope";
+import type { DIResolver } from "../interfaces/DIResolver";
+import type { TokenProvider } from "../interfaces/TokenProvider";
+import { TokenRoute } from "../interfaces/TokenRoute";
 export declare class DIConfiguration {
     readonly default: Map<string, any>;
     protected map: Map<string, any>;
@@ -15,6 +17,8 @@ export declare class DIConfiguration {
     set resolvers(resolvers: DIResolver[]);
     get imports(): TokenProvider[];
     set imports(imports: TokenProvider[]);
+    get routes(): TokenRoute[];
+    set routes(routes: TokenRoute[]);
     /**
      *
      * @param callbackfn

package/lib/{services → types/services}/DITest.d.ts

@@ -1,9 +1,13 @@
 import { TokenProvider } from "../interfaces/TokenProvider";
 import { InjectorService } from "./InjectorService";
+import { DIContext } from "../domain/DIContext";
 export interface DITestInvokeOptions {
     token?: TokenProvider;
     use: any;
 }
+export interface DITestOptions extends Partial<TsED.Configuration> {
+    imports?: DITestInvokeOptions[];
+}
 /**
  * Tool to run test with lightweight DI sandbox.
  */
@@ -12,7 +16,8 @@ export declare class DITest {
     static get injector(): InjectorService;
     static set injector(injector: InjectorService);
     static hasInjector(): boolean;
-    static create(settings?: Partial<TsED.Configuration>): Promise<void>;
+    static create(settings?: DITestOptions): Promise<void>;
+    static createContainer(settings?: DITestOptions): Promise<void>;
     /**
      * Create a new injector with the right default services
      */
@@ -33,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/{services → types/services}/InjectorService.d.ts

@@ -1,9 +1,12 @@
-import { DIContext, ProviderScope } from "../domain";
 import { Container } from "../domain/Container";
 import { LocalsContainer } from "../domain/LocalsContainer";
 import { Provider } from "../domain/Provider";
-import { DILogger, InjectablePropertyService, InjectablePropertyValue, InvokeOptions, IProvider, TokenProvider } from "../interfaces";
 import { DIConfiguration } from "./DIConfiguration";
+import { ProviderScope } from "../domain/ProviderScope";
+import { DILogger } from "../interfaces/DILogger";
+import { TokenProvider } from "../interfaces/TokenProvider";
+import { InvokeOptions } from "../interfaces/InvokeOptions";
+import { InjectablePropertyOptions, InjectablePropertyValue } from "../interfaces/InjectableProperties";
 /**
  * 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();
@@ -26,11 +29,12 @@ import { DIConfiguration } from "./DIConfiguration";
  * ```
  */
 export declare class InjectorService extends Container {
+    #private;
     settings: TsED.Configuration & DIConfiguration;
     logger: DILogger;
     private resolvedConfiguration;
     constructor();
-    get resolvers(): import("../interfaces").DIResolver[];
+    get resolvers(): import("..").DIResolver[];
     get scopes(): {
         [key: string]: ProviderScope;
     } & {
@@ -41,12 +45,6 @@ export declare class InjectorService extends Container {
      * @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
-     */
-    forkProvider(token: TokenProvider, settings?: Partial<IProvider<any>>): Provider;
     /**
      * Return a list of instance build by the injector.
      */
@@ -72,6 +70,11 @@ export declare class InjectorService extends Container {
      * @returns {boolean}
      */
     get<T = any>(token: TokenProvider, 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}
@@ -103,14 +106,19 @@ export declare class InjectorService extends Container {
     /**
      * Build only providers which are asynchronous.
      */
-    loadAsync(locals?: LocalsContainer<any>): Promise<LocalsContainer<any>>;
-    loadSync(locals?: LocalsContainer<any>): LocalsContainer<any>;
+    loadAsync(locals?: LocalsContainer): Promise<LocalsContainer<any>>;
+    loadSync(locals?: LocalsContainer): LocalsContainer<any>;
     /**
      * 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<LocalsContainer<any>>;
     /**
      * Build all providers from given container (or GlobalProviders) and emit `$onInit` event.
      *
@@ -134,19 +142,19 @@ export declare class InjectorService extends Container {
      * @param instance
      * @param {string} propertyKey
      */
-    bindMethod(instance: any, { propertyKey }: InjectablePropertyService): void;
+    bindMethod(instance: any, { propertyKey }: InjectablePropertyOptions): void;
     /**
      * Create an injectable property.
      *
      * @param instance
      * @param {string} propertyKey
      * @param {any} useType
-     * @param onGet
+     * @param resolver
      * @param options
      * @param locals
      * @param invokeOptions
      */
-    bindProperty(instance: any, { propertyKey, useType, onGet, options }: InjectablePropertyService, locals: Map<TokenProvider, any>, invokeOptions: Partial<InvokeOptions>): void;
+    bindProperty(instance: any, { propertyKey, resolver, options }: InjectablePropertyOptions, locals: Map<TokenProvider, any>, invokeOptions: Partial<InvokeOptions>): void;
     /**
      *
      * @param instance
@@ -160,7 +168,7 @@ export declare class InjectorService extends Container {
      * @param {string} propertyKey
      * @param {any} useType
      */
-    bindConstant(instance: any, { propertyKey, expression, defaultValue }: InjectablePropertyValue): PropertyDescriptor;
+    bindConstant(instance: any, { propertyKey, expression, defaultValue }: InjectablePropertyValue): void;
     /**
      *
      * @param instance
@@ -168,15 +176,30 @@ export declare class InjectorService extends Container {
      * @param useType
      * @param options
      */
-    bindInterceptor(instance: any, { propertyKey, useType, options }: InjectablePropertyService): void;
+    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 services.
+     * @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;
     /**
-     * Allow handler hack for AsyncHookContext plugin.
-     * @param ctx
-     * @param cb
-     * @protected
+     * @param eventName
+     * @param value
+     * @param args
      */
-    runInContext(ctx: DIContext, cb: any): any;
+    alterAsync<T = any>(eventName: string, value: any, ...args: any[]): Promise<T>;
+    destroy(): Promise<void>;
     protected ensureProvider(token: TokenProvider): Provider | undefined;
+    protected getInstance(token: any): any;
     /**
      * Invoke a class method and inject service.
      *

package/lib/types/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/{utils → 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/runInContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from "async_hooks";
+import { DIContext } from "../domain/DIContext";
+export declare function getAsyncStore(): AsyncLocalStorage<DIContext>;
+export declare function getContext(): DIContext | undefined;
+export declare function runInContext(ctx: DIContext, cb: any): unknown;

package/package.json

@@ -1,37 +1,53 @@
 {
   "name": "@tsed/di",
-  "version": "7.0.0-alpha.2",
+  "version": "7.0.0-beta.11",
   "description": "DI module for Ts.ED Framework",
   "private": false,
   "source": "./src/index.ts",
-  "main": "./lib/index.js",
-  "typings": "./lib/index.d.ts",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "typings": "./lib/types/index.d.ts",
   "exports": {
-    "require": "./lib/index.js",
-    "default": "./lib/index.modern.js"
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/esm/index.js",
+    "require": "./lib/cjs/index.js",
+    "default": "./lib/esm/index.js"
   },
   "scripts": {
-    "build": "microbundle --target node --no-compress --format modern,cjs --tsconfig ./tsconfig.compile.json"
+    "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",
+    "barrels": "yarn barrelsby --delete -d ./src -e \"\\.spec\\.ts\" -e \"__mock__\""
   },
   "dependencies": {
-    "@tsed/core": "7.0.0-alpha.2",
-    "chalk": "4.1.0",
-    "tslib": "2.2.0"
+    "tslib": "2.3.1"
   },
   "devDependencies": {
-    "@tsed/logger": "^5.16.0"
+    "@tsed/core": "7.0.0-beta.11",
+    "@tsed/logger": ">=6.1.1",
+    "@tsed/schema": "7.0.0-beta.11"
   },
   "peerDependencies": {
-    "@tsed/logger": "^5.16.0"
+    "@tsed/core": "^7.0.0-beta.11",
+    "@tsed/logger": ">=6.1.1",
+    "@tsed/schema": "^7.0.0-beta.11"
+  },
+  "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",
-  "publishConfig": {
-    "tag": "alpha"
-  }
+  "license": "MIT"
 }

package/readme.md

@@ -32,39 +32,36 @@ A package of Ts.ED framework. See website: https://tsed.io/
 # Installation
 
 You can get the latest release and the type definitions using npm:
+
 ```bash
 npm install --save @tsed/di
 ```
 
-> **Important!** TsExpressDecorators requires Node >= 6, Express >= 4, TypeScript >= 2.0 and 
-the `experimentalDecorators`, `emitDecoratorMetadata`, `types` and `lib` compilation 
-options in your `tsconfig.json` file.
+> **Important!** TsExpressDecorators requires Node >= 6, Express >= 4, TypeScript >= 2.0 and
+> the `experimentalDecorators`, `emitDecoratorMetadata`, `types` and `lib` compilation
+> options in your `tsconfig.json` file.
 
 ```json
 {
   "compilerOptions": {
     "target": "es2016",
     "lib": ["es2016"],
-    "typeRoots": [
-      "./node_modules/@types"
-    ],
+    "typeRoots": ["./node_modules/@types"],
     "module": "commonjs",
     "moduleResolution": "node",
-    "experimentalDecorators":true,
+    "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "allowSyntheticDefaultImports": true
   },
-  "exclude": [
-    "node_modules"
-  ]
+  "exclude": ["node_modules"]
 }
 ```
 
 ## Introduction
 
-Basically, almost everything may be considered as a provider – service, factory, intereceptors, and so on. 
+Basically, almost everything may be considered as a provider – service, factory, intereceptors, and so on.
 All of them can inject dependencies, meaning, they can create various relationships with each other.
- But in fact, a provider is nothing else than just a simple class annotated with an `@Injectable()` decorator.
+But in fact, a provider is nothing else than just a simple class annotated with an `@Injectable()` decorator.
 
 ## Usage
 
@@ -77,27 +74,28 @@ import {Calendar} from "./models/calendar";
 @Injectable()
 export class CalendarsService {
   private readonly calendars: Calendar[] = [];
-  
-    create(calendar: Calendar) {
-      this.calendars.push(calendar);
-    }
-  
-    findAll(): Calendar[] {
-      return this.calendars;
-    }
+
+  create(calendar: Calendar) {
+    this.calendars.push(calendar);
+  }
+
+  findAll(): Calendar[] {
+    return this.calendars;
+  }
 }
 ```
 
 Here's a CalendarsService, a basic class with one property and two methods. The only new trait is that it uses the `@Injectable()` decorator.
 The `@Injectable()` attaches the metadata, thereby Ts.ED knows that this class is a provider.
-  
+
 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 { CalendarsService } from './CalendarsService';
-import { Calendar } from './models/Calendar';
+import {Controller, Post, Body, Get} from "@tsed/common";
+import {CalendarsService} from "./CalendarsService";
+import {Calendar} from "./models/Calendar";
 
-@Controller('/calendars')
+@Controller("/calendars")
 export class CalendarCtrl {
   constructor(private readonly calendarsService: CalendarsService) {}
 
@@ -112,30 +110,31 @@ 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.
 
+> 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
 import {InjectorService} from "@tsed/di";
 import {CalendarCtrl} from "./CalendarCtrl";
 
 async function bootstrap() {
-  const injector = new InjectorService()
-  
+  const injector = new InjectorService();
+
   // Load all providers registered via @Injectable decorator
-  await injector.load()
-        
-  const calendarController = injector.get<CalendarCtrl>()
-  
-  await calendarController.create(new Calendar())
-  
+  await injector.load();
+
+  const calendarController = injector.get<CalendarCtrl>();
+
+  await calendarController.create(new Calendar());
+
   // And finally destroy injector and his instances (see injector hooks)
-  await injector.destroy()
+  await injector.destroy();
 }
 
-bootstrap()
+bootstrap();
 ```
 
 ## Custom providers
@@ -147,23 +146,20 @@ To organize your code Ts.ED DI provide different kind of providers:
 - Interceptor can be declared with `@Interceptor`,
 - Factory and Value can be declared with `registerProvider` and `registerValue`.
 
-
 See more details on our documentation https://tsed.io/providers.html
 
-
 ## Contributors
+
 Please read [contributing guidelines here](https://tsed.io/CONTRIBUTING.html)
 
 <a href="https://github.com/tsedio/ts-express-decorators/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
 
-
 ## Backers
 
 Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/tsed#backer)]
 
 <a href="https://opencollective.com/tsed#backers" target="_blank"><img src="https://opencollective.com/tsed/tiers/backer.svg?width=890"></a>
 
-
 ## Sponsors
 
 Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/tsed#sponsor)]

package/tsconfig.compile.esm.json

@@ -0,0 +1,25 @@
+{
+  "extends": "./tsconfig.compile.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "ES2020",
+    "rootDir": "src",
+    "outDir": "./lib/esm",
+    "declaration": true,
+    "declarationDir": "./lib/types"
+  },
+  "include": ["src"],
+  "exclude": [
+    "node_modules",
+    "test",
+    "lib",
+    "benchmark",
+    "coverage",
+    "spec",
+    "**/*.benchmark.ts",
+    "**/*.spec.ts",
+    "keys",
+    "jest.config.js",
+    "**/__mock__/**"
+  ]
+}

package/lib/decorators/index.d.ts

@@ -1,14 +0,0 @@
-export * from "./scope";
-export * from "./service";
-export * from "./overrideProvider";
-export * from "./inject";
-export * from "./injectable";
-export * from "./constant";
-export * from "./value";
-export * from "./intercept";
-export * from "./interceptor";
-export * from "./configuration";
-export * from "./module";
-export * from "./opts";
-export * from "./useOpts";
-export * from "./controller";

package/lib/decorators/inject.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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 symbol
- * @param onGet Use the given name method to inject
- * @returns {Function}
- * @decorator
- */
-export declare function Inject(symbol?: any, onGet?: (bean: any) => any): Function;

package/lib/domain/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./Container";
-export * from "./InjectablePropertyType";
-export * from "./LocalsContainer";
-export * from "./Provider";
-export * from "./ProviderScope";
-export * from "./ProviderType";
-export * from "./ContextLogger";
-export * from "./DIContext";

package/lib/index.d.ts

@@ -1,16 +0,0 @@
-export * from "./constants/index";
-export * from "./domain";
-export * from "./interfaces";
-export * from "./decorators";
-export * from "./registries/ProviderRegistry";
-export * from "./registries/GlobalProviders";
-export * from "./services/InjectorService";
-export * from "./services/DILogger";
-export * from "./services/DIConfiguration";
-export * from "./services/DITest";
-export * from "./errors/InjectionError";
-export * from "./errors/UndefinedTokenError";
-export * from "./utils/createContainer";
-export * from "./utils/getConfiguration";
-export * from "./utils/getConfiguration";
-export * from "./utils/setLoggerLevel";