Promise.allSettled 怎麼用？多個 API 部分失敗時保留成功結果

1
async function settleNamed(tasks) {
2
  const names = tasks.map((task) => task.name);
3
  if (new Set(names).size !== names.length) {
4
    throw new Error('task names must be unique');
5
  }
6

7
  const results = await Promise.allSettled(
8
    tasks.map((task) => Promise.resolve().then(() => task.run())),
9
  );
10
  return Object.fromEntries(results.map((result, index) => [
11
    names[index], result,
12
  ]));
13
}

1
async function fetchJson(url, timeoutMs = 3_000) {
2
  const response = await fetch(url, {
3
    signal: AbortSignal.timeout(timeoutMs),
4
  });
5
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
6
  return await response.json();
7
}
8

9
const sections = await settleNamed([
10
  { name: 'profile', run: () => fetchJson('/api/profile') },
11
  { name: 'notifications', run: () => fetchJson('/api/notifications') },
12
  { name: 'recommendations', run: () => fetchJson('/api/recommendations') },
13
]);
14

15
if (sections.profile.status === 'fulfilled') {
16
  console.log('帳號資料', sections.profile.value);
17
} else {
18
  console.error('帳號區塊載入失敗', sections.profile.reason);
19
}

1
import assert from 'node:assert/strict';
2

3
const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
4
const completed = [];
5
const data = await settleNamed([
6
  { name: 'slow', run: async () => {
7
    await wait(20);
8
    completed.push('slow');
9
    return 42;
10
  } },
11
  { name: 'broken', run: () => { throw new Error('unavailable'); } },
12
  { name: 'fast', run: async () => {
13
    completed.push('fast');
14
    return 7;
15
  } },
16
]);
17

18
assert.deepEqual(completed, ['fast', 'slow']);
19
assert.deepEqual(Object.keys(data), ['slow', 'broken', 'fast']);
20
assert.equal(data.slow.value, 42);
21
assert.equal(data.broken.status, 'rejected');
22
assert.equal(data.broken.reason.message, 'unavailable');
23
assert.equal(data.fast.value, 7);
24
assert.deepEqual(await settleNamed([]), {});
25
await assert.rejects(settleNamed([
26
  { name: 'same', run: () => 1 },
27
  { name: 'same', run: () => 2 },
28
]));
29
console.log('allSettled checks passed');

1
import pLimit from 'p-limit';
2

3
async function settleNamedLimited(tasks, concurrency) {
4
  const limit = pLimit(concurrency);
5
  return settleNamed(tasks.map(task => ({
6
    name: task.name,
7
    run: () => limit(() => task.run()),
8
  })));
9
}

1
import assert from 'node:assert/strict';
2

3
function deferred() {
4
  let resolve;
5
  const promise = new Promise(ok => { resolve = ok; });
6
  return { promise, resolve };
7
}
8

9
const gates = Array.from({ length: 4 }, deferred);
10
const entered = Array.from({ length: 4 }, deferred);
11
const started = [];
12
let active = 0;
13
let peak = 0;
14
const failure = new Error('第三項失敗');
15
const tasks = gates.map((gate, index) => ({
16
  name: `section-${index}`,
17
  run: async () => {
18
    started.push(index);
19
    active += 1;
20
    peak = Math.max(peak, active);
21
    entered[index].resolve();
22
    try {
23
      await gate.promise;
24
      if (index === 2) throw failure;
25
      return index * 10;
26
    } finally {
27
      active -= 1;
28
    }
29
  },
30
}));
31

32
const batch = settleNamedLimited(tasks, 2);
33
await Promise.all([entered[0].promise, entered[1].promise]);
34
assert.deepEqual(started, [0, 1]);
35
assert.equal(active, 2);
36
gates[1].resolve();
37
await entered[2].promise;
38
assert.deepEqual(started, [0, 1, 2]);
39
gates[2].resolve();
40
await entered[3].promise;
41
assert.equal(active, 2);
42
gates[3].resolve();
43
gates[0].resolve();
44
const results = await batch;
45
assert.equal(peak, 2);
46
assert.equal(active, 0);
47
assert.deepEqual(Object.keys(results), tasks.map(task => task.name));
48
assert.equal(results['section-0'].value, 0);
49
assert.equal(results['section-1'].value, 10);
50
assert.equal(results['section-2'].status, 'rejected');
51
assert.equal(results['section-2'].reason, failure);
52
assert.equal(results['section-3'].value, 30);
53
assert.deepEqual(await settleNamedLimited([], 2), {});
54
await assert.rejects(settleNamedLimited([], 0), TypeError);
55
console.log('並行上限、失敗後續處理與名稱對應檢查通過');