Jak obsługujesz błędy w asynchronicznym kodzie Node?

Question

Accepted Answer

Obsługa błędów różni się w zależności od stylu asynchronicznego, a nieprawidłowe postępowanie powoduje ciche awarie lub awarie. Kluczowe zasady: użyj `try/catch` z async/await, zawsze obsługuj odrzucenia Promise, i nigdy nie pozwól na wyjście niezobsługiwanych błędów w asynchronicznych callback'ach.

## async/await — użyj 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 — zawsze .catch

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

Odrzucenie Promise bez `.catch` (lub bez try/catch wokół `await`) staje się **nieobsługiwanym odrzuceniem** — które w nowoczesnym Node'u kończy proces.

## Klasyczna pułapka: błędy w asynchronicznych callback'ach uciekają 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` przechwytuje tylko błędy w **bieżącym** synchronicznym stosie wywołań. Gdy timer/callback się uruchomi, blok `try` dawno już minął. Obsłuż błąd *wewnątrz* callback'a.

## Asynchroniczne handlery tras Express wymagają opakowywania

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

## Globalne sieci bezpieczeństwa (ostateczność, nie podstawowa obsługa)

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

To są sieci bezpieczeństwa do logowania i (dla nieobsługiwanych wyjątków) czystego zamknięcia — a nie substytut obsługi błędów w miejscu, gdzie się pojawią.

## Dlaczego to ważne

Nieobsługiwane błędy asynchroniczne są główną przyczyną awarii lub cicho zepsutych serwisów Node.

Opcenowanie reguł — `try/catch` wokół `await`, zawsze `.catch` dla Promise, obsługuj błędy *wewnątrz* asynchronicznych callback'ów (try/catch nie może je osiągnąć), i opakowuj asynchroniczne handlery Express aby przesyłać błędy — zapobiega wiszącym żądaniom, cichym awariom i awariom procesów.

Globalne handlery zapewniają ostateczną sieć bezpieczeństwa, ale prawidłowa obsługa na poziomie operacji to to, co czyni asynchroniczny kod Node solidnym i łatwym do debugowania.