WIP: Add allSettled mode for Collector class

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased][unreleased]
 
+## [5.0.1][] - 2023-12-15
+
+- Add new properties `isRejectable` to Collector class: change behavior of `wait`, `take`, `collect` method in case of errors
+
 ## [5.0.0][] - 2023-12-10
 
 - Changed `Semaphore` signature, moved all parameters to `options`

lib/collector.js

@@ -7,17 +7,35 @@ class Collector {
   count = 0;
   exact = true;
   timeout = 0;
+  isRejectable = true;
   #fulfill = null;
   #reject = null;
   #timer = null;
   #cause = null;
 
-  constructor(keys, { exact = true, timeout = 0 } = {}) {
+  constructor(keys, { exact = true, timeout = 0, isRejectable = true } = {}) {
     this.keys = keys;
+    this.isRejectable = isRejectable;
     if (exact === false) this.exact = false;
     if (typeof timeout === 'number') this.#timeout(timeout);
   }
 
+  #setData(key, data) {
+    if (!this.isRejectable) {
+      this.set(key, getSettled(null, data));
+      return;
+    }
+    this.set(key, data);
+  }
+
+  #setError(key, err) {
+    if (!this.isRejectable) {
+      this.set(key, getSettled(err));
+      return;
+    }
+    this.fail(err);
+  }
+
   #timeout(msec) {
     this.timeout = msec;
     if (this.#timer) {
@@ -48,23 +66,23 @@ class Collector {
 
   take(key, fn, ...args) {
     fn(...args, (err, data) => {
-      if (err) this.fail(err);
-      else this.set(key, data);
+      if (err) this.#setError(key, err);
+      else this.#setData(key, data);
     });
   }
 
   wait(key, fn, ...args) {
     fn(...args).then(
-      (data) => this.set(key, data),
-      (err) => this.fail(err),
+      (data) => this.#setData(key, data),
+      (err) => this.#setError(key, err),
     );
   }
 
   collect(sources) {
     for (const [key, collector] of Object.entries(sources)) {
       collector.then(
-        (data) => this.set(key, data),
-        (err) => this.fail(err),
+        (data) => this.#setData(key, data),
+        (err) => this.#setError(key, err),
       );
     }
   }
@@ -88,6 +106,13 @@ class Collector {
   }
 }
 
+function getSettled(err = null, value = null) {
+  if (err) {
+    return { status: 'rejected', reason: err };
+  }
+  return { status: 'fulfilled', value };
+}
+
 const collect = (keys, options) => new Collector(keys, options);
 
 module.exports = { Collector, collect };

metautil.d.ts

@@ -235,6 +235,7 @@ export function sizeToBytes(size: string): number;
 export interface CollectorOptions {
   exact?: boolean;
   timeout?: number;
+  isRejectable?: boolean;
 }
 
 type AsyncFunction = (...args: Array<unknown>) => Promise<unknown>;

test/collector.js

@@ -209,3 +209,100 @@ metatests.test('Collector: error in then chain', (test) => {
     },
   );
 });
+
+metatests.test(
+  'Collector: wait isRejectable = true, all fulfilled',
+  async (test) => {
+    const expectedResult = { key1: 'User: Marcus', key2: 'User: Caesar' };
+    const dc = collect(['key1', 'key2']);
+
+    const fn = async (name) =>
+      new Promise((resolve) => {
+        setTimeout(() => resolve(`User: ${name}`), 100);
+      });
+    dc.wait('key1', fn, 'Marcus');
+    dc.wait('key2', fn, 'Caesar');
+
+    const result = await dc;
+    test.strictSame(result, expectedResult);
+    test.end();
+  },
+);
+
+metatests.test(
+  'Collector: wait isRejectable = true, rejected',
+  async (test) => {
+    const expectedResult = 'Error: Caesar';
+    const dc = collect(['key1', 'key2']);
+
+    const fn = async (name) =>
+      new Promise((resolve) => {
+        setTimeout(() => resolve(`User: ${name}`), 100);
+      });
+    const rejectFn = async (name) =>
+      new Promise((_, reject) => {
+        setTimeout(() => reject(`Error: ${name}`), 100);
+      });
+
+    dc.wait('key1', fn, 'Marcus');
+    dc.wait('key2', rejectFn, 'Caesar');
+
+    try {
+      await dc;
+      test.fail('Not rejected');
+    } catch (error) {
+      test.strictSame(error, expectedResult);
+    }
+    test.end();
+  },
+);
+
+metatests.test(
+  'Collector: wait isRejectable = false, all fulfilled',
+  async (test) => {
+    const expectedResult = {
+      key1: { status: 'fulfilled', value: 'User: Marcus' },
+      key2: { status: 'fulfilled', value: 'User: Caesar' },
+    };
+    const dc = collect(['key1', 'key2'], { isRejectable: false });
+
+    const fn = async (name) =>
+      new Promise((resolve) => {
+        setTimeout(() => resolve(`User: ${name}`), 100);
+      });
+
+    dc.wait('key1', fn, 'Marcus');
+    dc.wait('key2', fn, 'Caesar');
+
+    const result = await dc;
+    test.strictSame(result, expectedResult);
+    test.end();
+  },
+);
+
+metatests.test(
+  'Collector: wait isRejectable = false rejected',
+  async (test) => {
+    const expectedResult = {
+      key1: { status: 'fulfilled', value: 'User: Marcus' },
+      key2: { status: 'rejected', reason: 'Error: Caesar' },
+    };
+    const dc = collect(['key1', 'key2'], { isRejectable: false });
+
+    const fn = async (name) =>
+      new Promise((resolve) => {
+        setTimeout(() => resolve(`User: ${name}`), 100);
+      });
+    const rejectFn = async (name) =>
+      new Promise((_, reject) => {
+        setTimeout(() => reject(`Error: ${name}`), 100);
+      });
+
+    dc.wait('key1', fn, 'Marcus');
+    dc.wait('key2', rejectFn, 'Caesar');
+
+    const result = await dc;
+    test.strictSame(result, expectedResult);
+    test.end();
+  },
+);