Kako rukovaš greškama u async Node kodu?

Question

Accepted Answer

Rukovanje greškama se razlikuje prema async stilu, a ako ga krivo napraviš može doći do tihe greške ili pada. Ključna pravila: koristi `try/catch` s async/await, uvijek rukuj odbijanjima Promise-a, i nikad ne dopusti da greške u async callback-ovima ostanu nerukovane.

## async/await — koristi 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 — uvijek .catch

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

Obijanje Promise-a bez `.catch` (ili bez try/catch oko `await`) postaje **nerukovano odbijanje** — što u modernom Node-u prekida proces.

## Klasična zamka: greške u async callback-ovima izbjegavaju 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` hvata samo greške u **trenutnom** sinkronom call stack-u. Kada se timer/callback pokrene, `try` blok je dugo otišao. Rukuj greškom *unutar* callback-a.

## Express async route handleri trebaju rukovati

```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 sigurnosne mreže (zadnja opcija, ne primarna ruka)

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

Ovo su sigurnosne mreže za logiranje i (za uhvaćene iznimke) čisto gašenje — nisu zamjena za rukovanje greškama tamo gdje se javljaju.

## Zašto je to važno

Nerukovane async greške su vodeći uzrok pada ili tiho oštećenih Node servisa.

Savladavanje pravila — `try/catch` oko `await`, uvijek `.catch` Promise-a, rukuj greškama *unutar* async callback-ova (try/catch ih ne može dosegnuti), i omotaj Express async handlere za proslijeđivanje grešaka — sprječava viseće zahtjeve, tihe greške i padove procesa.

Globalni handleri pružaju posljednju sigurnosnu mrežu, ali ispravno rukovanje po operaciji je ono što čini async Node kod robustan i debugabilno.