feat(core): request-scoped custom providers improvements

Author: kamilmysliwiec

integration/scopes/src/request-chain/helper/helper.service.ts

@@ -1,6 +1,9 @@
-import { Injectable, Scope } from '@nestjs/common';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
 
 @Injectable({ scope: Scope.REQUEST })
 export class HelperService {
+  constructor(@Inject(REQUEST) public readonly request) {}
+
   public noop() {}
 }

integration/scopes/src/request-chain/interceptors/logging.interceptor.ts

@@ -0,0 +1,21 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { HelperService } from '../helper/helper.service';
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  constructor(private readonly helperSvc: HelperService) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    this.helperSvc.noop();
+    if (!this.helperSvc.request) {
+      throw new Error('error');
+    }
+    return next.handle();
+  }
+}

integration/scopes/src/request-chain/request-chain.controller.ts

@@ -1,10 +1,12 @@
-import { Controller, Get } from '@nestjs/common';
+import { Controller, Get, UseInterceptors } from '@nestjs/common';
+import { LoggingInterceptor } from './interceptors/logging.interceptor';
 import { RequestChainService } from './request-chain.service';
 
 @Controller('hello')
 export class RequestChainController {
   constructor(private readonly chainService: RequestChainService) {}
 
+  @UseInterceptors(LoggingInterceptor)
   @Get()
   greeting(): void {
     this.chainService.call();

packages/core/helpers/get-class-scope.ts

@@ -0,0 +1,8 @@
+import { Scope } from '@nestjs/common';
+import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+
+export function getClassScope(provider: Type<unknown>): Scope {
+  const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, provider);
+  return metadata && metadata.scope;
+}

packages/core/injector/injector.ts

@@ -194,7 +194,7 @@ export class Injector {
     if (instanceHost.isResolved) {
       return done();
     }
-    const callback = async (instances: any[]) => {
+    const callback = async (instances: unknown[]) => {
       const properties = await this.resolveProperties(
         wrapper,
         module,
@@ -228,7 +228,7 @@ export class Injector {
     wrapper: InstanceWrapper<T>,
     module: Module,
     inject: InjectorDependency[],
-    callback: (args: any[]) => void,
+    callback: (args: unknown[]) => void,
     contextId = STATIC_CONTEXT,
     inquirer?: InstanceWrapper,
     parentInquirer?: InstanceWrapper,

packages/core/injector/module.ts

@@ -1,5 +1,3 @@
-import { Scope } from '@nestjs/common';
-import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
 import {
   Abstract,
   ClassProvider,
@@ -26,6 +24,7 @@ import { InvalidClassException } from '../errors/exceptions/invalid-class.except
 import { RuntimeException } from '../errors/exceptions/runtime.exception';
 import { UnknownExportException } from '../errors/exceptions/unknown-export.exception';
 import { createContextId } from '../helpers';
+import { getClassScope } from '../helpers/get-class-scope';
 import { CONTROLLER_ID_KEY } from './constants';
 import { NestContainer } from './container';
 import { InstanceWrapper } from './instance-wrapper';
@@ -184,7 +183,7 @@ export class Module {
         metatype: injectable,
         instance: null,
         isResolved: false,
-        scope: this.getClassScope(injectable),
+        scope: getClassScope(injectable),
         host: this,
       });
       this._injectables.set(injectable.name, instanceWrapper);
@@ -208,7 +207,7 @@ export class Module {
         metatype: provider as Type<Injectable>,
         instance: null,
         isResolved: false,
-        scope: this.getClassScope(provider),
+        scope: getClassScope(provider),
         host: this,
       }),
     );
@@ -286,7 +285,7 @@ export class Module {
 
     let { scope } = provider;
     if (isUndefined(scope)) {
-      scope = this.getClassScope(useClass);
+      scope = getClassScope(useClass);
     }
     collection.set(
       name as string,
@@ -413,7 +412,7 @@ export class Module {
         metatype: controller,
         instance: null,
         isResolved: false,
-        scope: this.getClassScope(controller),
+        scope: getClassScope(controller),
         host: this,
       }),
     );
@@ -506,9 +505,4 @@ export class Module {
       }
     };
   }
-
-  private getClassScope(provider: Type<unknown>): Scope {
-    const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, provider);
-    return metadata && metadata.scope;
-  }
 }

packages/core/scanner.ts

@@ -36,6 +36,7 @@ import {
 import { ApplicationConfig } from './application-config';
 import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from './constants';
 import { CircularDependencyException } from './errors/exceptions/circular-dependency.exception';
+import { getClassScope } from './helpers/get-class-scope';
 import { ModulesContainer } from './injector';
 import { NestContainer } from './injector/container';
 import { InstanceWrapper } from './injector/instance-wrapper';
@@ -311,21 +312,27 @@ export class DependenciesScanner {
       return this.container.addProvider(provider as any, token);
     }
     const providerToken = `${type as string} (UUID: ${randomStringGenerator()})`;
+
+    let scope = (provider as ClassProvider | FactoryProvider).scope;
+    if (isNil(scope) && (provider as ClassProvider).useClass) {
+      scope = getClassScope((provider as ClassProvider).useClass);
+    }
     this.applicationProvidersApplyMap.push({
       type,
       moduleKey: token,
       providerKey: providerToken,
-      scope: (provider as ClassProvider | FactoryProvider).scope,
+      scope,
     });
 
     const newProvider = {
       ...provider,
       provide: providerToken,
+      scope,
     } as Provider;
 
     if (
       this.isRequestOrTransient(
-        (provider as FactoryProvider | ClassProvider).scope,
+        (newProvider as FactoryProvider | ClassProvider).scope,
       )
     ) {
       return this.container.addInjectable(newProvider, token);