update(@nestjs/core & @nestjs/common) injector improvements, forwardRef

Author: kamilmysliwiec

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 4.1.1
+- **common**: add `forwardRef()` util
+- **core**: improve injector & dependencies scanner
+
 ## 4.1.0
 - **common**: add `@Bind()` and `@Dependencies()` decorators to fix route parameters decorators (pure JavaScript compatibility issue)
 - **core**: improve performance

src/common/test/utils/bind.decorator.spec.ts

@@ -0,0 +1,26 @@
+import 'reflect-metadata';
+import { expect } from 'chai';
+import { Bind } from '../../utils/decorators/bind.decorator';
+import { ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
+import { Req } from '../../utils/decorators/route-params.decorator';
+
+describe('@Bind', () => {
+    class TestWithMethod {
+        @Bind(Req())
+        public test() {}
+    }
+
+    it('should enhance method - bind each decorator to method', () => {
+      const test = new TestWithMethod();
+      const metadata = Reflect.getMetadata(ROUTE_ARGS_METADATA, test, 'test');
+
+      expect(metadata).to.be.deep.equal({
+          '0:0': {
+            data: undefined,
+            index: 0,
+            pipes: [],
+          },
+        });
+    });
+
+});

src/common/test/utils/forward-ref.util.spec.ts

@@ -0,0 +1,10 @@
+import { expect } from 'chai';
+import { forwardRef } from './../../utils/forward-ref.util';
+
+describe('forwardRef', () => {
+  it('should return object with forwardRef property', () => {
+    const fn = () => ({});
+    const referenceFn = forwardRef(() => fn);
+    expect(referenceFn.forwardRef()).to.be.eql(fn);
+  });
+});

src/common/utils/forward-ref.util.ts

@@ -0,0 +1,5 @@
+import { isFunction } from './shared.utils';
+
+export function forwardRef(fn: () => any) {
+  return { forwardRef: fn };
+}

src/common/utils/index.ts

@@ -14,4 +14,5 @@ export * from './decorators/use-guards.decorator';
 export * from './decorators/reflect-metadata.decorator';
 export * from './decorators/use-interceptors.decorator';
 export * from './decorators/http-code.decorator';
-export * from './decorators/bind.decorator';
+export * from './decorators/bind.decorator';
+export * from './forward-ref.util';

src/core/errors/messages.ts

@@ -2,7 +2,7 @@ export const InvalidMiddlewareMessage = (name: string) =>
     `The middleware doesn't provide the 'resolve' method (${name})`;
 
 export const InvalidModuleMessage = (scope: string) =>
-    `Nest can't create the module instance. The frequent reason of this exception is the circular dependency between modules. Scope [${scope}]`;
+    `Nest can't create the module instance. The frequent reason of this exception is the circular dependency between modules. Use forwardRef() to avoid it (read more https://docs.nestjs.com/advanced/circular-dependency). Scope [${scope}]`;
 
 export const UnknownDependenciesMessage = (type: string) =>
     `Nest can't resolve dependencies of the ${type}. Please verify whether all of them are available in the current context.`;

src/core/injector/container.ts

@@ -50,12 +50,12 @@ export class NestContainer {
         module.addComponent(component);
     }
 
-    public addInjectable(Injectable: Metatype<Injectable>, token: string) {
+    public addInjectable(injectable: Metatype<Injectable>, token: string) {
         if (!this.modules.has(token)) {
             throw new UnknownModuleException();
         }
         const module = this.modules.get(token);
-        module.addInjectable(Injectable);
+        module.addInjectable(injectable);
     }
 
 
@@ -95,5 +95,6 @@ export interface InstanceWrapper<T> {
     done$?: Promise<void>;
     inject?: Metatype<any>[];
     isNotMetatype?: boolean;
+    forwardRef?: boolean;
     async?: boolean;
 }

src/core/injector/injector.ts

@@ -102,7 +102,7 @@ export class Injector {
 
         const instances = await Promise.all(args.map(async (param) => {
             const paramWrapper = await this.resolveSingleParam<T>(wrapper, param, module, context);
-            if (!paramWrapper.isResolved) {
+            if (!paramWrapper.isResolved && !paramWrapper.forwardRef) {
                 isResolved = false;
             }
             return paramWrapper.instance;
@@ -124,16 +124,18 @@ export class Injector {
 
     public async resolveSingleParam<T>(
         wrapper: InstanceWrapper<T>,
-        param: Metatype<any> | string | symbol,
+        param: Metatype<any> | string | symbol | any,
         module: Module,
         context: Module[]) {
 
         if (isUndefined(param)) {
             throw new UndefinedDependencyException(wrapper.name);
         }
+        const token = param.forwardRef ? param.forwardRef() : param;
+        wrapper.forwardRef = true;
         return await this.resolveComponentInstance<T>(
             module,
-            isFunction(param) ? (param as Metatype<any>).name : param,
+            isFunction(token) ? (token as Metatype<any>).name : token,
             wrapper,
             context,
         );
@@ -143,7 +145,7 @@ export class Injector {
         const components = module.components;
         const instanceWrapper = await this.scanForComponent(components, name, module, wrapper, context);
 
-        if (!instanceWrapper.isResolved) {
+        if (!instanceWrapper.isResolved && !instanceWrapper.forwardRef) {
             await this.loadInstanceOfComponent(instanceWrapper, module);
         }
         if (instanceWrapper.async) {
@@ -183,7 +185,7 @@ export class Injector {
             const component = await this.scanForComponent(
                 context.components, name, context, { metatype }, null,
             );
-            if (!component.isResolved) {
+            if (!component.isResolved && !component.forwardRef) {
                 await this.loadInstanceOfComponent(component, context);
             }
             return component;
@@ -207,7 +209,7 @@ export class Injector {
                 continue;
             }
             component = components.get(name);
-            if (!component.isResolved) {
+            if (!component.isResolved && !component.forwardRef) {
                 const ctx = isInScope ? [module] : [].concat(context, module);
                 await this.loadInstanceOfComponent(component, relatedModule, ctx);
                 break;

src/core/scanner.ts

@@ -27,7 +27,10 @@ export class DependenciesScanner {
         });
     }
 
-    public storeModule(module: NestModuleMetatype, scope: NestModuleMetatype[]) {
+    public storeModule(module: any, scope: NestModuleMetatype[]) {
+        if (module.forwardRef) {
+            return this.container.addModule(module.forwardRef(), scope);
+        }
         this.container.addModule(module, scope);
     }
 
@@ -108,7 +111,10 @@ export class DependenciesScanner {
         return descriptor ? Reflect.getMetadata(key, descriptor.value) : undefined;
     }
 
-    public storeRelatedModule(related: NestModuleMetatype, token: string) {
+    public storeRelatedModule(related: any, token: string) {
+        if (related.forwardRef) {
+            return this.container.addRelatedModule(related.forwardRef(), token);
+        }
         this.container.addRelatedModule(related, token);
     }
 
@@ -131,5 +137,4 @@ export class DependenciesScanner {
     public reflectMetadata(metatype, metadata: string) {
         return Reflect.getMetadata(metadata, metatype) || [];
     }
-
 }

src/core/test/scanner.spec.ts

@@ -121,4 +121,24 @@ describe('DependenciesScanner', () => {
         expect(result).to.be.eql(['test']);
       });
     });
+
+    describe('storeModule', () => {
+      it('should call forwardRef() when forwardRef property exists', () => {
+        const module = { forwardRef: sinon.spy() };
+
+        sinon.stub(container, 'addModule').returns({});
+        scanner.storeModule(module as any, [] as any);
+        expect(module.forwardRef.called).to.be.true;
+      });
+    });
+
+    describe('storeRelatedModule', () => {
+      it('should call forwardRef() when forwardRef property exists', () => {
+        const module = { forwardRef: sinon.stub().returns({}) };
+
+        sinon.stub(container, 'addRelatedModule').returns({});
+        scanner.storeRelatedModule(module as any, [] as any);
+        expect(module.forwardRef.called).to.be.true;
+      });
+    });
 });