Merge pull request nestjs#903 from nestjs/feature/module-ref

feature(@nestjs/core) expose container to ModuleRef, add close()

Author: kamilmysliwiec

package.json

@@ -137,6 +137,7 @@
       "packages/microservices/exceptions/",
       "packages/microservices/microservices-module.ts",
       "packages/core/middleware/middleware-module.ts",
+      "packages/core/injector/module-ref.ts",
       "packages/common/services/logger.service.ts"
     ],
     "extension": [

packages/common/interfaces/nest-application-context.interface.ts

@@ -1,5 +1,4 @@
 import { Type } from './type.interface';
-import { LoggerService } from '../services/logger.service';
 
 export interface INestApplicationContext {
   /**
@@ -10,10 +9,17 @@ export interface INestApplicationContext {
 
   /**
    * Retrieves an instance of either injectable or controller available anywhere, otherwise, throws exception.
-   * @returns {T}
+   * @returns {TResult}
    */
-  get<T>(
-    typeOrToken: Type<T> | string | symbol,
+  get<TInput = any, TResult = TInput>(
+    typeOrToken: Type<TInput> | string | symbol,
     options?: { strict: boolean },
-  ): T;
+  ): TResult;
+
+  /**
+   * Terminates the application
+   *
+   * @returns {Promise<void>}
+   */
+  close(): Promise<void>;
 }

packages/core/exceptions/base-exception-filter-context.ts

@@ -1,11 +1,11 @@
 import { FILTER_CATCH_EXCEPTIONS } from '@nestjs/common/constants';
+import { Type } from '@nestjs/common/interfaces';
 import { ExceptionFilter } from '@nestjs/common/interfaces/exceptions/exception-filter.interface';
-import { Type } from '@nestjs/common/interfaces/index';
 import { isEmpty, isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
 import iterate from 'iterare';
 import 'reflect-metadata';
+import { ContextCreator } from '../helpers/context-creator';
 import { NestContainer } from '../injector/container';
-import { ContextCreator } from './../helpers/context-creator';
 
 export class BaseExceptionFilterContext extends ContextCreator {
   protected moduleContext: string;

packages/core/guards/guards-context-creator.ts

@@ -1,17 +1,12 @@
-import 'reflect-metadata';
-import iterate from 'iterare';
-import { Controller } from '@nestjs/common/interfaces';
-import { GUARDS_METADATA } from '@nestjs/common/constants';
-import {
-  isUndefined,
-  isFunction,
-  isNil,
-  isEmpty,
-} from '@nestjs/common/utils/shared.utils';
-import { ContextCreator } from './../helpers/context-creator';
-import { NestContainer } from '../injector/container';
 import { CanActivate } from '@nestjs/common';
+import { GUARDS_METADATA } from '@nestjs/common/constants';
+import { Controller } from '@nestjs/common/interfaces';
 import { ConfigurationProvider } from '@nestjs/common/interfaces/configuration-provider.interface';
+import { isEmpty, isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
+import iterate from 'iterare';
+import 'reflect-metadata';
+import { ContextCreator } from '../helpers/context-creator';
+import { NestContainer } from '../injector/container';
 
 export class GuardsContextCreator extends ContextCreator {
   private moduleContext: string;

packages/core/helpers/context-creator.ts

@@ -1,8 +1,5 @@
-import 'reflect-metadata';
-import iterate from 'iterare';
 import { Controller } from '@nestjs/common/interfaces';
-import { isUndefined, isFunction } from '@nestjs/common/utils/shared.utils';
-import { ApplicationConfig } from './../application-config';
+import 'reflect-metadata';
 
 export abstract class ContextCreator {
   public abstract createConcreteContext<T extends any[], R extends any[]>(

packages/core/helpers/external-context-creator.ts

@@ -1,13 +1,13 @@
-import 'reflect-metadata';
-import { GuardsContextCreator } from './../guards/guards-context-creator';
-import { GuardsConsumer } from './../guards/guards-consumer';
-import { InterceptorsContextCreator } from './../interceptors/interceptors-context-creator';
-import { InterceptorsConsumer } from './../interceptors/interceptors-consumer';
+import { ForbiddenException } from '@nestjs/common';
 import { Controller } from '@nestjs/common/interfaces';
+import 'reflect-metadata';
 import { FORBIDDEN_MESSAGE } from '../guards/constants';
-import { ForbiddenException } from '@nestjs/common';
-import { Module } from './../injector/module';
-import { ModulesContainer } from './../injector/modules-container';
+import { GuardsConsumer } from '../guards/guards-consumer';
+import { GuardsContextCreator } from '../guards/guards-context-creator';
+import { Module } from '../injector/module';
+import { ModulesContainer } from '../injector/modules-container';
+import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
+import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
 
 export class ExternalContextCreator {
   constructor(

packages/core/injector/container.ts

@@ -2,9 +2,9 @@ import { DynamicModule } from '@nestjs/common';
 import { GLOBAL_MODULE_METADATA } from '@nestjs/common/constants';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import 'reflect-metadata';
+import { ApplicationConfig } from '../application-config';
+import { InvalidModuleException } from '../errors/exceptions/invalid-module.exception';
 import { UnknownModuleException } from '../errors/exceptions/unknown-module.exception';
-import { ApplicationConfig } from './../application-config';
-import { InvalidModuleException } from './../errors/exceptions/invalid-module.exception';
 import { ModuleCompiler } from './compiler';
 import { Module } from './module';
 import { ModulesContainer } from './modules-container';

packages/core/injector/injector.ts

@@ -5,9 +5,9 @@ import { Type } from '@nestjs/common/interfaces/type.interface';
 import { isFunction, isNil, isUndefined } from '@nestjs/common/utils/shared.utils';
 import 'reflect-metadata';
 import { RuntimeException } from '../errors/exceptions/runtime.exception';
+import { UndefinedDependencyException } from '../errors/exceptions/undefined-dependency.exception';
 import { UnknownDependenciesException } from '../errors/exceptions/unknown-dependencies.exception';
 import { MiddlewareWrapper } from '../middleware/container';
-import { UndefinedDependencyException } from './../errors/exceptions/undefined-dependency.exception';
 import { InstanceWrapper } from './container';
 import { Module } from './module';
 

packages/core/injector/module-ref.ts

@@ -1,5 +1,65 @@
-import { OpaqueToken } from './module';
+import { Type } from '@nestjs/common';
+import { isFunction } from '@nestjs/common/utils/shared.utils';
+import { UnknownElementException } from '../errors/exceptions/unknown-element.exception';
+import { InstanceWrapper, NestContainer } from './container';
+import { Module } from './module';
 
 export abstract class ModuleRef {
-  public abstract get<T>(type: OpaqueToken): T;
+  private flattenModuleFixture: Partial<Module>;
+
+  constructor(protected readonly container: NestContainer) {}
+
+  public abstract get<TInput = any, TResult = TInput>(
+    typeOrToken: Type<TInput> | string | symbol,
+    options?: { strict: boolean },
+  ): TResult;
+
+  protected find<TInput = any, TResult = TInput>(
+    typeOrToken: Type<TInput> | string | symbol,
+  ): TResult {
+    this.initFlattenModule();
+    return this.findInstanceByPrototypeOrToken<TInput, TResult>(
+      typeOrToken,
+      this.flattenModuleFixture,
+    );
+  }
+
+  protected findInstanceByPrototypeOrToken<TInput = any, TResult = TInput>(
+    metatypeOrToken: Type<TInput> | string | symbol,
+    contextModule: Partial<Module>,
+  ): TResult {
+    const dependencies = new Map([
+      ...contextModule.components,
+      ...contextModule.routes,
+      ...contextModule.injectables,
+    ]);
+    const name = isFunction(metatypeOrToken)
+      ? (metatypeOrToken as any).name
+      : metatypeOrToken;
+    const instanceWrapper = dependencies.get(name);
+    if (!instanceWrapper) {
+      throw new UnknownElementException();
+    }
+    return (instanceWrapper as InstanceWrapper<any>).instance;
+  }
+
+  private initFlattenModule() {
+    if (this.flattenModuleFixture) {
+      return void 0;
+    }
+    const modules = this.container.getModules();
+    const initialValue = {
+      components: [],
+      routes: [],
+      injectables: [],
+    };
+    this.flattenModuleFixture = [...modules.values()].reduce(
+      (flatten, curr) => ({
+        components: [...flatten.components, ...curr.components],
+        routes: [...flatten.routes, ...curr.routes],
+        injectables: [...flatten.injectables, ...curr.injectables],
+      }),
+      initialValue,
+    ) as any;
+  }
 }

packages/core/injector/module.ts

@@ -3,12 +3,12 @@ import { Type } from '@nestjs/common/interfaces/type.interface';
 import { isFunction, isNil, isString, isSymbol, isUndefined } from '@nestjs/common/utils/shared.utils';
 import { RuntimeException } from '../errors/exceptions/runtime.exception';
 import { UnknownExportException } from '../errors/exceptions/unknown-export.exception';
+import { GuardsConsumer } from '../guards/guards-consumer';
+import { GuardsContextCreator } from '../guards/guards-context-creator';
+import { ExternalContextCreator } from '../helpers/external-context-creator';
+import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
+import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
 import { Reflector } from '../services/reflector.service';
-import { GuardsConsumer } from './../guards/guards-consumer';
-import { GuardsContextCreator } from './../guards/guards-context-creator';
-import { ExternalContextCreator } from './../helpers/external-context-creator';
-import { InterceptorsConsumer } from './../interceptors/interceptors-consumer';
-import { InterceptorsContextCreator } from './../interceptors/interceptors-context-creator';
 import { InstanceWrapper, NestContainer } from './container';
 import { ModuleRef } from './module-ref';
 import { ModulesContainer } from './modules-container';
@@ -41,7 +41,7 @@ export class Module {
   constructor(
     private readonly _metatype: Type<any>,
     private readonly _scope: Type<any>[],
-    container: NestContainer,
+    private readonly container: NestContainer,
   ) {
     this.addCoreInjectables(container);
   }
@@ -92,7 +92,7 @@ export class Module {
   }
 
   public addModuleRef() {
-    const moduleRef = this.createModuleRefMetatype(this._components);
+    const moduleRef = this.createModuleRefMetatype();
     this._components.set(ModuleRef.name, {
       name: ModuleRef.name,
       metatype: ModuleRef as any,
@@ -324,15 +324,24 @@ export class Module {
     });
   }
 
-  public createModuleRefMetatype(components) {
-    return class {
-      public readonly components = components;
-
-      public get<T>(type: OpaqueToken): T {
-        const name = isFunction(type) ? (type as Type<any>).name : type;
-        const exists = this.components.has(name);
+  public createModuleRefMetatype(): any {
+    const self = this;
+    return class extends ModuleRef {
+      constructor() {
+        super(self.container);
+      }
 
-        return exists ? (this.components.get(name).instance as T) : null;
+      public get<TInput = any, TResult = TInput>(
+        typeOrToken: Type<TInput> | string | symbol,
+        options: { strict: boolean } = { strict: true },
+      ): TResult {
+        if (!(options && options.strict)) {
+          return this.find<TInput, TResult>(typeOrToken);
+        }
+        return this.findInstanceByPrototypeOrToken<TInput, TResult>(
+          typeOrToken,
+          self,
+        );
       }
     };
   }