refactor(exception): exception filter need to handle inheritance of error clazz (#255)

Author: noahziheng

src/exception/utils.ts

@@ -3,6 +3,8 @@ import { Constructable, Container } from '@artus/injection';
 import { EXCEPTION_FILTER_DEFAULT_SYMBOL, EXCEPTION_FILTER_MAP_INJECT_ID } from './constant';
 import { ArtusStdError } from './impl';
 import { ExceptionFilterMapType, ExceptionFilterType } from './types';
+import { isClass } from '../utils/is';
+
 
 export const matchExceptionFilterClazz =  (err: Error, container: Container): Constructable<ExceptionFilterType> | null => {
   const filterMap: ExceptionFilterMapType = container.get(EXCEPTION_FILTER_MAP_INJECT_ID, {
@@ -11,18 +13,27 @@ export const matchExceptionFilterClazz =  (err: Error, container: Container): Co
   if (!filterMap) {
     return null;
   }
-  let targetFilterClazz: Constructable<ExceptionFilterType> | null = null;
+
+  // handle ArtusStdError with code simply
   if (err instanceof ArtusStdError && filterMap.has(err.code)) {
-    // handle ArtusStdError with code simply
-    targetFilterClazz = filterMap.get(err.code);
-  } else if (filterMap.has(err['constructor'] as Constructable<Error>)) {
-    // handle CustomErrorClazz
-    targetFilterClazz = filterMap.get(err['constructor'] as Constructable<Error>);
-  } else if (filterMap.has(EXCEPTION_FILTER_DEFAULT_SYMBOL)) {
-    // handle default ExceptionFilter
-    targetFilterClazz = filterMap.get(EXCEPTION_FILTER_DEFAULT_SYMBOL);
+    return filterMap.get(err.code);
+  }
+  
+  // handle CustomErrorClazz, loop inherit class
+  let errConstructor: Function = err['constructor'];
+  while(isClass(errConstructor)) { // until parent/self is not class
+    if (filterMap.has(errConstructor as Constructable<Error>)) {
+      return filterMap.get(errConstructor as Constructable<Error>);
+    }
+    errConstructor = Object.getPrototypeOf(errConstructor); // get parent clazz by prototype
   }
-  return targetFilterClazz;
+  
+  // handle default ExceptionFilter
+  if (filterMap.has(EXCEPTION_FILTER_DEFAULT_SYMBOL)) {
+    return filterMap.get(EXCEPTION_FILTER_DEFAULT_SYMBOL);
+  }
+
+  return null;
 };
 
 export const matchExceptionFilter = (err: Error, container: Container): ExceptionFilterType | null => {

test/exception_filter.test.ts

@@ -27,6 +27,8 @@ describe('test/exception_filter.test.ts', () => {
         ['custom', 'TestCustomError'],
         ['wrapped', 'APP:WRAPPED_ERROR'],
         ['APP:TEST_ERROR', 'APP:TEST_ERROR'],
+        ['inherit', 'TestInheritError'],
+        ['defaultInherit', 'TestDefaultInheritError'],
       ]) {
         const mockErrorService = app.container.get(MockErrorService);
         try {

test/fixtures/exception_filter/bootstrap.ts

@@ -24,6 +24,8 @@ async function main() {
                 "TestAppCodeExceptionHandler",
                 "TestWrappedExceptionHandler",
                 "TestCustomExceptionHandler",
+                "TestDefaultInheritExceptionHandler",
+                "TestInheritExceptionHandler",
               ],
             },
             source: "app",

test/fixtures/exception_filter/error.ts

@@ -12,3 +12,15 @@ export class TestWrappedError extends ArtusStdError {
 export class TestCustomError extends Error {
   name = 'TestCustomError';
 }
+
+export class TestDefaultInheritError extends Error {
+  name = 'TestDefaultInheritError';
+}
+
+export class TestBaseError extends Error {
+  name = 'TestBaseError';
+}
+
+export class TestInheritError extends TestBaseError {
+  name = 'TestInheritError';
+}

test/fixtures/exception_filter/filter.ts

@@ -1,6 +1,6 @@
 import { ArtusStdError, Catch, Inject } from '../../../src';
 import { ExceptionFilterType } from '../../../src/exception/types';
-import { TestCustomError, TestWrappedError } from './error';
+import { TestBaseError, TestCustomError, TestWrappedError } from './error';
 
 @Catch()
 export class TestDefaultExceptionHandler implements ExceptionFilterType {
@@ -41,3 +41,23 @@ export class TestCustomExceptionHandler implements ExceptionFilterType {
     this.mockSet.add(err.name);
   }
 }
+
+@Catch(Error)
+export class TestDefaultInheritExceptionHandler implements ExceptionFilterType {
+  @Inject('mock_exception_set')
+  mockSet: Set<string>;
+
+  async catch(err: Error) {
+    this.mockSet.add(err.name);
+  }
+}
+
+@Catch(TestBaseError)
+export class TestInheritExceptionHandler implements ExceptionFilterType {
+  @Inject('mock_exception_set')
+  mockSet: Set<string>;
+
+  async catch(err: TestBaseError) {
+    this.mockSet.add(err.name);
+  }
+}

test/fixtures/exception_filter/service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@artus/injection';
 import { ArtusStdError } from '../../../src';
-import { TestCustomError, TestWrappedError } from './error';
+import { TestCustomError, TestDefaultInheritError, TestInheritError, TestWrappedError } from './error';
 
 @Injectable()
 export default class MockErrorService {
@@ -13,6 +13,10 @@ export default class MockErrorService {
         throw new TestCustomError();
       case "wrapped":
         throw new TestWrappedError();
+      case "inherit":
+        throw new TestInheritError();
+      case "defaultInherit":
+        throw new TestDefaultInheritError();
       default:
         throw new ArtusStdError(target);
     }