Fix issue with catching exceptions thrown by engage

.gitignore

@@ -1,4 +1,5 @@
 coverage
 node_modules
 yarn-error.log
-Future.js
+Future.js
+.envrc

Future.test.ts

@@ -16,14 +16,17 @@ describe("Future", () => {
             expect(resolveSpy).not.toHaveBeenCalled();
         });
 
-        test("invokes reject when action throws exception", () => {
-            const actionSpy = jasmine.createSpy("futureAction").and.throwError("forced error");
+        test("does not invoke reject when action throws exception", () => {
+            const actionSpy = jasmine.createSpy("futureAction").and.callFake(() => {
+                throw new Error("forced error");
+            });
             const rejectSpy = jasmine.createSpy("rejectSpy");
             const resolveSpy = jasmine.createSpy("resolveSpy");
-            new Future(actionSpy).engage(rejectSpy, resolveSpy);
-
+            expect(() => {
+                new Future(actionSpy).engage(rejectSpy, resolveSpy);
+            }).toThrowError("forced error");
             expect(actionSpy).toHaveBeenCalledWith(rejectSpy, resolveSpy);
-            expect(rejectSpy).toHaveBeenCalledWith(new Error("forced error"));
+            expect(rejectSpy).not.toHaveBeenCalled();
             expect(resolveSpy).not.toHaveBeenCalled();
         });
 
@@ -37,6 +40,69 @@ describe("Future", () => {
 
             expect(resolveSpy).toHaveBeenCalledWith("my value");
         });
+        test("handleWith for current Future does not get run if errors above its scope throw", (done) => {
+            let mapCalledTimes = 0;
+            let handleWithCalledTimes = 0;
+            const action = Future.of(33)
+                .handleWith((e: Error) => {
+                    // eslint-disable-next-line no-console
+                    console.log(`failed an infallible future: ${e.message}`);
+                    handleWithCalledTimes++;
+                    return Future.of(-1);
+                })
+                .map((r) => {
+                    mapCalledTimes++;
+                    return r;
+                });
+
+            try {
+                action.engage(
+                    (e) => {
+                        throw e;
+                    },
+                    (r) => {
+                        throw new Error(`oh no, something went wrong after the future has run to completion on ${r}`);
+                    }
+                );
+            } catch (e) {
+                expect(handleWithCalledTimes).toBe(0);
+                expect(mapCalledTimes).toBe(1);
+                done();
+            }
+        });
+
+        test("does not get run if engages above this scope throw in the rejection", (done) => {
+            let mapCalledTimes = 0;
+            let handleWithCalledTimes = 0;
+            const expectedError = new Error("error message");
+            let errorInHandleWith = null;
+            const action: Future<Error, number> = Future.reject(expectedError)
+                .handleWith((e): any => {
+                    handleWithCalledTimes++;
+                    errorInHandleWith = e;
+                    return Future.of(-1);
+                })
+                .map((r) => {
+                    mapCalledTimes++;
+                    return r;
+                });
+
+            try {
+                action.engage(
+                    (e) => {
+                        throw e;
+                    },
+                    (r) => {
+                        throw new Error(`oh no, something went wrong after the future has run to completion on ${r}`);
+                    }
+                );
+            } catch (e) {
+                expect(handleWithCalledTimes).toBe(1);
+                expect(errorInHandleWith).toBe(expectedError);
+                expect(mapCalledTimes).toBe(1);
+                done();
+            }
+        });
     });
 
     describe("toPromise", () => {
@@ -909,5 +975,16 @@ describe("Future", () => {
 
             await expect(chainedPromiseFuture).rejects.toThrow("bad stuff");
         });
+
+        test("catches exceptions if thrown in the map of the future", async () => {
+            const p = Promise.resolve(1);
+            const chainedPromiseFuture = p.then(() =>
+                Future.of(1).map(() => {
+                    throw new Error("bad stuff");
+                })
+            );
+
+            await expect(chainedPromiseFuture).rejects.toThrow("bad stuff");
+        });
     });
 });

Future.ts

@@ -14,11 +14,14 @@ export default class Future<L, R> {
      * @param {Function} resolve Handler if Future fully executed successfully
      */
     engage(reject: Reject<L>, resolve: Resolve<R>): void {
+        this.action(reject, resolve);
+    }
+
+    private engageAndCatch(reject: Reject<L>, resolve: Resolve<R>): void {
         try {
-            //In the case where the action call just completely blows up, prevent against that and invoke reject.
-            this.action(reject, resolve);
-        } catch (error: any) {
-            reject(error);
+            this.engage(reject, resolve);
+        } catch (e) {
+            reject(e as L);
         }
     }
 
@@ -60,7 +63,7 @@ export default class Future<L, R> {
      */
     flatMap<NewResultType>(next: (data: R) => Future<L, NewResultType>): Future<L, NewResultType> {
         return new Future<L, NewResultType>((reject: Reject<L>, resolve: Resolve<NewResultType>) => {
-            this.engage(reject, (data: R) => next(data).engage(reject, resolve));
+            this.engageAndCatch(reject, (data: R) => next(data).engageAndCatch(reject, resolve));
         });
     }
 
@@ -83,7 +86,7 @@ export default class Future<L, R> {
      */
     errorMap<LB>(mapper: (error: L) => LB): Future<LB, R> {
         return new Future<LB, R>((reject: Reject<LB>, resolve: Resolve<R>) => {
-            this.engage((error) => reject(mapper(error)), resolve);
+            this.engageAndCatch((error) => reject(mapper(error)), resolve);
         });
     }
 
@@ -97,6 +100,7 @@ export default class Future<L, R> {
             try {
                 result = fn();
             } catch (e: any) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return reject(e);
             }
             resolve(result);
@@ -114,6 +118,7 @@ export default class Future<L, R> {
             try {
                 promiseResult = fn();
             } catch (e: any) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return reject(e);
             }
             //We have to support both Promise and PromiseLike methods as input here, but treat them all as normal Promises when executing them
@@ -151,6 +156,7 @@ export default class Future<L, R> {
             try {
                 result = fn(a);
             } catch (e: any) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return reject(e);
             }
             resolve(result);
@@ -169,7 +175,7 @@ export default class Future<L, R> {
             let count = 0;
             let done = false;
 
-            future1.engage(
+            future1.engageAndCatch(
                 (error) => {
                     if (!done) {
                         done = true;
@@ -184,7 +190,7 @@ export default class Future<L, R> {
                 }
             );
 
-            future2.engage(
+            future2.engageAndCatch(
                 (error) => {
                     if (!done) {
                         done = true;
@@ -249,7 +255,7 @@ export default class Future<L, R> {
             }
 
             futures.forEach((futureInstance, index) => {
-                futureInstance.engage(
+                futureInstance.engageAndCatch(
                     (error) => {
                         reject(error);
                     },

flake.nix

@@ -0,0 +1,23 @@
+{
+  description = "FutureJS";
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem
+      (system:
+        let
+          pkgs = nixpkgs.legacyPackages.${system};
+        in
+        {
+          devShell = pkgs.mkShell
+            {
+              buildInputs =
+                [
+                  pkgs.nodejs_20
+                  (pkgs.yarn.override {
+                    nodejs = pkgs.nodejs_20;
+                  })
+                ];
+            };
+        });
+}

package.json

@@ -15,8 +15,8 @@
     },
     "devDependencies": {
         "@types/jest": "^26.0.22",
-        "@typescript-eslint/eslint-plugin": "^4.21.0",
-        "@typescript-eslint/parser": "^4.21.0",
+        "@typescript-eslint/eslint-plugin": "^5.59.11",
+        "@typescript-eslint/parser": "^5.59.11",
         "eslint": "^7.23.0",
         "eslint-plugin-import": "^2.22.1",
         "eslint-plugin-jsdoc": "^32.3.0",