Come gestisci gli errori nel codice async Node?

Question

Accepted Answer

La gestione degli errori varia in base allo stile async, e se la fai male causerai errori silenziosi o crash. Le regole chiave: usa `try/catch` con async/await, gestisci sempre i rifiuti di Promise, e non lasciare mai che gli errori nei callback async sfuggano non gestiti.

## async/await — usa 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
```

Un rifiuto di Promise senza `.catch` (o senza try/catch intorno ad `await`) diventa un **unhandled rejection** — che in Node moderno termina il processo.

## La trappola classica: gli errori nei callback async sfuggono 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` cattura solo gli errori nel **current** synchronous call stack. Nel momento in cui il timer/callback viene eseguito, il blocco `try` è ormai lontano. Gestisci l'errore *dentro* il callback.

## I gestori di route async di Express necessitano di wrapping

```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
}));
```

## Reti di sicurezza globali (ultima risorsa, non gestione primaria)

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

Queste sono reti di sicurezza per registrare e (per le eccezioni non catturate) chiudere ordinatamente — non sono un sostituto per la gestione degli errori dove si verificano.

## Perché è importante

Gli errori async non gestiti sono una delle cause principali dei servizi Node bloccati o non riusciti silenziosamente.

Padroneggiare le regole — `try/catch` intorno ad `await`, sempre `.catch` Promises, gestisci gli errori *dentro* i callback async (try/catch non può raggiungerli), e avvolgi i gestori di route async di Express per inoltrare gli errori — previene le richieste sospese, i fallimenti silenziosi e i crash dei processi.

I gestori globali forniscono una rete di sicurezza finale, ma la corretta gestione per operazione è ciò che rende il codice async Node robusto e debuggabile.