¿Cómo se manejan los errores en código asíncrono de Node?

Question

Accepted Answer

El manejo de errores difiere según el estilo asíncrono, y hacerlo mal causa fallos silenciosos o crasheos. Las reglas clave: usa `try/catch` con async/await, maneja siempre los rechazos de Promesas, y nunca dejes que los errores en callbacks asíncronos escapen sin manejar.

## async/await — usa try/catch

```js
async function getUser(id) {
  try {
    const user = await db.findUser(id);   // un rechazo aquí lanza hacia el catch
    return user;
  } catch (err) {
    logger.error(err);
    throw new AppError("Failed to load user", { cause: err }); // relanzar de forma significativa
  }
}
```

## Promesas — siempre .catch

```js
fetchData()
  .then(process)
  .catch(err => logger.error(err)); // un rechazo no manejado puede crashear el proceso
```

Un rechazo de Promesa sin `.catch` (o sin try/catch alrededor del `await`) se convierte en un **rechazo no manejado** — que en el Node moderno termina el proceso.

## La trampa clásica: los errores en callbacks asíncronos escapan del try/catch

```js
// ❌ try/catch NO captura esto — el throw ocurre en un tick POSTERIOR
try {
  setTimeout(() => { throw new Error("boom"); }, 100);
} catch (e) { /* nunca se ejecuta */ }
```

`try/catch` solo captura errores en la pila de llamadas síncrona **actual**. Para cuando el temporizador/callback se ejecuta, el bloque `try` hace rato que desapareció. Maneja el error *dentro* del callback.

## Los manejadores de rutas asíncronas de Express necesitan envoltura

```js
// ❌ un manejador async rechazado no es capturado por Express → la solicitud queda colgada
app.get("/users", async (req, res) => {
  const users = await db.getUsers(); // si esto lanza, Express no lo captura (pre-v5)
  res.json(users);
});

// ✅ envuélvelo para reenviar los errores al manejador de errores de Express
const asyncH = (fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
app.get("/users", asyncH(async (req, res) => {
  res.json(await db.getUsers()); // los errores ahora van a next() → middleware de errores
}));
```

## Redes de seguridad globales (último recurso, no el manejo principal)

```js
process.on("unhandledRejection", (reason) => { logger.error(reason); });
process.on("uncaughtException", (err) => { logger.error(err); process.exit(1); });
```

Estas son redes de seguridad para registrar y (en el caso de excepciones no capturadas) salir limpiamente — no un sustituto de manejar los errores donde ocurren.

## Por qué es importante

Los errores asíncronos no manejados son una de las principales causas de servicios de Node crasheados o rotos de forma silenciosa.

Dominar las reglas — `try/catch` alrededor de `await`, siempre `.catch` en las Promesas, manejar los errores *dentro* de los callbacks asíncronos (el try/catch no puede alcanzarlos), y envolver los manejadores asíncronos de Express para reenviar los errores — previene solicitudes colgadas, fallos silenciosos y crasheos del proceso.

Los manejadores globales proveen una red de seguridad final, pero el manejo correcto por operación es lo que hace que el código asíncrono de Node sea robusto y depurable.