add ability to configure global error handling for Do.try

Author: Mat Jones

src/types/do-try-types.ts

@@ -9,12 +9,28 @@ type SyncWorkload<T> = () => T;
 type CatchHandler<T> = (result?: ResultRecord<T>, error?: any) => void;
 type FinallyHandler = () => void;
 
+interface DoTryConfig {
+    /**
+     * A default handler that will always run on error, if configured,
+     * even if a `catch()` does not exist in the call chain.
+     * This is useful for adding default error handling in the
+     * development environment, such as `console.error(err)`.
+     */
+    defaultErrorHandler?: CatchHandler<any>;
+}
+
 // #endregion Types
 
 // -----------------------------------------------------------------------------------------
 // #region Exports
 // -----------------------------------------------------------------------------------------
 
-export { AsyncWorkload, SyncWorkload, CatchHandler, FinallyHandler };
+export {
+    AsyncWorkload,
+    CatchHandler,
+    DoTryConfig,
+    FinallyHandler,
+    SyncWorkload,
+};
 
 // #endregion Exports

src/utilities/do-try.test.ts

@@ -8,6 +8,7 @@ import { Do, DoSync } from "../utilities/do-try";
 import { PolyfillUtils } from "../utilities/polyfill-utils";
 import { StubResourceRecord } from "../tests/stubs/stub-resource-record";
 import { CoreUtils } from "../utilities/core-utils";
+import { CatchHandler } from "../types/do-try-types";
 
 PolyfillUtils.registerPromiseFinallyPolyfill();
 
@@ -119,6 +120,42 @@ describe("do-try.ts", () => {
         });
     });
 
+    describe("Do.configure", () => {
+        it("When defaultErrorHandler configured and no catch() in call chain, then defaultErrorHandler is still executed", async () => {
+            // Arrange
+            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            Do.configure({ defaultErrorHandler });
+            const catchHandler = jest.fn();
+            const workload = async () => {
+                throw Error();
+            };
+
+            // Act & Assert
+            Do.try(workload)
+                .catch(catchHandler)
+                .finally(() => {
+                    expect(catchHandler).toHaveBeenCalled();
+                    expect(defaultErrorHandler).toHaveBeenCalled();
+                });
+            expect.assertions(2);
+        });
+
+        it("When defaultErrorHandler configured and catch() is in call chain, the defaultErrorHandler is still executed", async () => {
+            // Arrange
+            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            Do.configure({ defaultErrorHandler });
+            const workload = async () => {
+                throw Error();
+            };
+
+            // Act & Assert
+            Do.try(workload).finally(() => {
+                expect(defaultErrorHandler).toHaveBeenCalled();
+            });
+            expect.assertions(1);
+        });
+    });
+
     describe("DoSync.try", () => {
         it("When no errors occur, then .execute() returns the workload return value", () => {
             // Arrange
@@ -204,4 +241,40 @@ describe("do-try.ts", () => {
             expect(finallyHandler).toHaveBeenCalled();
         });
     });
+
+    describe("DoSync.configure", () => {
+        it("When defaultErrorHandler configured and no catch() in call chain, then defaultErrorHandler is still executed", () => {
+            // Arrange
+            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            DoSync.configure({ defaultErrorHandler });
+            const catchHandler = jest.fn();
+            const workload = () => {
+                throw Error();
+            };
+
+            // Act
+            DoSync.try(workload)
+                .catch(catchHandler)
+                .execute();
+
+            // Assert
+            expect(catchHandler).toHaveBeenCalled();
+            expect(defaultErrorHandler).toHaveBeenCalled();
+        });
+
+        it("When defaultErrorHandler configured and catch() is in call chain, the defaultErrorHandler is still executed", () => {
+            // Arrange
+            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            DoSync.configure({ defaultErrorHandler });
+            const workload = () => {
+                throw Error();
+            };
+
+            // Act
+            DoSync.try(workload).execute();
+
+            // Assert
+            expect(defaultErrorHandler).toHaveBeenCalled();
+        });
+    });
 });

src/utilities/do-try.ts

@@ -1,9 +1,10 @@
 import { ResultRecord } from "../view-models/result-record";
 import {
     AsyncWorkload,
-    SyncWorkload,
     CatchHandler,
+    DoTryConfig,
     FinallyHandler,
+    SyncWorkload,
 } from "../types/do-try-types";
 
 // -----------------------------------------------------------------------------------------
@@ -19,8 +20,20 @@ import {
 class Do<TResourceType, TReturnVal = void> {
     private promise: Promise<TReturnVal>;
 
+    private static config: DoTryConfig = {
+        defaultErrorHandler: undefined,
+    };
+
     private constructor(workload: AsyncWorkload<TReturnVal>) {
-        this.promise = workload();
+        this.promise = workload().catch((err: any) => {
+            if (err instanceof ResultRecord) {
+                Do.config.defaultErrorHandler?.(err, undefined);
+                throw err; // rethrow so it doesn't interrupt call chain
+            }
+
+            Do.config.defaultErrorHandler?.(undefined, err);
+            throw err; // rethrow so it doesn't interrupt call chain
+        });
     }
 
     /**
@@ -47,6 +60,14 @@ class Do<TResourceType, TReturnVal = void> {
         return this;
     }
 
+    /**
+     * Sets the global configuration object for class {Do}
+     * @param config the {DoTryConfig} object to set
+     */
+    public static configure(config: DoTryConfig): void {
+        Do.config = config;
+    }
+
     /**
      * Run some handler when the function completes, whether the
      * catch() was hit or not.
@@ -96,6 +117,10 @@ class DoSync<TResourceType, TReturnVal = void> {
     private catchHandler?: (err: any) => void;
     private finallyHandler?: FinallyHandler;
 
+    private static config: DoTryConfig = {
+        defaultErrorHandler: undefined,
+    };
+
     private constructor(workload: SyncWorkload<TReturnVal>) {
         this.workload = workload;
     }
@@ -123,6 +148,14 @@ class DoSync<TResourceType, TReturnVal = void> {
         return this;
     }
 
+    /**
+     * Sets the global configuration for class {DySync}.
+     * @param config the {DoTryConfig} object to set
+     */
+    public static configure(config: DoTryConfig): void {
+        DoSync.config = config;
+    }
+
     /**
      * Execute the entire DoSync call chain. For the synchronous version, i.e. DoSync,
      * you must manually call .execute() for the call chain to be executed.
@@ -132,6 +165,13 @@ class DoSync<TResourceType, TReturnVal = void> {
         try {
             return this.workload();
         } catch (e) {
+            if (e instanceof ResultRecord) {
+                DoSync.config.defaultErrorHandler?.(e, undefined);
+                this.catchHandler?.(e);
+                return;
+            }
+
+            DoSync.config.defaultErrorHandler?.(undefined, e);
             this.catchHandler?.(e);
         } finally {
             this.finallyHandler?.();