Merge pull request #22 from GregOnNet/feature/bindFailure

feat(api): add bindFailure & bindFailureAsync

Author: seangwright

src/result.ts

@@ -767,6 +767,38 @@ export class Result<TValue = Unit, TError = string> {
       : resultAsyncOrPromise;
   }
 
+  /**
+   * Maps a failed Result to a new Result
+   * @param projection
+   * @returns
+   */
+  bindFailure(
+    projection: FunctionOfT<Result<TValue, TError>>
+  ): Result<TValue, TError> {
+    return this.isSuccess ? this : projection();
+  }
+
+  /**
+   * Maps a failed Result to a new ResultAsync
+   * @param projection
+   * @returns
+   */
+  bindFailureAsync(
+    projection:
+      | FunctionOfT<Promise<Result<TValue, TError>>>
+      | FunctionOfT<ResultAsync<TValue, TError>>
+  ): ResultAsync<TValue, TError> {
+    if (this.isSuccess) {
+      return ResultAsync.success(this.getValueOrThrow());
+    }
+
+    const resultAsyncOrPromise = projection();
+
+    return isPromise(resultAsyncOrPromise)
+      ? ResultAsync.from<TValue, TError>(resultAsyncOrPromise)
+      : resultAsyncOrPromise;
+  }
+
   /**
    * Executes an action if the current Result has succeeded
    * @param action a function given the value of the current Result

src/resultAsync.ts

@@ -495,6 +495,31 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
+  /**
+   * Maps a failed ResultAsync to a new ResultAsync
+   * @param projection
+   * @returns
+   */
+  bindFailure(
+    projection:
+      | FunctionOfT<Result<TValue, TError>>
+      | FunctionOfT<ResultAsync<TValue, TError>>
+  ): ResultAsync<TValue, TError> {
+    return new ResultAsync(
+      this.value.then((r) => {
+        if (r.isSuccess) {
+          return Result.success(r.getValueOrThrow());
+        }
+
+        const resultOrResultAsync = projection();
+
+        return resultOrResultAsync instanceof Result
+          ? resultOrResultAsync
+          : resultOrResultAsync.toPromise();
+      })
+    );
+  }
+
   /**
    * Executes the given async action if the ResultAsync is successful
    * @param action an async function given the value of the successful ResultAsync

test/result/bindFailure.spec.ts

@@ -0,0 +1,23 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('bindFailure', () => {
+    test('takes the result from the second result, when previous result fails', () => {
+      const sut = Result.failure('💥');
+
+      expect(sut.bindFailure(() => Result.success('✅'))).toSucceedWith('✅');
+    });
+
+    test('takes the result from the first result, when it succeeds', () => {
+      const sut = Result.success('✅');
+
+      expect(sut.bindFailure(() => Result.failure('💥'))).toSucceedWith('✅');
+    });
+
+    test('takes the failure from the second result, when both fail', () => {
+      const sut = Result.failure('💥');
+
+      expect(sut.bindFailure(() => Result.failure('💥💥'))).toFailWith('💥💥');
+    });
+  });
+});

test/result/bindFailureAsync.spec.ts

@@ -0,0 +1,70 @@
+import { Result } from '@/src/result';
+import { ResultAsync } from '../../src';
+
+describe('Result', () => {
+  describe('bindFailureAsync', () => {
+    describe('Promise', () => {
+      test('takes the result from the second result, when previous result fails', async () => {
+        const sut = Result.failure('💥');
+
+        const innerResult = await sut
+          .bindFailureAsync(() => Promise.resolve(Result.success('✅')))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the result from the first result, when it succeeds', async () => {
+        const sut = Result.success('✅');
+
+        const innerResult = await sut
+          .bindFailureAsync(() => Promise.resolve(Result.failure('💥')))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the failure from the second result, when both fail', async () => {
+        const sut = Result.failure('💥');
+
+        const innerResult = await sut
+          .bindFailureAsync(() => Promise.resolve(Result.failure('💥💥')))
+          .toPromise();
+
+        return expect(innerResult).toFailWith('💥💥');
+      });
+    });
+
+    describe('ResultAsync', () => {
+      test('takes the result from the second result, when previous result fails', async () => {
+        const sut = Result.failure('💥');
+
+        const innerResult = await sut
+          .bindFailureAsync(() => ResultAsync.success('✅'))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the result from the first result, when it succeeds', async () => {
+        const sut = Result.success('✅');
+
+        const innerResult = await sut
+          .bindFailureAsync(() => ResultAsync.failure('💥'))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the failure from the second result, when both fail', async () => {
+        const sut = Result.failure('💥');
+
+        const innerResult = await sut
+          .bindFailureAsync(() => ResultAsync.failure('💥💥'))
+          .toPromise();
+
+        return expect(innerResult).toFailWith('💥💥');
+      });
+    });
+  });
+});

test/resultAsync/bindFailure.spec.ts

@@ -0,0 +1,70 @@
+import { Result } from '@/src/result';
+import { ResultAsync } from '@/src/resultAsync';
+
+describe('ResultAsync', () => {
+  describe('bindFailure', () => {
+    describe('Result', () => {
+      test('takes the result from the second result, when previous result fails', async () => {
+        const sut = ResultAsync.failure('💥');
+
+        const innerResult = await sut
+          .bindFailure(() => Result.success('✅'))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the result from the first result, when it succeeds', async () => {
+        const sut = ResultAsync.success('✅');
+
+        const innerResult = await sut
+          .bindFailure(() => Result.failure('💥'))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the failure from the second result, when both fail', async () => {
+        const sut = ResultAsync.failure('💥');
+
+        const innerResult = await sut
+          .bindFailure(() => Result.failure('💥💥'))
+          .toPromise();
+
+        return expect(innerResult).toFailWith('💥💥');
+      });
+    });
+
+    describe('ResultAsync', () => {
+      test('takes the result from the second result, when previous result fails', async () => {
+        const sut = ResultAsync.failure('💥');
+
+        const innerResult = await sut
+          .bindFailure(() => ResultAsync.success('✅'))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the result from the first result, when it succeeds', async () => {
+        const sut = ResultAsync.success('✅');
+
+        const innerResult = await sut
+          .bindFailure(() => ResultAsync.failure('💥'))
+          .toPromise();
+
+        return expect(innerResult).toSucceedWith('✅');
+      });
+
+      test('takes the failure from the second result, when both fail', async () => {
+        const sut = ResultAsync.failure('💥');
+
+        const innerResult = await sut
+          .bindFailure(() => ResultAsync.failure('💥💥'))
+          .toPromise();
+
+        return expect(innerResult).toFailWith('💥💥');
+      });
+    });
+  });
+});