feat(ResultAsync): add from() error handling, update Result async methods

Author: seangwright

src/result.ts

@@ -1,4 +1,4 @@
-import { isSome } from '.';
+import { ErrorHandler, isSome } from '.';
 import { ResultAsync } from './resultAsync';
 import { Unit } from './unit';
 import {
@@ -175,7 +175,7 @@ export class Result<TValue = Unit, TError = string> {
    */
   static try<TValue, TError = string>(
     factory: FunctionOfT<Some<TValue>>,
-    errorHandler: FunctionOfTtoK<unknown, TError>
+    errorHandler: ErrorHandler<TError>
   ): Result<TValue, TError>;
   /**
    * Creates a new successful Result with a Unit value.
@@ -186,7 +186,7 @@ export class Result<TValue = Unit, TError = string> {
    */
   static try<TError = string>(
     action: Action,
-    errorHandler: FunctionOfTtoK<unknown, TError>
+    errorHandler: ErrorHandler<TError>
   ): Result<Unit, TError>;
   /**
    * Creates a new successful Result with the return value
@@ -198,7 +198,7 @@ export class Result<TValue = Unit, TError = string> {
    */
   static try<TValue = Unit, TError = string>(
     actionOrFactory: FunctionOfT<Some<TValue>> | Action,
-    errorHandler: FunctionOfTtoK<unknown, Some<TError>>
+    errorHandler: ErrorHandler<TError>
   ): Result<TValue, TError> {
     try {
       const value = actionOrFactory();
@@ -480,27 +480,31 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * Maps the value successful Result to a new async value wrapped in a ResultAsync
    * @param projection a function given the value of the current Result which returns a Promise of some value
+   * @param errorHandler a function that converts the error of the rejected Promise to a failed Result
    * @returns
    */
   mapAsync<TNewValue>(
-    projection: FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>
+    projection: FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TNewValue, TError> {
     return this.isSuccess
-      ? ResultAsync.from(projection(this.getValueOrThrow()))
+      ? ResultAsync.from(projection(this.getValueOrThrow()), errorHandler)
       : ResultAsync.failure(this.getErrorOrThrow());
   }
 
   /**
    * Maps the error of a failed Result to a new async value wrapped in a ResultAsync
    * @param projection a function given the error of the current Result which returns a Promise of some value
+   * @param errorHandler a function that converts the error of the rejected Promise to a failed Result
    * @returns
    */
   mapFailureAsync(
-    projection: FunctionOfTtoK<TError, Promise<Some<TValue>>>
+    projection: FunctionOfTtoK<TError, Promise<Some<TValue>>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TValue, TError> {
     return this.isSuccess
       ? ResultAsync.from(this)
-      : ResultAsync.from(projection(this.getErrorOrThrow()));
+      : ResultAsync.from(projection(this.getErrorOrThrow()), errorHandler);
   }
 
   /**
@@ -519,9 +523,11 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * Maps a successful Result to a new ResultAsync
    * @param projection
+   * @param errorHandler a function that converts the error of the rejected Promise to a failed Result
    */
   bindAsync<TNewValue>(
-    projection: FunctionOfTtoK<TValue, Promise<Result<TNewValue, TError>>>
+    projection: FunctionOfTtoK<TValue, Promise<Result<TNewValue, TError>>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TNewValue, TError>;
   /**
    * Maps a successful Result to a new ResultAsync
@@ -533,12 +539,14 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * Maps a successful Result to a new ResultAsync
    * @param projection
+   * @param errorHandler a function that converts the error of the rejected Promise to a failed Result
    * @returns
    */
   bindAsync<TNewValue>(
     projection:
       | FunctionOfTtoK<TValue, Promise<Result<TNewValue, TError>>>
-      | FunctionOfTtoK<TValue, ResultAsync<TNewValue, TError>>
+      | FunctionOfTtoK<TValue, ResultAsync<TNewValue, TError>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TNewValue, TError> {
     if (this.isFailure) {
       return ResultAsync.failure(this.getErrorOrThrow());
@@ -547,7 +555,7 @@ export class Result<TValue = Unit, TError = string> {
     const resultAsyncOrPromise = projection(this.getValueOrThrow());
 
     return isPromise(resultAsyncOrPromise)
-      ? ResultAsync.from<TNewValue, TError>(resultAsyncOrPromise)
+      ? ResultAsync.from<TNewValue, TError>(resultAsyncOrPromise, errorHandler)
       : resultAsyncOrPromise;
   }
 
@@ -580,16 +588,23 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * Executes an async action if the Result succeeded
    * @param action a function given the Result's value returns a Promise
+   * @param errorHandler a function that converts the error of the rejected Promise to a failed Result
    * @returns a ResultAsync
    */
-  tapAsync(action: AsyncActionOfT<TValue>): ResultAsync<TValue, TError> {
+  tapAsync(
+    action: AsyncActionOfT<TValue>,
+    errorHandler?: ErrorHandler<TError>
+  ): ResultAsync<TValue, TError> {
     if (this.isFailure) {
       return ResultAsync.failure(this.getErrorOrThrow());
     }
 
     const value = this.getValueOrThrow();
 
-    return ResultAsync.from(action(value).then(() => value));
+    return ResultAsync.from(
+      action(value).then<Some<TValue>>(() => value),
+      errorHandler
+    );
   }
 
   /**
@@ -686,12 +701,12 @@ export class Result<TValue = Unit, TError = string> {
   /**
    *
    * @param action
-   * @param errorCreator
+   * @param errorHandler
    * @returns
    */
   onSuccessTry(
     action: ActionOfT<TValue>,
-    errorCreator: FunctionOfTtoK<unknown, Some<TError>>
+    errorHandler: ErrorHandler<TError>
   ): Result<TValue, TError> {
     if (this.isFailure) {
       return this;
@@ -704,7 +719,7 @@ export class Result<TValue = Unit, TError = string> {
 
       return Result.success(value);
     } catch (error: unknown) {
-      return Result.failure(errorCreator(error));
+      return Result.failure(errorHandler(error));
     }
   }
 
@@ -716,13 +731,13 @@ export class Result<TValue = Unit, TError = string> {
    */
   onSuccessTryAsync(
     asyncAction: FunctionOfTtoK<TValue, Promise<void>>,
-    errorHander: FunctionOfTtoK<unknown, Some<TError>>
+    errorHander: ErrorHandler<TError>
   ): ResultAsync<TValue, TError> {
     if (this.isFailure) {
       return ResultAsync.failure(this.getErrorOrThrow());
     }
 
-    const result = async () => {
+    const promiseFactory = async () => {
       const value = this.getValueOrThrow();
 
       try {
@@ -734,7 +749,7 @@ export class Result<TValue = Unit, TError = string> {
       }
     };
 
-    return ResultAsync.from<TValue, TError>(result());
+    return ResultAsync.from<TValue, TError>(promiseFactory(), errorHander);
   }
 
   /**

src/resultAsync.ts

@@ -1,3 +1,4 @@
+import { ErrorHandler } from '.';
 import { Result } from './result';
 import { Unit } from './unit';
 import {
@@ -29,28 +30,42 @@ export class ResultAsync<TValue = Unit, TError = string> {
   ): ResultAsync<TValue, TError>;
   /**
    * Creates a new ResultAsync from the given Promise
-   * @param value a Promise returning a value which will be wrapped in a successful Result
+   * @param value a Promise resolving to a Result
+   * @param errorHandler
    */
   static from<TValue, TError>(
-    value: Promise<Some<TValue>>
+    value: Promise<Result<TValue, TError>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TValue, TError>;
   /**
    * Creates a new ResultAsync from the given Promise
-   * @param value a Promise returning a Result, if it resolves
+   * @param value a Promise which will be converted into a successful Result if it resolves
+   * and a failed Result if it rejects
    */
   static from<TValue, TError>(
-    value: Promise<Result<TValue, TError>>
+    value: Promise<Some<TValue>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TValue, TError>;
+
   static from<TValue, TError>(
     value:
-      | Promise<Some<TValue>>
-      | Promise<Result<TValue, TError>>
       | Result<TValue, TError>
+      | Promise<Result<TValue, TError>>
+      | Promise<Some<TValue>>,
+    errorHandler?: ErrorHandler<TError>
   ): ResultAsync<TValue, TError> {
     if (isPromise(value)) {
-      return new ResultAsync(
-        value.then((v) => (v instanceof Result ? v : Result.success(v)))
+      let promise = value.then((v) =>
+        v instanceof Result ? v : Result.success<TValue, TError>(v)
       );
+
+      if (isFunction(errorHandler)) {
+        promise = promise.catch((error) =>
+          Result.failure<TValue, TError>(errorHandler(error))
+        );
+      }
+
+      return new ResultAsync(promise);
     } else if (value instanceof Result) {
       return new ResultAsync(Promise.resolve(value));
     }
@@ -165,7 +180,7 @@ export class ResultAsync<TValue = Unit, TError = string> {
   private value: Promise<Result<TValue, TError>>;
 
   protected constructor(value: Promise<Result<TValue, TError>>) {
-    this.value = value.catch((error) => Result.failure(error));
+    this.value = value;
   }
 
   /**

src/utilities.ts

@@ -11,6 +11,8 @@ export type Some<T> = T extends None ? never : T;
 export type None = null | undefined | void;
 export type Known<TValue> = Exclude<unknown, TValue>;
 
+export type ErrorHandler<TError> = FunctionOfTtoK<unknown, Some<TError>>;
+
 export const never: ActionNever = () => {
   throw Error('This error should be unreachable');
 };

test/result/bindAsync.spec.ts

@@ -29,6 +29,19 @@ describe('Result', () => {
         expect(result).toFailWith(error);
         expect(wasCalled).toBe(false);
       });
+
+      test('will call the projection function when the original Result succeeds and convert a rejected Promise to a failed Result', async () => {
+        const sut = Result.success(1);
+
+        const result = await sut
+          .bindAsync(
+            (_number) => Promise.reject('reject'),
+            (e) => (typeof e === 'string' ? e : 'caught')
+          )
+          .toPromise();
+
+        expect(result).toFailWith('reject');
+      });
     });
 
     describe('ResultAsync', () => {

test/result/mapAsync.spec.ts

@@ -27,5 +27,20 @@ describe('Result', () => {
       expect(result).toFailWith(error);
       expect(wasCalled).toBe(false);
     });
+
+    test('will execute the mapping with a failed Result and convert a rejected Promise to a failed Result', async () => {
+      const sut = Result.success(1);
+
+      const result = await sut
+        .mapAsync(
+          (_num) => {
+            return Promise.reject('reject');
+          },
+          (e) => (typeof e === 'string' ? e : 'caught')
+        )
+        .toPromise();
+
+      expect(result).toFailWith('reject');
+    });
   });
 });

test/result/mapFailureAsync.spec.ts

@@ -28,5 +28,25 @@ describe('Result', () => {
       expect(innerResult).toSucceedWith(2);
       expect(wasCalled).toBe(true);
     });
+
+    test('will execute the projection with a failed Result and convert a rejected Promise to a failed Result', async () => {
+      const error = 'error';
+      let wasCalled = false;
+      const sut = Result.failure<number>(error);
+
+      const innerResult = await sut
+        .mapFailureAsync(
+          (_error) => {
+            wasCalled = true;
+
+            return Promise.reject('reject');
+          },
+          (e) => (typeof e === 'string' ? e : 'caught')
+        )
+        .toPromise();
+
+      expect(innerResult).toFailWith('reject');
+      expect(wasCalled).toBe(true);
+    });
   });
 });

test/result/tapAsync.spec.ts

@@ -17,16 +17,19 @@ describe('Result', () => {
         expect(wasCalled).toBe(true);
       });
 
-      test('will return a rejected Promise if the Result is successful and the asyncAction rejects', async () => {
+      test('will return a failed Result if the Result is successful and the asyncAction rejects', async () => {
         const sut = Result.success(1);
+        const error = 'error';
 
         const asyncAction = () => {
-          return Promise.reject('error');
+          return Promise.reject(error);
         };
 
-        const result = await sut.tapAsync(asyncAction).toPromise();
+        const innerResult = await sut
+          .tapAsync(asyncAction, (e) => (typeof e === 'string' ? e : 'caught'))
+          .toPromise();
 
-        expect(result).toFailWith('error');
+        expect(innerResult).toFailWith(error);
       });
 
       test('will not execute the asynchronous action if the Result is a failure', async () => {