refactor(): extract handling unknown errors to separate functions

Author: kamilmysliwiec

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

@@ -9,6 +9,7 @@ import {
   Optional,
 } from '@nestjs/common';
 import { isObject } from '@nestjs/common/utils/shared.utils';
+import { AbstractHttpAdapter } from '../adapters';
 import { MESSAGES } from '../constants';
 import { HttpAdapterHost } from '../helpers';
 
@@ -27,18 +28,7 @@ export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
       (this.httpAdapterHost && this.httpAdapterHost.httpAdapter);
 
     if (!(exception instanceof HttpException)) {
-      const body = {
-        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
-        message: MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
-      };
-      applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
-      if (this.isExceptionObject(exception)) {
-        return BaseExceptionFilter.logger.error(
-          exception.message,
-          exception.stack,
-        );
-      }
-      return BaseExceptionFilter.logger.error(exception);
+      return this.handleUnknownError(exception, host, applicationRef);
     }
     const res = exception.getResponse();
     const message = isObject(res)
@@ -51,6 +41,25 @@ export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
     applicationRef.reply(host.getArgByIndex(1), message, exception.getStatus());
   }
 
+  public handleUnknownError(
+    exception: T,
+    host: ArgumentsHost,
+    applicationRef: AbstractHttpAdapter | HttpServer,
+  ) {
+    const body = {
+      statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+      message: MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
+    };
+    applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
+    if (this.isExceptionObject(exception)) {
+      return BaseExceptionFilter.logger.error(
+        exception.message,
+        exception.stack,
+      );
+    }
+    return BaseExceptionFilter.logger.error(exception);
+  }
+
   public isExceptionObject(err: any): err is Error {
     return isObject(err) && !!(err as Error).message;
   }

packages/core/injector/module.ts

@@ -281,7 +281,12 @@ export class Module {
     provider: ClassProvider & ProviderName,
     collection: Map<string, InstanceWrapper>,
   ) {
-    const { name, useClass, scope } = provider;
+    const { name, useClass } = provider;
+
+    let { scope } = provider;
+    if (isUndefined(scope)) {
+      scope = this.getClassScope(useClass);
+    }
     collection.set(
       name as string,
       new InstanceWrapper({
@@ -501,7 +506,7 @@ export class Module {
     };
   }
 
-  private getClassScope(provider: Provider): Scope {
+  private getClassScope(provider: Type<unknown>): Scope {
     const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, provider);
     return metadata && metadata.scope;
   }

packages/microservices/exceptions/base-rpc-exception-filter.ts

@@ -8,25 +8,29 @@ export class BaseRpcExceptionFilter<T = any, R = any>
   implements RpcExceptionFilter<T> {
   private static readonly logger = new Logger('RpcExceptionsHandler');
 
-  catch(exception: T, host: ArgumentsHost): Observable<R> {
+  public catch(exception: T, host: ArgumentsHost): Observable<R> {
     const status = 'error';
     if (!(exception instanceof RpcException)) {
-      const errorMessage = MESSAGES.UNKNOWN_EXCEPTION_MESSAGE;
-
-      const loggerArgs = this.isError(exception)
-        ? [exception.message, exception.stack]
-        : [exception];
-      const logger = BaseRpcExceptionFilter.logger;
-      logger.error.apply(logger, loggerArgs as any);
-
-      return _throw({ status, message: errorMessage });
+      return this.handleUnknownError(exception);
     }
     const res = exception.getError();
     const message = isObject(res) ? res : { status, message: res };
     return _throw(message);
   }
 
-  isError(exception: any): exception is Error {
+  public handleUnknownError(exception: T) {
+    const errorMessage = MESSAGES.UNKNOWN_EXCEPTION_MESSAGE;
+
+    const loggerArgs = this.isError(exception)
+      ? [exception.message, exception.stack]
+      : [exception];
+    const logger = BaseRpcExceptionFilter.logger;
+    logger.error.apply(logger, loggerArgs as any);
+
+    return _throw({ status, message: errorMessage });
+  }
+
+  public isError(exception: any): exception is Error {
     return !!(isObject(exception) && (exception as Error).message);
   }
 }

packages/microservices/exceptions/rpc-exception.ts

@@ -2,6 +2,7 @@ import { isString } from '@nestjs/common/utils/shared.utils';
 
 export class RpcException extends Error {
   public readonly message: any;
+
   constructor(private readonly error: string | object) {
     super();
     this.message = error;

packages/websockets/exceptions/base-ws-exception-filter.ts

@@ -4,12 +4,12 @@ import { MESSAGES } from '@nestjs/core/constants';
 import { WsException } from '../errors/ws-exception';
 
 export class BaseWsExceptionFilter<T = any> implements WsExceptionFilter<T> {
-  catch(exception: T, host: ArgumentsHost) {
+  public catch(exception: T, host: ArgumentsHost) {
     const client = host.switchToWs().getClient();
     this.handleError(client, exception);
   }
 
-  handleError<IClient extends { emit: Function }>(
+  public handleError<IClient extends { emit: Function }>(
     client: IClient,
     exception: T,
   ) {