improvement(core) use application ref host instead of http ref

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/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;