Merge branch '5.4.1' of https://github.com/nestjs/nest into 5.4.1

Author: kamilmysliwiec

packages/common/cache/interceptors/cache.interceptor.ts

@@ -1,32 +1,22 @@
 import { Observable, of } from 'rxjs';
 import { tap } from 'rxjs/operators';
 import { Inject, Injectable, Optional } from '../../decorators';
-import {
-  ExecutionContext,
-  HttpServer,
-  NestInterceptor,
-} from '../../interfaces';
+import { ExecutionContext, NestInterceptor } from '../../interfaces';
 import { CACHE_KEY_METADATA, CACHE_MANAGER } from '../cache.constants';
 
-// NOTE (external)
-// We need to deduplicate them here due to the circular dependency
-// between core and common packages
-const HTTP_SERVER_REF = 'HTTP_SERVER_REF';
+const APPLICATION_REFERENCE_HOST = 'ApplicationReferenceHost';
 const REFLECTOR = 'Reflector';
 
 @Injectable()
 export class CacheInterceptor implements NestInterceptor {
-  protected readonly isHttpApp: boolean;
+  @Optional()
+  @Inject(APPLICATION_REFERENCE_HOST)
+  protected readonly applicationRefHost: any;
 
   constructor(
-    @Optional()
-    @Inject(HTTP_SERVER_REF)
-    protected readonly httpServer: HttpServer,
     @Inject(CACHE_MANAGER) protected readonly cacheManager: any,
     @Inject(REFLECTOR) protected readonly reflector,
-  ) {
-    this.isHttpApp = httpServer && !!httpServer.getRequestMethod;
-  }
+  ) {}
 
   async intercept(
     context: ExecutionContext,
@@ -48,13 +38,16 @@ export class CacheInterceptor implements NestInterceptor {
   }
 
   trackBy(context: ExecutionContext): string | undefined {
-    if (!this.isHttpApp) {
+    const httpServer = this.applicationRefHost.applicationRef;
+    const isHttpApp = httpServer && !!httpServer.getRequestMethod;
+
+    if (!isHttpApp) {
       return this.reflector.get(CACHE_KEY_METADATA, context.getHandler());
     }
     const request = context.getArgByIndex(0);
-    if (this.httpServer.getRequestMethod(request) !== 'GET') {
+    if (httpServer.getRequestMethod(request) !== 'GET') {
       return undefined;
     }
-    return this.httpServer.getRequestUrl(request);
+    return httpServer.getRequestUrl(request);
   }
 }

packages/common/utils/shared.utils.ts

@@ -8,4 +8,4 @@ export const validatePath = (path): string =>
   path.charAt(0) !== '/' ? '/' + path : path;
 export const isNil = (obj): boolean => isUndefined(obj) || obj === null;
 export const isEmpty = (array): boolean => !(array && array.length > 0);
-export const isSymbol = (fn): boolean => typeof fn === 'symbol';
+export const isSymbol = (fn): fn is symbol => typeof fn === 'symbol';

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

@@ -4,23 +4,34 @@ import {
   HttpException,
   HttpServer,
   HttpStatus,
+  Inject,
   Logger,
+  Optional,
 } from '@nestjs/common';
 import { isObject } from '@nestjs/common/utils/shared.utils';
 import { MESSAGES } from '../constants';
+import { ApplicationReferenceHost } from './../helpers/application-ref-host';
 
 export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
   private static readonly logger = new Logger('ExceptionsHandler');
 
-  constructor(protected readonly applicationRef: HttpServer) {}
+  @Optional()
+  @Inject()
+  protected readonly applicationRefHost?: ApplicationReferenceHost;
+
+  constructor(protected readonly applicationRef?: HttpServer) {}
 
   catch(exception: T, host: ArgumentsHost) {
+    const applicationRef =
+      this.applicationRef ||
+      (this.applicationRefHost && this.applicationRefHost.applicationRef);
+
     if (!(exception instanceof HttpException)) {
       const body = {
         statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
         message: MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
       };
-      this.applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
+      applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
       if (this.isExceptionObject(exception)) {
         return BaseExceptionFilter.logger.error(
           exception.message,
@@ -37,11 +48,7 @@ export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
           message: res,
         };
 
-    this.applicationRef.reply(
-      host.getArgByIndex(1),
-      message,
-      exception.getStatus(),
-    );
+    applicationRef.reply(host.getArgByIndex(1), message, exception.getStatus());
   }
 
   public isExceptionObject(err): err is Error {

packages/core/exceptions/exceptions-handler.ts

@@ -1,4 +1,4 @@
-import { HttpException, HttpServer } from '@nestjs/common';
+import { HttpException } from '@nestjs/common';
 import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
 import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
 import { isEmpty } from '@nestjs/common/utils/shared.utils';
@@ -8,10 +8,6 @@ import { BaseExceptionFilter } from './base-exception-filter';
 export class ExceptionsHandler extends BaseExceptionFilter {
   private filters: ExceptionFilterMetadata[] = [];
 
-  constructor(applicationRef: HttpServer) {
-    super(applicationRef);
-  }
-
   public next(exception: Error | HttpException | any, ctx: ArgumentsHost) {
     if (this.invokeCustomFilters(exception, ctx)) {
       return;

packages/core/injector/injector.ts

@@ -227,7 +227,11 @@ export class Injector {
     module: Module,
   ) {
     if (isUndefined(param)) {
-      throw new UndefinedDependencyException(wrapper.name, dependencyContext, module);
+      throw new UndefinedDependencyException(
+        wrapper.name,
+        dependencyContext,
+        module,
+      );
     }
     const token = this.resolveParamToken(wrapper, param);
     return this.resolveComponentInstance<T>(
@@ -293,7 +297,11 @@ export class Injector {
       dependencyContext.name,
     );
     if (isNil(instanceWrapper)) {
-      throw new UnknownDependenciesException(wrapper.name, dependencyContext, module);
+      throw new UnknownDependenciesException(
+        wrapper.name,
+        dependencyContext,
+        module,
+      );
     }
     return instanceWrapper;
   }
@@ -401,10 +409,9 @@ export class Injector {
   ): Promise<T> {
     const { metatype, inject } = wrapper;
     if (isNil(inject)) {
-      targetMetatype.instance = Object.assign(
-        targetMetatype.instance,
-        new metatype(...instances),
-      );
+      targetMetatype.instance = wrapper.forwardRef
+        ? Object.assign(targetMetatype.instance, new metatype(...instances))
+        : new metatype(...instances);
     } else {
       const factoryResult = ((targetMetatype.metatype as any) as Function)(
         ...instances,

packages/core/injector/module.ts

@@ -47,7 +47,7 @@ export class Module {
   private readonly _components = new Map<any, InstanceWrapper<Injectable>>();
   private readonly _injectables = new Map<any, InstanceWrapper<Injectable>>();
   private readonly _routes = new Map<string, InstanceWrapper<Controller>>();
-  private readonly _exports = new Set<string>();
+  private readonly _exports = new Set<string | symbol>();
 
   constructor(
     private readonly _metatype: Type<any>,
@@ -82,7 +82,7 @@ export class Module {
     return this._routes;
   }
 
-  get exports(): Set<string> {
+  get exports(): Set<string | symbol> {
     return this._exports;
   }
 
@@ -279,14 +279,14 @@ export class Module {
   }
 
   public addExportedComponent(
-    exportedComponent: ComponentMetatype | string | DynamicModule,
+    exportedComponent: ComponentMetatype | string | symbol | DynamicModule,
   ) {
-    const addExportedUnit = (token: string) =>
+    const addExportedUnit = (token: string | symbol) =>
       this._exports.add(this.validateExportedProvider(token));
 
     if (this.isCustomProvider(exportedComponent as any)) {
       return this.addCustomExportedComponent(exportedComponent as any);
-    } else if (isString(exportedComponent)) {
+    } else if (isString(exportedComponent) || isSymbol(exportedComponent)) {
       return addExportedUnit(exportedComponent);
     } else if (this.isDynamicModule(exportedComponent)) {
       const { module } = exportedComponent;
@@ -305,7 +305,7 @@ export class Module {
     this._exports.add(this.validateExportedProvider(provide.name));
   }
 
-  public validateExportedProvider(token: string) {
+  public validateExportedProvider(token: string | symbol) {
     if (this._components.has(token)) {
       return token;
     }
@@ -316,7 +316,7 @@ export class Module {
       .filter(metatype => metatype)
       .map(({ name }) => name);
 
-    if (!importedRefNames.includes(token)) {
+    if (!importedRefNames.includes(token as any)) {
       const { name } = this.metatype;
       throw new UnknownExportException(name);
     }

packages/core/test/injector/injector.spec.ts

@@ -69,7 +69,7 @@ describe('Injector', () => {
       ) as InstanceWrapper<MainTest>;
 
       expect(instance.depOne).instanceof(DependencyOne);
-      expect(instance.depTwo).instanceof(DependencyOne);
+      expect(instance.depTwo).instanceof(DependencyTwo);
       expect(instance).instanceof(MainTest);
     });