Quais utilitários ajudam a trabalhar com código assíncrono (promisify, AbortController)?

Question

Accepted Answer

Node fornece vários utilitários que tornam o código assíncrono mais limpo e controlável — convertendo APIs callback antigas em Promises, cancelando operações e coordenando múltiplas tarefas assíncronas.

## Por que isso importa

```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` envolve qualquer função callback padrão `(args..., (err, result) => {})` para que você possa fazer `await` nela — útil para bibliotecas antigas que precedem Promises. (Muitas funções built-in agora oferecem versões promise diretamente, por exemplo `fs/promises`.)

## AbortController — cancele operações assíncronas

```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` fornece uma forma padrão de **cancelar** operações em andamento (fetch, timers, streams, muitas bibliotecas) — essencial para timeouts e para evitar trabalho desperdiçado quando um resultado não é mais necessário.

## Promise combinators — coordene múltiplas tarefas assíncronas

```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()]);
```

Estos combinadores expressam padrões comuns: `all` para paralelo-e-espere, `allSettled` quando você precisa de cada resultado independentemente de falhas, `race` para timeouts/vencedor-mais-rápido, `any` para fontes de fallback.

## setTimeout como Promise (moderno)

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

## Por que isso importa

Estes utilitários tornam o código Node assíncrono do mundo real mais limpo e robusto: `promisify` faz a ponte entre APIs callback antigas em async/await, `AbortController` adiciona cancelamento e timeouts (prevenindo operações travadas ou desperdiçadas), e os combinators Promise (`all`/`allSettled`/`race`/`any`) expressam padrões comuns de coordenação de forma concisa e correta.

Conhecê-los permite que você manipule paralelismo, cancelamento e fallback elegantemente em vez de reinventá-los — necessidades comuns em qualquer aplicação assíncrona não trivial.