Cum gestionezi erorile în codul async din Node?

Question

Accepted Answer

Gestionarea erorilor diferă în funcție de stilul async, iar o implementare greșită provoacă defecțiuni silențioase sau prăbușiri. Regulile cheie: folosește `try/catch` cu async/await, gestionează întotdeauna respingerile Promise, și nu lăsa erorile în callback-urile asincrone să rămână negestionate.

## async/await — folosește 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 — întotdeauna .catch

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

O respingere Promise fără `.catch` (sau fără try/catch în jurul `await`) devine o **respingere negestionate** — care în Node-ul modern termină procesul.

## Capcanul clasic: erorile în callback-urile asincrone scapă 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` gestiona doar erorile din **stack-ul** de apeluri sincrone curent. Pe vremea când timer-ul/callback-ul rulează, blocul `try` a dispărut de mult. Gestionează eroarea *în interiorul* callback-ului.

## Handler-ele async din Express necesită 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
}));
```

## Rețele de siguranță globale (ultim recurs, nu gestionare primară)

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

Acestea sunt rețele de siguranță pentru a înregistra și (pentru excepții negestionate) a încheia curat — nu un înlocuitor pentru gestionarea erorilor acolo unde apar.

## De ce contează

Erorile asincrone negestionate sunt o cauză principală a serviciilor Node care se prăbușesc sau sunt defecte în tăcere.

Stapânirea regulilor — `try/catch` în jurul `await`, întotdeauna `.catch` pentru Promises, gestionare erori *în interiorul* callback-urilor asincrone (try/catch nu le poate atinge), și wrapping handler-elor async din Express pentru a transfera erorile — previne cererile suspendate, defecțiunile silențioase, și prăbușirile procesului.

Handler-ele globale oferă o rețea de siguranță finală, dar gestionarea corectă per-operație este ceea ce face codul async din Node robust și ușor de depanat.