Promise.any 搶到錯誤回應？先驗證 HTTP 與 JSON 再選最快結果

1
async function readCandidate(url) {
2
  const response = await fetch(url, {
3
    signal: AbortSignal.timeout(3_000),
4
  });
5
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
6
  const data = await response.json();
7
  if (typeof data?.title !== 'string' || data.title.trim() === '') {
8
    throw new TypeError('title must be a non-empty string');
9
  }
10
  return { url, data };
11
}

1
import assert from 'node:assert/strict';
2
import http from 'node:http';
3
import { once } from 'node:events';
4

5
let release;
6
const gate = new Promise(resolve => { release = resolve; });
7
const server = http.createServer(async (req, res) => {
8
  res.setHeader('Content-Type', 'application/json');
9
  if (req.url === '/good') {
10
    await gate;
11
    res.end('{"title":"可用資料"}');
12
  } else if (req.url === '/status') {
13
    res.statusCode = 503;
14
    res.end('{"error":"unavailable"}');
15
  } else if (req.url === '/syntax') {
16
    res.end('not json');
17
  } else {
18
    res.end('{"error":"wrong shape"}');
19
  }
20
});
21
server.listen(0, '127.0.0.1');
22
await once(server, 'listening');
23
const base = `http://127.0.0.1:${server.address().port}`;
24

25
try {
26
  // HTTP 503 本身不會讓 fetch reject。
27
  const raw = await fetch(base + '/status');
28
  assert.equal(raw.ok, false);
29
  assert.equal(raw.status, 503);
30
  await raw.text();
31

32
  const urls = ['/good', '/status', '/shape'].map(path => base + path);
33
  const jobs = urls.map(readCandidate);
34
  let settled = false;
35
  const winner = Promise.any(jobs).finally(() => { settled = true; });
36
  await Promise.allSettled(jobs.slice(1));
37
  assert.equal(settled, false);
38
  release();
39
  assert.deepEqual(await winner, {
40
    url: base + '/good', data: { title: '可用資料' },
41
  });
42
  await Promise.allSettled(jobs);
43

44
  await assert.rejects(Promise.any([
45
    readCandidate(base + '/status'),
46
    readCandidate(base + '/syntax'),
47
    readCandidate(base + '/shape'),
48
  ]), error => {
49
    assert.ok(error instanceof AggregateError);
50
    assert.equal(error.errors.length, 3);
51
    assert.equal(error.errors[0].message, 'HTTP 503');
52
    assert.ok(error.errors[1] instanceof SyntaxError);
53
    assert.ok(error.errors[2] instanceof TypeError);
54
    return true;
55
  });
56
  await assert.rejects(Promise.any([]), error => {
57
    assert.ok(error instanceof AggregateError);
58
    assert.deepEqual(error.errors, []);
59
    return true;
60
  });
61
  console.log('HTTP、解析、格式、全部失敗與空清單檢查通過');
62
} finally {
63
  release();
64
  server.closeAllConnections();
65
  await new Promise(resolve => server.close(resolve));
66
}

1
async function firstValidAndWait(tasks) {
2
  if (!Array.isArray(tasks) || tasks.length === 0) {
3
    throw new TypeError('Expected non-empty task array');
4
  }
5
  for (let i = 0; i < tasks.length; i += 1) {
6
    if (!Object.hasOwn(tasks, i) || typeof tasks[i] !== 'function') {
7
      throw new TypeError('Expected dense task functions');
8
    }
9
  }
10
  const controllers = tasks.map(() => new AbortController());
11
  const jobs = tasks.map((task, index) => Promise.resolve()
12
    .then(() => task(controllers[index].signal))
13
    .then(value => ({ index, value })));
14
  let winnerIndex = -1;
15
  try {
16
    const winner = await Promise.any(jobs);
17
    winnerIndex = winner.index;
18
    return winner.value;
19
  } finally {
20
    controllers.forEach((controller, index) => {
21
      if (index !== winnerIndex) controller.abort();
22
    });
23
    await Promise.allSettled(jobs);
24
  }
25
}

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

3
let observeAbort;
4
const aborted = new Promise(resolve => { observeAbort = resolve; });
5
let finishCleanup;
6
const cleanupGate = new Promise(resolve => { finishCleanup = resolve; });
7
let finished = false;
8
const result = firstValidAndWait([
9
  async () => 'valid data',
10
  async signal => {
11
    try {
12
      await new Promise((resolve, reject) => {
13
        const onAbort = () => {
14
          observeAbort();
15
          reject(signal.reason);
16
        };
17
        if (signal.aborted) onAbort();
18
        else signal.addEventListener('abort', onAbort, { once: true });
19
      });
20
    } finally {
21
      await cleanupGate;
22
    }
23
  },
24
]).finally(() => { finished = true; });
25
await aborted;
26
assert.equal(finished, false);
27
finishCleanup();
28
assert.equal(await result, 'valid data');
29
assert.equal(finished, true);
30

31
const firstError = new Error('first input');
32
const secondError = new Error('second input');
33
await assert.rejects(firstValidAndWait([
34
  () => { throw firstError; },
35
  async () => { throw secondError; },
36
]), error => {
37
  assert.ok(error instanceof AggregateError);
38
  assert.deepEqual(error.errors, [firstError, secondError]);
39
  return true;
40
});
41
await assert.rejects(firstValidAndWait([]), TypeError);
42
await assert.rejects(firstValidAndWait(new Array(2)), TypeError);
43
assert.equal(await firstValidAndWait([
44
  () => { throw new Error('sync failure'); },
45
  async () => 'second candidate',
46
]), 'second candidate');
47
console.log('勝出資料、取消通知、清理等待與全部失敗檢查通過');