Issue #55 Update Do.try to allow configuring a default error handler

add ability to configure global error handling for Do.try

Author: brandongregoryscott

docs/interfaces/dotryconfig.md

@@ -0,0 +1,26 @@
+[andculturecode-javascript-core](../README.md) › [DoTryConfig](dotryconfig.md)
+
+# Interface: DoTryConfig
+
+## Hierarchy
+
+* **DoTryConfig**
+
+## Index
+
+### Properties
+
+* [defaultErrorHandler](dotryconfig.md#optional-defaulterrorhandler)
+
+## Properties
+
+### `Optional` defaultErrorHandler
+
+• **defaultErrorHandler**? : *[CatchHandler](../README.md#catchhandler)‹any›*
+
+*Defined in [src/types/do-try-types.ts:19](https://github.com/mrjones2014/AndcultureCode.JavaScript.Core/blob/7c31cdb/src/types/do-try-types.ts#L19)*
+
+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)`.

src/index.ts

@@ -54,12 +54,12 @@ export { User } from "./interfaces/user";
 // #region Types
 // -----------------------------------------------------------------------------------------
 
-export { AsyncWorkload } from "./types/do-try-types";
+export { AsyncWorkload } from "./types/async-workload";
 export { CancellablePromise } from "./types/cancellable-promise";
-export { CatchHandler } from "./types/do-try-types";
+export { CatchResultHandler } from "./types/catch-result-handler";
 export { Constructor } from "./types/constructor";
-export { FinallyHandler } from "./types/do-try-types";
-export { SyncWorkload } from "./types/do-try-types";
+export { FinallyHandler } from "./types/finally-handler";
+export { SyncWorkload } from "./types/sync-workload";
 
 // #endregion Types
 

src/interfaces/do-try-config.ts

@@ -0,0 +1,13 @@
+import { CatchResultHandler } from "../types/catch-result-handler";
+
+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?: CatchResultHandler<any>;
+}
+
+export { DoTryConfig };

src/types/async-workload.ts

@@ -0,0 +1,6 @@
+/**
+ * Represents an asynchronous method reference.
+ */
+type AsyncWorkload<T> = () => Promise<T>;
+
+export { AsyncWorkload };

src/types/catch-result-handler.ts

@@ -0,0 +1,8 @@
+import { ResultRecord } from "../view-models/result-record";
+
+/**
+ * Handler for a typed error ResultRecord, or any type if a Javascript error occurred.
+ */
+type CatchResultHandler<T> = (result?: ResultRecord<T>, error?: any) => void;
+
+export { CatchResultHandler };

src/types/do-try-types.ts

@@ -0,0 +1,6 @@
+/**
+ * Handler for Do.try().finally(); Runs whether an error occurred or not.
+ */
+type FinallyHandler = () => void;
+
+export { FinallyHandler };

src/types/finally-handler.ts

@@ -0,0 +1,6 @@
+/**
+ * Represents a synchronous method reference.
+ */
+type SyncWorkload<T> = () => T;
+
+export { SyncWorkload };

src/types/sync-workload.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 { CatchResultHandler } from "../types/catch-result-handler";
 
 PolyfillUtils.registerPromiseFinallyPolyfill();
 
@@ -119,6 +120,42 @@ describe("do-try.ts", () => {
         });
     });
 
+    describe("Do.configure", () => {
+        it("When defaultErrorHandler configured and catch() is in call chain, then defaultErrorHandler is still executed", async () => {
+            // Arrange
+            const defaultErrorHandler: CatchResultHandler<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 no catch() is in call chain, the defaultErrorHandler is still executed", async () => {
+            // Arrange
+            const defaultErrorHandler: CatchResultHandler<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 catch() in call chain, then defaultErrorHandler is still executed", () => {
+            // Arrange
+            const defaultErrorHandler: CatchResultHandler<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 no catch() is in call chain, the defaultErrorHandler is still executed", () => {
+            // Arrange
+            const defaultErrorHandler: CatchResultHandler<any> = jest.fn();
+            DoSync.configure({ defaultErrorHandler });
+            const workload = () => {
+                throw Error();
+            };
+
+            // Act
+            DoSync.try(workload).execute();
+
+            // Assert
+            expect(defaultErrorHandler).toHaveBeenCalled();
+        });
+    });
 });

src/utilities/do-try.test.ts

@@ -1,10 +1,9 @@
 import { ResultRecord } from "../view-models/result-record";
-import {
-    AsyncWorkload,
-    SyncWorkload,
-    CatchHandler,
-    FinallyHandler,
-} from "../types/do-try-types";
+import { DoTryConfig } from "../interfaces/do-try-config";
+import { AsyncWorkload } from "../types/async-workload";
+import { CatchResultHandler } from "../types/catch-result-handler";
+import { FinallyHandler } from "../types/finally-handler";
+import { SyncWorkload } from "../types/sync-workload";
 
 // -----------------------------------------------------------------------------------------
 // #region Do
@@ -19,8 +18,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
+        });
     }
 
     /**
@@ -33,7 +44,7 @@ class Do<TResourceType, TReturnVal = void> {
      * @returns this
      */
     public catch(
-        errorHandler: CatchHandler<TResourceType>
+        errorHandler: CatchResultHandler<TResourceType>
     ): Do<TResourceType, TReturnVal> {
         this.promise = this.promise.catch((err: any) => {
             if (err instanceof ResultRecord) {
@@ -47,6 +58,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 +115,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;
     }
@@ -109,7 +132,7 @@ class DoSync<TResourceType, TReturnVal = void> {
      * @param errorHandler handle errors, either as a {ResultRecord} or {any}
      */
     public catch(
-        errorHandler: CatchHandler<TResourceType>
+        errorHandler: CatchResultHandler<TResourceType>
     ): DoSync<TResourceType, TReturnVal> {
         this.catchHandler = (err: any) => {
             if (err instanceof ResultRecord) {
@@ -123,6 +146,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 +163,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?.();