Merge pull request #8 from GregOnNet/feat/result-combine

feat(result): support combining multiple results

Author: seangwright

package-lock.json

@@ -47,6 +47,7 @@
   },
   "devDependencies": {
     "@babel/preset-typescript": "7.16.7",
+    "@jest/expect-utils": "^28.0.0-alpha.0",
     "@types/jest": "27.4.1",
     "cpy-cli": "4.1.0",
     "jest": "27.5.1",

package.json

@@ -21,10 +21,55 @@ import {
   Some,
 } from './utilities';
 
+/**
+ * Allows to extract the Value of the given Result-Type
+ * e.g. ResultValueOf<Result<string>> => string
+ */
+export type ResultValueOf<T> = T extends Result<infer TResultValue>
+  ? TResultValue
+  : unknown;
+
 /**
  * Represents a successful or failed operation
  */
 export class Result<TValue = Unit, TError = string> {
+  /**
+   * Combines several results (and any error messages) into a single result.
+   * The returned result will be a failure if any of the input results are failures.
+   *
+   * @param results The Results to be combined.
+   * @returns A Result that is a success when all the input results are also successes.
+   */
+  static combine<T extends Record<string, Result<unknown>>>(
+    results: T
+  ): Result<{ [K in keyof T]: ResultValueOf<T[K]> }> {
+    const resultEntries = Object.entries(results);
+
+    const failedResults = resultEntries.filter(
+      ([, result]) => result.isFailure
+    );
+    const succeededResults = resultEntries.filter(
+      ([, result]) => result.isSuccess
+    );
+
+    if (failedResults.length === 0) {
+      const values = succeededResults.reduce((resultValues, [key, result]) => {
+        resultValues[key] = result.getValueOrThrow();
+        return resultValues;
+      }, {} as { [key: string]: unknown });
+
+      return Result.success(
+        values as Some<{ [K in keyof T]: ResultValueOf<T[K]> }>
+      );
+    }
+
+    const errorMessages = failedResults
+      .map(([, result]) => result.getErrorOrThrow())
+      .join(', ');
+
+    return Result.failure(errorMessages);
+  }
+
   /**
    * Creates a new successful Result with a string error type
    * and Unit value type

src/result.ts

@@ -1,6 +1,7 @@
 import { Maybe } from '@/src/maybe';
 import { Result } from '@/src/result';
 import { FunctionOfT, isDefined, isFunction } from '@/src/utilities';
+import { equals } from '@jest/expect-utils';
 
 expect.extend({
   toHaveNoValue<TValue>(received: Maybe<TValue>): MatchResponse {
@@ -25,7 +26,7 @@ expect.extend({
 
     const value = received.getValueOrThrow();
 
-    return value === expectedValue
+    return equals(value, expectedValue)
       ? r(
           true,
           `expected [${received}] to have a value [${expectedValue}], but it has a value of [${value}]`
@@ -66,17 +67,15 @@ expect.extend({
 
     const value = received.getValueOrThrow();
 
-    if (expectedValue === value) {
-      return r(
-        true,
-        `expected [${received}] to be successful but not have value [${expectedValue}] but it did`
-      );
-    }
-
-    return r(
-      false,
-      `expected [${received}] to have value [${expectedValue}], but found value [${value}]`
-    );
+    return equals(expectedValue, value)
+      ? r(
+          true,
+          `expected [${received}] to be successful but not have value [${expectedValue}] but it did`
+        )
+      : r(
+          false,
+          `expected [${received}] to have value [${expectedValue}], but found value [${value}]`
+        );
   },
   toFail<TValue, TError>(received: Result<TValue, TError>) {
     return received.isSuccess

test/expectExtensions.ts

@@ -0,0 +1,54 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('combine', () => {
+    test('fails if one result fails', () => {
+      const success = Result.success(1);
+      const failure = Result.failure('1st Error');
+
+      const result = Result.combine({ success, failure });
+
+      expect(result).toFailWith('1st Error');
+    });
+
+    test('succeeds if one results succeed', () => {
+      const success = Result.success(1);
+
+      const result = Result.combine({ success });
+
+      expect(result).toSucceed();
+    });
+
+    test('succeeds if all results succeed', () => {
+      const success_1 = Result.success(1);
+      const success_2 = Result.success(2);
+
+      const result = Result.combine({ success_1, success_2 });
+
+      expect(result).toSucceed();
+    });
+
+    test('yields all result values on success', () => {
+      const success_1 = Result.success(1);
+      const success_2 = Result.success({ name: 'Arthur' });
+
+      const result = Result.combine({ success_1, success_2 });
+
+      expect(result).toSucceedWith({
+        success_1: 1,
+        success_2: { name: 'Arthur' },
+      });
+    });
+
+    test('concatenates error messages', () => {
+      const failure_1_message = '1st Error';
+      const failure_1 = Result.failure(failure_1_message);
+      const failure_2_message = '2nd Error';
+      const failure_2 = Result.failure(failure_2_message);
+
+      const result = Result.combine({ failure_1, failure_2 });
+
+      expect(result).toFailWith(`${failure_1_message}, ${failure_2_message}`);
+    });
+  });
+});