Jak se vyrovnáváte s chybami v async kódu Node?

Question

Accepted Answer

Zpracování chyb se liší podle async stylu a špatné zpracování způsobuje tiché selhání nebo selhání. Klíčová pravidla: používejte `try/catch` s async/await, vždy zpracujte Promise rejections a nechte chyby v async callbackech neuvolňovat neošetřené.

## async/await — použijte 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 — vždy .catch

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

Promise rejection bez `.catch` (nebo bez try/catch kolem `await`) se stane **neošetřeným rejection** — což v moderním Node process ukončí.

## Klasická past: chyby v async callbackech unikají 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` zachytává pouze chyby v **aktuálním** synchronním call stacku. V okamžiku, kdy se timer/callback spustí, je `try` blok dávno pryč. Zpracujte chybu *uvnitř* callbacku.

## Express async route handlery potřebují obalení

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

## Globální sítě bezpečnosti (poslední možnost, ne primární zpracování)

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

Toto jsou sítě bezpečnosti pro protokolování a (pro neošetřené výjimky) čisté ukončení — ne náhrada za zpracování chyb tam, kde se vyskytují.

## Proč je to důležité

Neošetřené async chyby jsou jednou z hlavních příčin selhání nebo tichého selhání Node služeb.

Zvládnutí pravidel — `try/catch` kolem `await`, vždy `.catch` Promises, zpracování chyb *uvnitř* async callbacků (try/catch se jich nemůže dotknout), a obalení Express async handlerů pro přesměrování chyb — zabraňuje zavěšeným požadavkům, tichým selháním a selhání procesu.

Globální handlery poskytují finální bezpečnostní síť, ale správné zpracování na operaci je to, co činí async Node kód robustním a debugovatelným.