Merge pull request #35 from GregOnNet/feature/combine-in-order

feature: combineInOrderAsync

Author: seangwright

.vscode/settings.json

@@ -10,8 +10,8 @@
   },
 
   "editor.codeActionsOnSave": {
-    "source.fixAll": true,
-    "source.organizeImports": true
+    "source.fixAll": "explicit",
+    "source.organizeImports": "explicit"
   },
 
   "editor.defaultFormatter": "esbenp.prettier-vscode",

src/result.ts

@@ -23,12 +23,20 @@ import {
 } from './utilities.js';
 
 /**
- * Allows to extract the Value of the given Result-Type
- * e.g. ResultValueOf<Result<string>> => string
+ * Allows to extract the Value of the given `Result` or `ResultAsync`
+ *
+ * @example ResultValue<Result<string>> => string
+ * @example ResultValue<ResultAsync<string>> => string
  */
-export type ResultValueOf<T> = T extends Result<infer TResultValue>
+export type ResultValue<T> = T extends Result<infer TResultValue>
   ? TResultValue
-  : unknown;
+  : T extends ResultAsync<infer TResultAsyncValue>
+  ? TResultAsyncValue
+  : never;
+
+export type ResultRecord<TResultRecord> = {
+  [K in keyof TResultRecord]: ResultValue<TResultRecord[K]>;
+};
 
 /**
  * Represents a successful Result operation.
@@ -55,9 +63,9 @@ export class Result<TValue = Unit, TError = string> {
    * @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]> }> {
+  static combine<TResultRecord extends Record<string, Result<unknown>>>(
+    results: TResultRecord
+  ): Result<ResultRecord<TResultRecord>> {
     const resultEntries = Object.entries(results);
 
     const failedResults = resultEntries.filter(
@@ -74,7 +82,9 @@ export class Result<TValue = Unit, TError = string> {
       }, {} as { [key: string]: unknown });
 
       return Result.success(
-        values as Some<{ [K in keyof T]: ResultValueOf<T[K]> }>
+        values as Some<{
+          [K in keyof TResultRecord]: ResultValue<TResultRecord[K]>;
+        }>
       );
     }
 
@@ -85,6 +95,12 @@ export class Result<TValue = Unit, TError = string> {
     return Result.failure(errorMessages);
   }
 
+  static combineInOrderAsync<
+    TResultRecord extends Record<string, Result<unknown> | ResultAsync<unknown>>
+  >(record: TResultRecord): ResultAsync<ResultRecord<TResultRecord>> {
+    return ResultAsync.combineInOrder(record);
+  }
+
   /**
    * Creates a new successful Result with a string error type
    * and Unit value type
@@ -692,7 +708,7 @@ 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
-   
+
    * @returns
    */
   mapAsync<TNewValue>(
@@ -706,7 +722,7 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * 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
-   
+
    * @returns
    */
   mapFailureAsync(
@@ -733,7 +749,7 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * Maps a successful Result to a new ResultAsync
    * @param projection
-   
+
    */
   bindAsync<TNewValue>(
     projection: FunctionOfTtoK<TValue, Promise<Result<TNewValue, TError>>>
@@ -748,7 +764,7 @@ export class Result<TValue = Unit, TError = string> {
   /**
    * Maps a successful Result to a new ResultAsync
    * @param projection
-   
+
    * @returns
    */
   bindAsync<TNewValue>(
@@ -856,7 +872,7 @@ 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
-   
+
    * @returns a ResultAsync
    */
   tapAsync(action: AsyncActionOfT<TValue>): ResultAsync<TValue, TError> {

src/resultAsync.ts

@@ -1,4 +1,4 @@
-import { Result } from './result.js';
+import { Result, type ResultRecord } from './result.js';
 import { Unit } from './unit.js';
 import {
   Action,
@@ -23,6 +23,50 @@ import {
  * Represents and asynchronous Result that could succeed with a value or fail with an error
  */
 export class ResultAsync<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.
+   *
+   * Asynchronous operations are executed one after another.
+   *
+   * @param results The Results to be combined.
+   * @returns A Result that is a success when all the input results are also successes.
+   */
+  static combineInOrder<
+    TResultRecord extends Record<string, Result<unknown> | ResultAsync<unknown>>
+  >(results: TResultRecord): ResultAsync<ResultRecord<TResultRecord>> {
+    const entries = Object.entries(results);
+
+    const promiseResult = entries
+      .reduce(
+        async (accumulator, [key, result]) => {
+          const sink = await accumulator;
+
+          const resolvedResult =
+            result instanceof Result ? result : await result.toPromise();
+
+          resolvedResult.isSuccess
+            ? (sink.values[key] = resolvedResult.getValueOrThrow())
+            : sink.errors.push(resolvedResult.getErrorOrThrow());
+
+          return sink;
+        },
+        Promise.resolve({
+          errors: [],
+          values: {},
+        } as { errors: string[]; values: { [key: string]: unknown } })
+      )
+      .then((valuesAndErrors) =>
+        valuesAndErrors.errors.length
+          ? Result.failure(valuesAndErrors.errors.join(', '))
+          : Result.success(valuesAndErrors.values)
+      );
+
+    return ResultAsync.from(
+      promiseResult as Promise<Result<ResultRecord<TResultRecord>>>
+    );
+  }
+
   /**
    * Creates a new ResultAsync from the given Result
    * @param value a successful or failed Result

test/result/combineInOrderAsync.spec.ts

@@ -0,0 +1,39 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('combineInOrderAsync', () => {
+    test('fails if one result fails', async () => {
+      const success = Result.success(1);
+      const failure = Result.failure('1st Error');
+
+      const sut = await Result.combineInOrderAsync({
+        success,
+        failure,
+      }).toPromise();
+
+      expect(sut).toFailWith('1st Error');
+    });
+
+    test('succeeds if one results succeed', async () => {
+      const success = Result.success(1);
+
+      const sut = await Result.combineInOrderAsync({ success }).toPromise();
+
+      expect(sut).toSucceed();
+    });
+
+    test('concatenates error messages', async () => {
+      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 sut = await Result.combineInOrderAsync({
+        failure_1,
+        failure_2,
+      }).toPromise();
+
+      expect(sut).toFailWith(`${failure_1_message}, ${failure_2_message}`);
+    });
+  });
+});

test/resultAsync/combine-in-order.spec.ts

@@ -0,0 +1,102 @@
+import { Result } from '@/src/result';
+import { ResultAsync } from '@/src/resultAsync';
+
+describe('ResultAsync', () => {
+  describe('combineInOrder', () => {
+    it('succeeds with one successful ResultAsync', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        success: ResultAsync.success('✅'),
+      }).toPromise();
+
+      expect(sut).toSucceedWith({
+        success: '✅',
+      });
+    });
+
+    it('succeeds with two successful ResultAsync', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        first: ResultAsync.success('✅'),
+        second: ResultAsync.success('✅'),
+      }).toPromise();
+
+      expect(sut).toSucceedWith({
+        first: '✅',
+        second: '✅',
+      });
+    });
+
+    it('fails with one failed ResultAsync', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        failure: ResultAsync.failure('💥'),
+      }).toPromise();
+
+      expect(sut).toFailWith('💥');
+    });
+
+    it('fails with one successful and one failed ResultAsync', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        success: ResultAsync.success('✅'),
+        failure: ResultAsync.failure('💥'),
+      }).toPromise();
+
+      expect(sut).toFailWith('💥');
+    });
+
+    it('succeeds with one successful Result', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        success: Result.success('✅'),
+      }).toPromise();
+
+      expect(sut).toSucceedWith({
+        success: '✅',
+      });
+    });
+
+    it('succeeds with two successful Results', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        first: Result.success('✅'),
+        second: Result.success('✅'),
+      }).toPromise();
+
+      expect(sut).toSucceedWith({
+        first: '✅',
+        second: '✅',
+      });
+    });
+
+    it('fails with one failed Result', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        failure: Result.failure('💥'),
+      }).toPromise();
+
+      expect(sut).toFailWith('💥');
+    });
+
+    it('fails with one successful and one failed Result', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        success: Result.success('✅'),
+        failure: Result.failure('💥'),
+      }).toPromise();
+
+      expect(sut).toFailWith('💥');
+    });
+
+    it('fails with mixed types when one fails', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        sut: Result.success('✅'),
+        sutAsync: ResultAsync.failure('💥'),
+      }).toPromise();
+
+      expect(sut).toFailWith('💥');
+    });
+
+    it('concatenates failures', async () => {
+      const sut = await ResultAsync.combineInOrder({
+        sut: Result.failure('💥'),
+        sutAsync: ResultAsync.failure('💥'),
+      }).toPromise();
+
+      expect(sut).toFailWith('💥, 💥');
+    });
+  });
+});