Promise.all Rejects Early: Wait Before Cleaning Up

Reproduce cleanup happening before the last write#

Save the following as promise-cleanup.mjs and run node promise-cleanup.mjs. The complete fixture was executed on macOS with Node.js 24.13.0 on October 6, 2026. It uses in-memory event records rather than a real database or filesystem.

The first two cases use an explicitly released gate, so their ordering does not depend on a guessed timer duration. The third uses Node’s abortable promise timer to demonstrate cancellation of an operation that actually accepts a signal.

1
import assert from 'node:assert/strict';
2
import { setTimeout as delay } from 'node:timers/promises';
3

4
async function earlyCleanup() {
5
  const events = [];
6
  let release;
7
  const gate = new Promise((resolve) => { release = resolve; });
8
  const pending = (async () => {
9
    await gate;
10
    events.push('write');
11
  })();
12
  const tasks = [Promise.reject(new Error('failed')), pending];
13
  try {
14
    await Promise.all(tasks);
15
  } catch {
16
    events.push('caught');
17
  } finally {
18
    events.push('cleanup');
19
  }
20
  release();
21
  await Promise.allSettled(tasks);
22
  return events;
23
}
24

25
async function waitBeforeCleanup() {
26
  const events = [];
27
  let release;
28
  const gate = new Promise((resolve) => { release = resolve; });
29
  const pending = (async () => {
30
    await gate;
31
    events.push('write');
32
  })();
33
  const tasks = [Promise.reject(new Error('failed')), pending];
34
  const settled = Promise.allSettled(tasks);
35
  release();
36
  const results = await settled;
37
  events.push(results.map((result) => result.status).join('/'));
38
  events.push('cleanup');
39
  return events;
40
}
41

42
async function abortBeforeCleanup() {
43
  const events = [];
44
  const controller = new AbortController();
45
  const pending = (async () => {
46
    try {
47
      await delay(1000, undefined, { signal: controller.signal });
48
      events.push('write');
49
    } catch (error) {
50
      events.push(error.name);
51
      throw error;
52
    }
53
  })();
54
  const tasks = [Promise.reject(new Error('failed')), pending];
55
  try {
56
    await Promise.all(tasks);
57
  } catch (error) {
58
    events.push(error.message);
59
    controller.abort();
60
    await Promise.allSettled(tasks);
61
  } finally {
62
    events.push('cleanup');
63
  }
64
  return events;
65
}
66

67
const early = await earlyCleanup();
68
const waited = await waitBeforeCleanup();
69
const aborted = await abortBeforeCleanup();
70
assert.deepEqual(early, ['caught', 'cleanup', 'write']);
71
assert.deepEqual(waited, ['write', 'rejected/fulfilled', 'cleanup']);
72
assert.deepEqual(aborted, ['failed', 'AbortError', 'cleanup']);
73
console.log('all:', early.join(' -> '));
74
console.log('allSettled:', waited.join(' -> '));
75
console.log('abort + drain:', aborted.join(' -> '));

The assertions pass with this output:

1
all: caught -> cleanup -> write
2
allSettled: write -> rejected/fulfilled -> cleanup
3
abort + drain: failed -> AbortError -> cleanup

In earlyCleanup(), the gate remains closed until after finally runs. The later write event proves that catching the aggregate rejection did not finish the sibling task. The final allSettled() only drains that task so the demonstration can report its complete event list; it comes too late to protect the earlier cleanup.

Choose a completion boundary#

For an ordinary array of native promises, these choices give different boundaries:

The ECMAScript Promise.all algorithm attaches fulfillment and rejection handlers to the inputs. It does not provide an operation-cancellation step. MDN documents the early rejection and continued operations.

If every task should finish despite one failure, collect outcomes with Promise.allSettled(). Inspect each status; waiting successfully does not mean every task succeeded. In the fixture, rejected/fulfilled is the result order for the input array.

Abort, drain, then preserve the failure#

The cancellation case works because Node’s promise timers accept an AbortSignal. Calling abort() rejects the pending timer with AbortError. The catch block waits for both task promises before finally records cleanup.

In application code, keep the same order and rethrow the original error after draining. This helper is a complete, syntax-checked pattern; unlike the fixture above, it was not exercised against application resources:

1
async function runBatch(startTasks, cleanup) {
2
  const controller = new AbortController();
3
  let tasks = [];
4
  try {
5
    // startTasks must return an array synchronously without throwing
6
    // after starting work. Every task must honor the supplied signal
7
    // if cancellation is required.
8
    tasks = startTasks(controller.signal);
9
    return await Promise.all(tasks);
10
  } catch (error) {
11
    controller.abort();
12
    await Promise.allSettled(tasks);
13
    throw error;
14
  } finally {
15
    await cleanup();
16
  }
17
}

The contract matters: if a task launches background work and resolves before that work stops, draining its promise cannot protect the resource. If a task ignores the signal, draining waits for its normal completion. If a task never settles, cleanup waits indefinitely; this helper has no deadline. A rejecting cleanup() also replaces the return value or original error, so define how your application reports cleanup failures.

Cancellation does not roll back completed writes or prove that a remote server stopped processing a request. This example verifies a local timer only; database drivers, filesystem operations, browser requests, and server-side effects need their own cancellation checks.

Keep task failure separate from HTTP status#

A sibling fetch returning HTTP 404 will not trigger this cancellation path unless your task checks the response and throws. Use the status-before-JSON pattern when HTTP failures should reject the task.

Also, later rejections from the same native promises already passed to Promise.all() are handled by that combinator. They are not automatically unhandled rejections merely because another input failed first. Detached promises or ignored promises returned by additional .then() or .finally() calls are a separate diagnosis.

Before releasing a shared resource, verify that every operation using it is represented by a promise you have awaited through settlement. Choose cancellation separately, based on the underlying API.

References: ECMAScript: PerformPromiseAll, MDN: Promise.all, MDN: Promise.allSettled, Node.js: Cancelling timers. Checked October 6, 2026; fixture executed on Node.js 24.13.0.