Como você lida com erros em código assíncrono no Node?

Question

Accepted Answer

O tratamento de erros difere conforme o estilo assíncrono, e cometer um erro causa falhas silenciosas ou crashes. As regras principais: use `try/catch` com async/await, sempre trate rejeições de Promise, e nunca deixe erros em callbacks assíncrono escaparem sem tratamento.

## async/await — use try/catch

```js
async function getUser(id) {
  try {
    const user = await db.findUser(id);   // a rejection here throws into catch
    return user;
  } catch (err) {
    logger.error(err);
    throw new AppError("Failed to load user", { cause: err }); // rethrow meaningfully
  }
}
```

## Promises — sempre .catch

```js
fetchData()
  .then(process)
  .catch(err => logger.error(err)); // an unhandled rejection can crash the process
```

Uma rejeição de Promise sem `.catch` (ou sem `try/catch` em torno de `await`) se torna uma **unhandled rejection** — que em Node moderno encerra o processo.

## A armadilha clássica: erros em callbacks assíncrono escapam do try/catch

```js
// ❌ try/catch does NOT catch this — the throw happens on a LATER tick
try {
  setTimeout(() => { throw new Error("boom"); }, 100);
} catch (e) { /* never runs */ }
```

`try/catch` só captura erros na **pilha de chamadas** síncrona atual. Quando o timer/callback é executado, o bloco `try` já desapareceu há muito tempo. Trate o erro *dentro* do callback.

## Manipuladores de rota assíncrona do Express precisam envolvimento

```js
// ❌ a rejected async handler isn't caught by Express → request hangs
app.get("/users", async (req, res) => {
  const users = await db.getUsers(); // if this throws, Express doesn't catch it (pre-v5)
  res.json(users);
});

// ✅ wrap to forward errors to Express's error handler
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()); // errors now go to next() → error middleware
}));
```

## Redes de segurança globais (último recurso, não é tratamento primário)

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

Estas são redes de segurança para registrar e (para exceções não capturadas) encerrar corretamente — não é um substituto para tratar erros onde eles ocorrem.

## Por que isso importa

Erros assíncrono não tratados são uma das principais causas de serviços Node que travam ou funcionam silenciosamente com erro.

Dominar as regras — `try/catch` em torno de `await`, sempre `.catch` Promises, tratar erros *dentro* de callbacks assíncrono (try/catch não consegue alcançá-los), e envolver manipuladores assíncrono do Express para encaminhar erros — previne requisições penduradas, falhas silenciosas e crashes de processo.

Os manipuladores globais fornecem uma rede de segurança final, mas o tratamento correto por operação é o que torna o código assíncrono do Node robusto e depurável.