fix(core): fix typings, transient scope through resolve

Author: kamilmysliwiec

integration/injector/e2e/scoped-instances.spec.ts

@@ -1,3 +1,4 @@
+import { createContextId } from '@nestjs/core';
 import { InvalidClassScopeException } from '@nestjs/core/errors/exceptions/invalid-class-scope.exception';
 import { Test, TestingModule } from '@nestjs/testing';
 import { expect } from 'chai';
@@ -16,8 +17,9 @@ describe('Scoped Instances', () => {
   });
 
   it('should dynamically resolve transient provider', async () => {
-    const transient1 = await testingModule.resolve(TransientService);
-    const transient2 = await testingModule.resolve(TransientService);
+    const contextId = createContextId();
+    const transient1 = await testingModule.resolve(TransientService, contextId);
+    const transient2 = await testingModule.resolve(TransientService, contextId);
 
     expect(transient1).to.be.instanceOf(TransientService);
     expect(transient2).to.be.instanceOf(TransientService);

integration/injector/src/scoped/scoped.module.ts

@@ -2,9 +2,10 @@ import { Module } from '@nestjs/common';
 import { ScopedController } from './scoped.controller';
 import { ScopedService } from './scoped.service';
 import { TransientService } from './transient.service';
+import { Transient2Service } from './transient2.service';
 
 @Module({
   controllers: [ScopedController],
-  providers: [ScopedService, TransientService],
+  providers: [ScopedService, TransientService, Transient2Service],
 })
 export class ScopedModule {}

integration/injector/src/scoped/transient.service.ts

@@ -1,4 +1,7 @@
 import { Injectable, Scope } from '@nestjs/common';
+import { Transient2Service } from './transient2.service';
 
 @Injectable({ scope: Scope.TRANSIENT })
-export class TransientService {}
+export class TransientService {
+  constructor(private readonly svc: Transient2Service) {}
+}

integration/injector/src/scoped/transient2.service.ts

@@ -0,0 +1,4 @@
+import { Injectable, Scope } from '@nestjs/common';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class Transient2Service {}

integration/scopes/e2e/resolve-scoped.spec.ts

@@ -0,0 +1,39 @@
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+import { loggerProvider } from '../src/resolve-scoped/logger.provider';
+import { LoggerService } from '../src/resolve-scoped/logger.service';
+import { RequestLoggerService } from '../src/resolve-scoped/request-logger.service';
+
+describe('Resolve method', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      providers: [LoggerService, loggerProvider, RequestLoggerService],
+    }).compile();
+
+    app = module.createNestApplication();
+    await app.init();
+  });
+
+  it('should resolve transient logger', async () => {
+    const transientLogger = await app.resolve(LoggerService);
+    expect(transientLogger.logger).to.be.eql({
+      logger: true,
+    });
+  });
+
+  it('should resolve request-scoped logger', async () => {
+    const requestScoped = await app.resolve(RequestLoggerService);
+
+    expect(requestScoped.loggerService).to.be.instanceOf(LoggerService);
+    expect(requestScoped.loggerService.logger).to.be.eql({
+      logger: true,
+    });
+  });
+
+  after(async () => {
+    await app.close();
+  });
+});

integration/scopes/src/resolve-scoped/logger.provider.ts

@@ -0,0 +1,9 @@
+import { FactoryProvider } from '@nestjs/common/interfaces';
+
+export const LOGGER_PROVIDER = 'LOGGER_PROVIDER';
+export const loggerProvider: FactoryProvider = {
+  provide: LOGGER_PROVIDER,
+  useFactory: () => {
+    return { logger: true };
+  },
+};

integration/scopes/src/resolve-scoped/logger.service.ts

@@ -0,0 +1,7 @@
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { LOGGER_PROVIDER } from './logger.provider';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class LoggerService {
+  constructor(@Inject(LOGGER_PROVIDER) public logger) {}
+}

integration/scopes/src/resolve-scoped/request-logger.service.ts

@@ -0,0 +1,7 @@
+import { Injectable, Scope } from '@nestjs/common';
+import { LoggerService } from './logger.service';
+
+@Injectable({ scope: Scope.REQUEST })
+export class RequestLoggerService {
+  constructor(public loggerService: LoggerService) {}
+}

packages/core/helpers/http-adapter-host.ts

@@ -15,7 +15,7 @@ import { AbstractHttpAdapter } from '../adapters/http-adapter';
 export class HttpAdapterHost<
   T extends AbstractHttpAdapter = AbstractHttpAdapter
 > {
-  private _httpAdapter: T;
+  private _httpAdapter?: T;
 
   /**
    * Accessor for the underlying `HttpAdapter`
@@ -32,7 +32,7 @@ export class HttpAdapterHost<
    * @example
    * `const httpAdapter = adapterHost.httpAdapter;`
    */
-  get httpAdapter(): T | undefined {
+  get httpAdapter(): T {
     return this._httpAdapter;
   }
 }

packages/core/injector/injector.ts

@@ -633,7 +633,12 @@ export class Injector {
     const isStatic = wrapper.isStatic(contextId, inquirer);
     const isInRequestScope = wrapper.isInRequestScope(contextId, inquirer);
     const isLazyTransient = wrapper.isLazyTransient(contextId, inquirer);
-    const isInContext = isStatic || isInRequestScope || isLazyTransient;
+    const isExplicitlyRequested = wrapper.isExplicitlyRequested(
+      contextId,
+      inquirer,
+    );
+    const isInContext =
+      isStatic || isInRequestScope || isLazyTransient || isExplicitlyRequested;
 
     if (isNil(inject) && isInContext) {
       instanceHost.instance = wrapper.forwardRef
@@ -664,7 +669,7 @@ export class Injector {
     await this.loadInstance(wrapper, collection, module, ctx, wrapper);
     await this.loadEnhancersPerContext(wrapper, ctx, wrapper);
 
-    const host = wrapper.getInstanceByContextId(ctx);
+    const host = wrapper.getInstanceByContextId(ctx, wrapper.id);
     return host && (host.instance as T);
   }