¿Qué utilidades ayudan a trabajar con código asíncrono (promisify, AbortController)?

Question

Accepted Answer

Node proporciona varias utilidades que hacen el código asíncrono más limpio y controlable — convirtiendo viejas APIs basadas en callbacks a Promesas, cancelando operaciones y coordinando múltiples tareas asíncronas.

## promisify — convierte APIs de callbacks a Promesas

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

// convierte una función de callback error-first en una que retorna una Promesa
const readFileAsync = promisify(fs.readFile);
const data = await readFileAsync("file.txt", "utf8"); // ahora se puede usar con await
```

`promisify` envuelve cualquier función estándar de callback `(args..., (err, result) => {})` para que puedas usar `await` con ella — útil para bibliotecas antiguas anteriores a las Promesas. (Muchos módulos integrados ahora ofrecen versiones con Promesas directamente, p. ej. `fs/promises`.)

## AbortController — cancela operaciones asíncronas

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

// pasa el signal a una operación cancelable
const promise = fetch("https://api.example.com", { signal: controller.signal });

// cancélala (p. ej. al cumplirse un timeout o al navegar el usuario)
setTimeout(() => controller.abort(), 5000); // aborta tras 5s

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

`AbortController` proporciona una forma estándar de **cancelar** operaciones en curso (fetch, timers, streams, muchas bibliotecas) — esencial para timeouts y para evitar trabajo desperdiciado cuando un resultado ya no es necesario.

## Combinadores de Promesas — coordinan múltiples tareas asíncronas

```js
// ejecuta en paralelo, espera por TODAS (falla rápido si alguna se rechaza)
const [a, b, c] = await Promise.all([getA(), getB(), getC()]);

// espera por todas, obtiene cada resultado O error (nunca se cortocircuita)
const results = await Promise.allSettled([getA(), getB()]);

// la primera en resolverse (cumplirse O rechazarse) gana
const fastest = await Promise.race([fetchPrimary(), fetchBackup()]);

// la primera en CUMPLIRSE (ignora los rechazos hasta que una tenga éxito)
const first = await Promise.any([source1(), source2()]);
```

Estos combinadores expresan patrones comunes: `all` para ejecutar en paralelo y esperar, `allSettled` cuando necesitas cada resultado sin importar las fallas, `race` para timeouts/el-más-rápido-gana, `any` para fuentes de respaldo.

## setTimeout como Promesa (moderno)

```js
import { setTimeout as sleep } from "timers/promises";
await sleep(1000); // espera un retardo con await sin envolverlo manualmente en una Promesa
```

## Por qué es importante

Estas utilidades hacen que el código asíncrono real de Node sea más limpio y robusto: `promisify` conecta APIs heredadas de callbacks con async/await, `AbortController` agrega cancelación y timeouts (evitando operaciones colgadas o desperdiciadas), y los combinadores de Promesas (`all`/`allSettled`/`race`/`any`) expresan patrones comunes de coordinación de forma concisa y correcta.

Conocerlos te permite manejar el paralelismo, la cancelación y los respaldos con elegancia en lugar de reinventarlos — necesidades comunes en cualquier aplicación asíncrona no trivial.