What utilities help work with async code (promisify, AbortController)?

Question

Accepted Answer

Node provides several utilities that make async code cleaner and more controllable — converting old callback APIs to Promises, cancelling operations, and coordinating multiple async tasks.

## promisify — convert callback APIs to Promises

```js
import { promisify } from "util";
import fs from "fs";

// turn an error-first callback function into a Promise-returning one
const readFileAsync = promisify(fs.readFile);
const data = await readFileAsync("file.txt", "utf8"); // now awaitable
```

`promisify` wraps any standard `(args..., (err, result) => {})` callback function so you can `await` it — useful for older libraries that predate Promises. (Many built-ins now offer promise versions directly, e.g. `fs/promises`.)

## AbortController — cancel async operations

```js
const controller = new AbortController();

// pass the signal to a cancellable operation
const promise = fetch("https://api.example.com", { signal: controller.signal });

// cancel it (e.g. on timeout or user navigation)
setTimeout(() => controller.abort(), 5000); // abort after 5s

try {
  await promise;
} catch (err) {
  if (err.name === "AbortError") console.log("request cancelled");
}
```

`AbortController` provides a standard way to **cancel** in-flight operations (fetch, timers, streams, many libraries) — essential for timeouts and avoiding wasted work when a result is no longer needed.

## Promise combinators — coordinate multiple async tasks

```js
// run in parallel, wait for ALL (fails fast if any rejects)
const [a, b, c] = await Promise.all([getA(), getB(), getC()]);

// wait for all, get each result OR error (never short-circuits)
const results = await Promise.allSettled([getA(), getB()]);

// the first to settle (resolve OR reject) wins
const fastest = await Promise.race([fetchPrimary(), fetchBackup()]);

// the first to FULFILL (ignores rejections until one succeeds)
const first = await Promise.any([source1(), source2()]);
```

These combinators express common patterns: `all` for parallel-and-wait, `allSettled` when you need every outcome regardless of failures, `race` for timeouts/fastest-wins, `any` for fallback sources.

## setTimeout as a Promise (modern)

```js
import { setTimeout as sleep } from "timers/promises";
await sleep(1000); // await a delay without wrapping in a Promise manually
```

## Why it matters

These utilities make real-world async Node code cleaner and more robust: `promisify` bridges legacy callback APIs into async/await, `AbortController` adds cancellation and timeouts (preventing hung or wasted operations), and the Promise combinators (`all`/`allSettled`/`race`/`any`) express common coordination patterns concisely and correctly.

Knowing them lets you handle parallelism, cancellation, and fallback elegantly instead of reinventing them — common needs in any non-trivial async application.