Merge pull request #19 from seangwright/feat/result-tap-both

Feature: Result.tapEither/Async

Author: seangwright

README.md

@@ -64,12 +64,12 @@ The distributed library is currently not minified. Below are the module sizes wh
 - maybe.js: 0.81 kb
 - maybe.utilities.js: 0.27 kb
 - maybeAsync.js: 0.64 kb
-- result.js: 1.25 kb
-- resultAsync.js: 0.74 kb
+- result.js: 1.26 kb
+- resultAsync.js: 0.75 kb
 - unit.js: 0.13 kb
 - utilities.js: 0.27 kb
 
-Total: 4.33 kb
+Total: 4.36 kb
 
 ### Core Monads
 

package-lock.json

@@ -48,18 +48,18 @@
     "report:size": "node ./scripts/dist-size.mjs"
   },
   "devDependencies": {
-    "@babel/preset-typescript": "7.18.6",
-    "@types/node": "18.11.18",
-    "@vitest/coverage-c8": "0.28.1",
+    "@babel/preset-typescript": "7.21.5",
+    "@types/node": "18.16.3",
+    "@vitest/coverage-c8": "0.31.0",
     "cpy-cli": "4.2.0",
     "gzip-size": "7.0.0",
-    "jest": "28.1.3",
-    "prettier": "2.8.3",
+    "jest": "29.5.0",
+    "prettier": "2.8.8",
     "trash-cli": "5.0.0",
     "ts-node": "10.9.1",
-    "tslib": "2.4.1",
-    "typescript": "4.9.4",
+    "tslib": "2.5.0",
+    "typescript": "5.0.4",
     "uglify-js": "3.17.4",
-    "vitest": "0.28.2"
+    "vitest": "0.31.0"
   }
 }

package.json

@@ -3,6 +3,7 @@ import { Unit } from './unit.js';
 import {
   Action,
   ActionOfT,
+  AsyncAction,
   AsyncActionOfT,
   ErrorHandler,
   FunctionOfT,
@@ -850,6 +851,26 @@ export class Result<TValue = Unit, TError = string> {
     return this;
   }
 
+  /**
+   * Executes the action on both success and failure.
+   * @param action a function with no parameters returning no value
+   * @returns the current Result
+   */
+  tapEither(action: Action): Result<TValue, TError> {
+    action();
+
+    return this;
+  }
+
+  /**
+   * Executes the asynchronous action on both success and failure.
+   * @param action a function
+   * @returns the current Result wrapped in a ResultAsync
+   */
+  tapEitherAsync(action: AsyncAction): ResultAsync<TValue, TError> {
+    return ResultAsync.from<TValue, TError>(action().then(() => this));
+  }
+
   /**
    * Maps a successful Result's value to a new value,
    * or a failed Result's error to a new value

src/result.ts

@@ -1,6 +1,7 @@
 import { Result } from './result.js';
 import { Unit } from './unit.js';
 import {
+  Action,
   ActionOfT,
   AsyncAction,
   AsyncActionOfT,
@@ -558,6 +559,32 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
+  /**
+   * Executes the given async action if the ResultAsync is successful or failed
+   * @param action an async function
+   * @returns the current ResultAsync wrapping the inner Result
+   */
+  tapEither(asyncAction: AsyncAction): ResultAsync<TValue, TError>;
+  /**
+   * Executes the given action if the ResultAsync is successful or failed
+   * @param action a function
+   * @returns the current ResultAsync wrapping the inner Result
+   */
+  tapEither(action: Action): ResultAsync<TValue, TError>;
+  tapEither(action: Action | AsyncAction): ResultAsync<TValue, TError> {
+    return new ResultAsync(
+      this.value.then(async (originalResult) => {
+        const actionResult = action();
+
+        if (actionResult instanceof Promise) {
+          await actionResult;
+        }
+
+        return originalResult;
+      })
+    );
+  }
+
   /**
    *
    * @param matcher

src/resultAsync.ts

@@ -0,0 +1,25 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('tapEither', () => {
+    test('will execute the given action if the Result is successful', () => {
+      let wasCalled = false;
+      const sut = Result.success(1);
+
+      sut.tapEither(() => (wasCalled = true));
+
+      expect(wasCalled).toBe(true);
+      expect(sut).toSucceedWith(1);
+    });
+
+    test('will execute the given action if the Result is a failure', () => {
+      let wasCalled = false;
+      const sut = Result.failure<number>('error');
+
+      sut.tapEither(() => (wasCalled = true));
+
+      expect(wasCalled).toBe(true);
+      expect(sut).toFailWith('error');
+    });
+  });
+});

test/result/tapEither.spec.ts

@@ -0,0 +1,37 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('tapEitherAsync', () => {
+    describe('promise', () => {
+      test('will execute the asynchronous action if the Result is successful', async () => {
+        let wasCalled = false;
+        const sut = Result.success(1);
+
+        const asyncAction = () => {
+          wasCalled = true;
+          return Promise.resolve();
+        };
+
+        await sut.tapEitherAsync(asyncAction).toPromise();
+
+        expect(wasCalled).toBe(true);
+        expect(sut).toSucceedWith(1);
+      });
+
+      test('will execute the asynchronous action if the Result is a failure', async () => {
+        let wasCalled = false;
+        const sut = Result.failure<number>('error');
+
+        const asyncAction = () => {
+          wasCalled = true;
+          return Promise.resolve();
+        };
+
+        await sut.tapEitherAsync(asyncAction).toPromise();
+
+        expect(wasCalled).toBe(true);
+        expect(sut).toFailWith('error');
+      });
+    });
+  });
+});

test/result/tapEitherAsync.spec.ts

@@ -0,0 +1,71 @@
+import { ResultAsync } from '@/src/resultAsync';
+
+describe('ResultAsync', () => {
+  describe('tapEither', () => {
+    test('executes the action with a failed ResultAsync', async () => {
+      let wasCalled = false;
+      const sut = ResultAsync.failure<number>('error');
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+        })
+        .toPromise();
+
+      expect(result).toFailWith('error');
+      expect(wasCalled).toBe(true);
+    });
+
+    test('executes the action with a successful ResultAsync', async () => {
+      const value = 1;
+      let wasCalled = false;
+
+      const sut = ResultAsync.success(value);
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+        })
+        .toPromise();
+
+      expect(result).toSucceedWith(1);
+      expect(wasCalled).toBe(true);
+    });
+
+    test('executes the async action with a successful ResultAsync', async () => {
+      const value = 1;
+      let wasCalled = false;
+
+      const sut = ResultAsync.success(value);
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+
+          return Promise.resolve();
+        })
+        .toPromise();
+
+      expect(result).toSucceedWith(1);
+      expect(wasCalled).toBe(true);
+    });
+
+    test('executes the async action with a failed ResultAsync', async () => {
+      const error = 'error';
+      let wasCalled = false;
+
+      const sut = ResultAsync.failure(error);
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+
+          return Promise.resolve();
+        })
+        .toPromise();
+
+      expect(result).toFailWith(error);
+      expect(wasCalled).toBe(true);
+    });
+  });
+});