refactor(lib): remove resultAsync promise error handling, add missing tests

Author: seangwright

src/result.ts

@@ -480,31 +480,29 @@ 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>>>,
-    errorHandler?: ErrorHandler<TError>
+    projection: FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>
   ): ResultAsync<TNewValue, TError> {
     return this.isSuccess
-      ? ResultAsync.from(projection(this.getValueOrThrow()), errorHandler)
+      ? ResultAsync.from(projection(this.getValueOrThrow()))
       : 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>>>,
-    errorHandler?: ErrorHandler<TError>
+    projection: FunctionOfTtoK<TError, Promise<Some<TValue>>>
   ): ResultAsync<TValue, TError> {
     return this.isSuccess
       ? ResultAsync.from(this)
-      : ResultAsync.from(projection(this.getErrorOrThrow()), errorHandler);
+      : ResultAsync.from(projection(this.getErrorOrThrow()));
   }
 
   /**
@@ -523,11 +521,10 @@ 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>>>,
-    errorHandler?: ErrorHandler<TError>
+    projection: FunctionOfTtoK<TValue, Promise<Result<TNewValue, TError>>>
   ): ResultAsync<TNewValue, TError>;
   /**
    * Maps a successful Result to a new ResultAsync
@@ -539,14 +536,13 @@ 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>>,
-    errorHandler?: ErrorHandler<TError>
+      | FunctionOfTtoK<TValue, ResultAsync<TNewValue, TError>>
   ): ResultAsync<TNewValue, TError> {
     if (this.isFailure) {
       return ResultAsync.failure(this.getErrorOrThrow());
@@ -555,7 +551,7 @@ export class Result<TValue = Unit, TError = string> {
     const resultAsyncOrPromise = projection(this.getValueOrThrow());
 
     return isPromise(resultAsyncOrPromise)
-      ? ResultAsync.from<TNewValue, TError>(resultAsyncOrPromise, errorHandler)
+      ? ResultAsync.from<TNewValue, TError>(resultAsyncOrPromise)
       : resultAsyncOrPromise;
   }
 
@@ -588,23 +584,17 @@ 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>,
-    errorHandler?: ErrorHandler<TError>
-  ): ResultAsync<TValue, TError> {
+  tapAsync(action: AsyncActionOfT<TValue>): ResultAsync<TValue, TError> {
     if (this.isFailure) {
       return ResultAsync.failure(this.getErrorOrThrow());
     }
 
     const value = this.getValueOrThrow();
 
-    return ResultAsync.from(
-      action(value).then<Some<TValue>>(() => value),
-      errorHandler
-    );
+    return ResultAsync.from(action(value).then<Some<TValue>>(() => value));
   }
 
   /**
@@ -749,7 +739,7 @@ export class Result<TValue = Unit, TError = string> {
       }
     };
 
-    return ResultAsync.from<TValue, TError>(promiseFactory(), errorHander);
+    return ResultAsync.from<TValue, TError>(promiseFactory());
   }
 
   /**

src/resultAsync.ts

@@ -1,4 +1,3 @@
-import { ErrorHandler } from '.';
 import { Result } from './result';
 import { Unit } from './unit';
 import {
@@ -31,41 +30,31 @@ export class ResultAsync<TValue = Unit, TError = string> {
   /**
    * Creates a new ResultAsync from the given Promise
    * @param value a Promise resolving to a Result
-   * @param errorHandler
    */
   static from<TValue, TError>(
-    value: Promise<Result<TValue, TError>>,
-    errorHandler?: ErrorHandler<TError>
+    value: Promise<Result<TValue, TError>>
   ): ResultAsync<TValue, TError>;
   /**
    * Creates a new ResultAsync from the given Promise
    * @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<Some<TValue>>,
-    errorHandler?: ErrorHandler<TError>
+    value: Promise<Some<TValue>>
   ): ResultAsync<TValue, TError>;
 
   static from<TValue, TError>(
     value:
       | Result<TValue, TError>
       | Promise<Result<TValue, TError>>
-      | Promise<Some<TValue>>,
-    errorHandler?: ErrorHandler<TError>
+      | Promise<Some<TValue>>
   ): ResultAsync<TValue, TError> {
     if (isPromise(value)) {
-      let promise = value.then((v) =>
-        v instanceof Result ? v : Result.success<TValue, TError>(v)
+      return new ResultAsync(
+        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));
     }
@@ -293,24 +282,24 @@ export class ResultAsync<TValue = Unit, TError = string> {
 
   /**
    * Converts the inner value of a successful Result to a new value.
-   * If the Result failed, no action is taken
-   * @param projection function which accepts the current value as a parameter and returns a new value
+   * @param projection function which accepts the current value as a parameter and returns a Promise containing
+   * the new value
    */
   map<TNewValue>(
-    projection: FunctionOfTtoK<TValue, Some<TNewValue>>
+    projection: FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>
   ): ResultAsync<TNewValue, TError>;
   /**
    * Converts the inner value of a successful Result to a new value.
-   * @param projection function which accepts the current value as a parameter and returns a Promise containing
-   * the new value
+   * If the Result failed, no action is taken
+   * @param projection function which accepts the current value as a parameter and returns a new value
    */
   map<TNewValue>(
-    projection: FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>
+    projection: FunctionOfTtoK<TValue, Some<TNewValue>>
   ): ResultAsync<TNewValue, TError>;
   map<TNewValue>(
     projection:
-      | FunctionOfTtoK<TValue, Some<TNewValue>>
       | FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>
+      | FunctionOfTtoK<TValue, Some<TNewValue>>
   ): ResultAsync<TNewValue, TError> {
     return new ResultAsync(
       this.value.then((r) => {
@@ -329,16 +318,20 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
+  /**
+   *
+   * @param projection
+   */
   mapError<TNewError>(
-    projection: FunctionOfTtoK<TError, Some<TNewError>>
+    projection: FunctionOfTtoK<TError, Promise<Some<TNewError>>>
   ): ResultAsync<TValue, TNewError>;
   mapError<TNewError>(
-    projection: FunctionOfTtoK<TError, Promise<Some<TNewError>>>
+    projection: FunctionOfTtoK<TError, Some<TNewError>>
   ): ResultAsync<TValue, TNewError>;
   mapError<TNewError>(
     projection:
-      | FunctionOfTtoK<TError, Some<TNewError>>
       | FunctionOfTtoK<TError, Promise<Some<TNewError>>>
+      | FunctionOfTtoK<TError, Some<TNewError>>
   ): ResultAsync<TValue, TNewError> {
     return new ResultAsync(
       this.value.then((r) => {
@@ -357,6 +350,43 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
+  mapFailure(
+    projection: FunctionOfTtoK<TError, Promise<Some<TValue>>>
+  ): ResultAsync<TValue, TError>;
+  /**
+   * Converts a failed Result into a successful one
+   * @param projection a function that maps the error of the current Result to a value
+   * @returns A successful Result using the current Result's value if it succeeded and the projection's value if it failed
+   */
+  mapFailure(
+    projection: FunctionOfTtoK<TError, Some<TValue>>
+  ): ResultAsync<TValue, TError>;
+  mapFailure(
+    projection:
+      | FunctionOfTtoK<TError, Promise<Some<TValue>>>
+      | FunctionOfTtoK<TError, Some<TValue>>
+  ): ResultAsync<TValue, TError> {
+    return new ResultAsync(
+      this.value.then((r) => {
+        if (r.isSuccess) {
+          return r;
+        }
+
+        const valueOrPromise = projection(r.getErrorOrThrow());
+
+        if (isPromise(valueOrPromise)) {
+          return valueOrPromise.then((v) => Result.success(v));
+        }
+
+        return Result.success(valueOrPromise);
+      })
+    );
+  }
+
+  /**
+   *
+   * @param projection
+   */
   bind<TNewValue>(
     projection: FunctionOfTtoK<TValue, Result<TNewValue, TError>>
   ): ResultAsync<TNewValue, TError>;
@@ -385,13 +415,17 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
-  tap(action: ActionOfT<TValue>): ResultAsync<TValue, TError>;
+  /**
+   *
+   * @param action
+   */
   tap(
     asyncAction: FunctionOfTtoK<TValue, Promise<void>>
   ): ResultAsync<TValue, TError>;
   tap<TOtherValue>(
     asyncAction: FunctionOfTtoK<TValue, ResultAsync<TOtherValue, TError>>
   ): ResultAsync<TValue, TError>;
+  tap(action: ActionOfT<TValue>): ResultAsync<TValue, TError>;
   tap<TOtherValue>(
     action:
       | ActionOfT<TValue>
@@ -421,21 +455,29 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
+  /**
+   *
+   * @param conditionOrPredicate
+   * @param action
+   * @returns
+   */
   tapIf(
     conditionOrPredicate: boolean | PredicateOfT<TValue>,
     action: ActionOfT<TValue>
   ): ResultAsync<TValue, TError> {
     return new ResultAsync(
       this.value.then((r) => {
-        if (isFunction(conditionOrPredicate)) {
-          return r.tapIf(conditionOrPredicate, action);
-        }
-
-        return r.tapIf(conditionOrPredicate, action);
+        return isFunction(conditionOrPredicate)
+          ? r.tapIf(conditionOrPredicate, action)
+          : r.tapIf(conditionOrPredicate, action);
       })
     );
   }
 
+  /**
+   *
+   * @param matcher
+   */
   match<TNewValue>(
     matcher: ResultMatcher<TValue, TError, TNewValue>
   ): Promise<Some<TNewValue>>;
@@ -448,15 +490,20 @@ export class ResultAsync<TValue = Unit, TError = string> {
     return this.value.then((r) => r.match(matcher));
   }
 
+  /**
+   *
+   * @param projection
+   * @returns
+   */
   finally<TNewValue>(
     projection: FunctionOfTtoK<Result<TValue, TError>, Some<TNewValue>>
   ): Promise<Some<TNewValue>> {
     return this.value.then((r) => r.finally(projection));
   }
 
-  onFailure(action: ActionOfT<TError>): ResultAsync<TValue, TError>;
-  onFailure(action: AsyncActionOfT<TError>): ResultAsync<TValue, TError>;
-  onFailure(
+  tapFailure(action: ActionOfT<TError>): ResultAsync<TValue, TError>;
+  tapFailure(action: AsyncActionOfT<TError>): ResultAsync<TValue, TError>;
+  tapFailure(
     action: ActionOfT<TError> | AsyncActionOfT<TError>
   ): ResultAsync<TValue, TError> {
     return new ResultAsync(

test/result/bindAsync.spec.ts

@@ -29,19 +29,6 @@ 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,20 +27,5 @@ 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');
-    });
   });
 });