fix(core): resolve conflicts

Author: kamilmysliwiec

integration/scopes/e2e/inject-inquirer.spec.ts

@@ -0,0 +1,64 @@
+import { INestApplication, Logger } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as request from 'supertest';
+import { HelloModule } from '../src/inject-inquirer/hello.module';
+
+describe('Inject Inquirer', () => {
+  let logger: Record<string, any>;
+  let server: any;
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    logger = { log: sinon.spy() };
+
+    const module = await Test.createTestingModule({
+      imports: [HelloModule],
+    })
+      .overrideProvider(Logger)
+      .useValue(logger)
+      .compile();
+
+    app = module.createNestApplication();
+    server = app.getHttpServer();
+    await app.init();
+  });
+
+  it(`should allow the injection of inquirer in a Transient Scope`, async () => {
+    await request(server).get('/hello/transient');
+
+    expect(
+      logger.log.calledWith({
+        message: 'Hello transient!',
+        feature: 'transient',
+      }),
+    ).to.be.true;
+  });
+
+  it(`should allow the injection of the inquirer in a Request Scope`, async () => {
+    await request(server).get('/hello/request');
+
+    expect(
+      logger.log.calledWith({
+        message: 'Hello request!',
+        requestId: sinon.match.string,
+        feature: 'request',
+      }),
+    ).to.be.true;
+
+    const requestId = logger.log.getCall(0).args[0].requestId;
+
+    expect(
+      logger.log.calledWith({
+        message: 'Goodbye request!',
+        requestId,
+        feature: 'request',
+      }),
+    );
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+});

integration/scopes/src/inject-inquirer/hello-request/hello-request.service.ts

@@ -0,0 +1,17 @@
+import { Injectable, Scope } from '@nestjs/common';
+import { RequestLogger } from './request-logger.service';
+
+@Injectable({ scope: Scope.REQUEST })
+export class HelloRequestService {
+  static logger = { feature: 'request' };
+
+  constructor(private readonly logger: RequestLogger) {}
+
+  greeting() {
+    this.logger.log('Hello request!');
+  }
+
+  farewell() {
+    this.logger.log('Goodbye request!');
+  }
+}

integration/scopes/src/inject-inquirer/hello-request/request-logger.service.ts

@@ -0,0 +1,26 @@
+import { Inject, Logger, Injectable, Scope } from '@nestjs/common';
+import { REQUEST, INQUIRER } from '@nestjs/core';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class RequestLogger {
+  config: object;
+
+  constructor(
+    @Inject(INQUIRER) { constructor },
+    @Inject(REQUEST) private readonly request,
+    private readonly logger: Logger,
+  ) {
+    this.config = (constructor && constructor.logger) || {};
+  }
+
+  get requestId() {
+    if (!this.request.id) {
+      this.request.id = `${Date.now()}.${Math.floor(Math.random() * 1000000)}`;
+    }
+    return this.request.id;
+  }
+
+  log(message: string) {
+    this.logger.log({ message, requestId: this.requestId, ...this.config });
+  }
+}

integration/scopes/src/inject-inquirer/hello-transient/hello-transient.service.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common';
+import { TransientLogger } from './transient-logger.service';
+
+@Injectable()
+export class HelloTransientService {
+  static logger = { feature: 'transient' };
+
+  constructor(private readonly logger: TransientLogger) {}
+
+  greeting() {
+    this.logger.log('Hello transient!');
+  }
+}

integration/scopes/src/inject-inquirer/hello-transient/transient-logger.service.ts

@@ -0,0 +1,19 @@
+import { Inject, Injectable, Logger, Scope } from '@nestjs/common';
+import { INQUIRER } from '@nestjs/core';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class TransientLogger {
+  // @Inject(INQUIRER) inquirer: any;
+  config: object;
+
+  constructor(
+    @Inject(INQUIRER) { constructor },
+    private readonly logger: Logger,
+  ) {
+    this.config = (constructor && constructor.logger) || {};
+  }
+
+  log(message: string) {
+    this.logger.log({ message, ...this.config });
+  }
+}

integration/scopes/src/inject-inquirer/hello.controller.ts

@@ -0,0 +1,25 @@
+import { Controller, Get, Scope } from '@nestjs/common';
+import { HelloRequestService } from './hello-request/hello-request.service';
+import { HelloTransientService } from './hello-transient/hello-transient.service';
+
+@Controller({
+  path: 'hello',
+  scope: Scope.REQUEST,
+})
+export class HelloController {
+  constructor(
+    private readonly helloTransientService: HelloTransientService,
+    private readonly helloRequestService: HelloRequestService,
+  ) {}
+
+  @Get('transient')
+  greetingTransient() {
+    this.helloTransientService.greeting();
+  }
+
+  @Get('request')
+  greetingRequest() {
+    this.helloRequestService.greeting();
+    this.helloRequestService.farewell();
+  }
+}

integration/scopes/src/inject-inquirer/hello.module.ts

@@ -0,0 +1,18 @@
+import { Module, Logger } from '@nestjs/common';
+import { HelloController } from './hello.controller';
+import { HelloRequestService } from './hello-request/hello-request.service';
+import { HelloTransientService } from './hello-transient/hello-transient.service';
+import { RequestLogger } from './hello-request/request-logger.service';
+import { TransientLogger } from './hello-transient/transient-logger.service';
+
+@Module({
+  controllers: [HelloController],
+  providers: [
+    HelloRequestService,
+    HelloTransientService,
+    RequestLogger,
+    TransientLogger,
+    Logger,
+  ],
+})
+export class HelloModule {}

packages/core/injector/index.ts

@@ -2,3 +2,4 @@ export * from './container';
 export { ContextId } from './instance-wrapper';
 export * from './module-ref';
 export * from './modules-container';
+export * from './inquirer';

packages/core/injector/injector.ts

@@ -19,6 +19,7 @@ import { RuntimeException } from '../errors/exceptions/runtime.exception';
 import { UndefinedDependencyException } from '../errors/exceptions/undefined-dependency.exception';
 import { UnknownDependenciesException } from '../errors/exceptions/unknown-dependencies.exception';
 import { STATIC_CONTEXT } from './constants';
+import { INQUIRER } from './inquirer';
 import {
   ContextId,
   InstancePerContext,
@@ -218,6 +219,7 @@ export class Injector {
       callback,
       contextId,
       wrapper,
+      inquirer,
     );
   }
 
@@ -228,11 +230,17 @@ export class Injector {
     callback: (args: any[]) => void,
     contextId = STATIC_CONTEXT,
     inquirer?: InstanceWrapper,
+    parentInquirer?: InstanceWrapper,
   ) {
     const inquirerId = this.getInquirerId(inquirer);
     const metadata = wrapper.getCtorMetadata();
     if (metadata && contextId !== STATIC_CONTEXT) {
-      const deps = await this.loadCtorMetadata(metadata, contextId, inquirer);
+      const deps = await this.loadCtorMetadata(
+        metadata,
+        contextId,
+        inquirer,
+        parentInquirer,
+      );
       return callback(deps);
     }
     const dependencies = isNil(inject)
@@ -245,6 +253,9 @@ export class Injector {
     let isResolved = true;
     const resolveParam = async (param: unknown, index: number) => {
       try {
+        if (this.isInquirer(param, parentInquirer)) {
+          return parentInquirer && parentInquirer.instance;
+        }
         const paramWrapper = await this.resolveSingleParam<T>(
           wrapper,
           param,
@@ -666,10 +677,16 @@ export class Injector {
     metadata: InstanceWrapper<any>[],
     contextId: ContextId,
     inquirer?: InstanceWrapper,
+    parentInquirer?: InstanceWrapper,
   ): Promise<any[]> {
     const hosts = await Promise.all(
       metadata.map(async item =>
-        this.resolveComponentHost(item.host, item, contextId, inquirer),
+        this.resolveScopedComponentHost(
+          item,
+          contextId,
+          inquirer,
+          parentInquirer,
+        ),
       ),
     );
     const inquirerId = this.getInquirerId(inquirer);
@@ -705,4 +722,29 @@ export class Injector {
   private getInquirerId(inquirer: InstanceWrapper | undefined): string {
     return inquirer && inquirer.id;
   }
+
+  private resolveScopedComponentHost(
+    item: InstanceWrapper,
+    contextId: ContextId,
+    inquirer?: InstanceWrapper,
+    parentInquirer?: InstanceWrapper,
+  ) {
+    return this.isInquirerRequest(item, parentInquirer)
+      ? parentInquirer
+      : this.resolveComponentHost(item.host, item, contextId, inquirer);
+  }
+
+  private isInquirerRequest(
+    item: InstanceWrapper,
+    parentInquirer: InstanceWrapper | undefined,
+  ) {
+    return item.isTransient && item.name === INQUIRER && parentInquirer;
+  }
+
+  private isInquirer(
+    param: unknown,
+    parentInquirer: InstanceWrapper | undefined,
+  ) {
+    return param === INQUIRER && parentInquirer;
+  }
 }

packages/core/injector/inquirer/index.ts

@@ -0,0 +1 @@
+export * from './inquirer-constants';