Hoe verwerk je fouten in async Node-code?

Question

Accepted Answer

Foutafhandeling verschilt per async-stijl, en als je het verkeerd doet, veroorzaakt dit stille fouten of crashes. De belangrijkste regels: gebruik `try/catch` met async/await, verwerk altijd Promise rejections, en laat fouten in async callbacks nooit onbehandeld.

## async/await — gebruik 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 — altijd .catch

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

Een Promise rejection zonder `.catch` (of zonder try/catch rond `await`) wordt een **unhandled rejection** — wat in moderne Node het proces beëindigt.

## De klassieke valkuil: fouten in async callbacks ontsnappen aan 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` vangt fouten alleen op in de **huidige** synchrone call stack. Zodra de timer/callback wordt uitgevoerd, is het `try`-blok allang weg. Verwerk de fout *binnenin* de callback.

## Express async route handlers moeten worden verpakt

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

## Globale vangnetjes (laatste redmiddel, niet als primaire afhandeling)

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

Dit zijn vangnetjes voor logging en (voor onbegrepen uitzonderingen) netjes afsluiten — geen vervanging voor foutafhandeling op het moment dat ze optreden.

## Waarom het belangrijk is

Onbegrepen async-fouten zijn een van de voornaamste oorzaken van gecrasht of stille gebroken Node-services.

De regels onder de knie krijgen — `try/catch` rond `await`, altijd `.catch` Promises, fouten *binnenin* async callbacks afhandelen (try/catch kan ze niet bereiken), en Express async handlers verpakken om fouten door te sturen — voorkomt hangende verzoeken, stille fouten en procescrashes.

De globale handlers bieden een laatste vangnet, maar correcte per-operatie-afhandeling is wat async Node-code robuust en debuggable maakt.