Hvordan håndterer du fejl i async Node-kode?

Question

Accepted Answer

Fejlhåndtering adskiller sig efter async-stil, og at gøre det forkert forårsager stille fejl eller nedbrud. Nøglereglerne: brug `try/catch` med async/await, håndter altid Promise-afvisninger, og lad ikke fejl i async-callbacks slippe uden håndtering.

## async/await — brug 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 — altid .catch

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

En Promise-afvisning uden `.catch` (eller uden try/catch omkring `await`) bliver en **uhåndteret afvisning** — som i moderne Node afslutter processen.

## Den klassiske fælde: fejl i async-callbacks undslipper 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` fanger kun fejl i den **aktuelle** synkrone call stack. I det øjeblik timeren/callback kører, er `try`-blokken længe væk. Håndter fejlen *inden* i callback'en.

## Express async route-handlere kræver indpakning

```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 sikkerhedsnet (sidste udvej, ikke primær håndtering)

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

Disse er sikkerhedsnet til at logge og (for uafviklede undtagelser) afslutte pænt — ikke en erstatning for at håndtere fejl, hvor de opstår.

## Hvorfor det betyder noget

Uhåndterede async-fejl er en af hovedårsagerne til, at Node-tjenester går ned eller fejler stilfærdig.

At mestre reglerne — `try/catch` omkring `await`, altid `.catch` Promises, håndter fejl *inden* i async-callbacks (try/catch kan ikke nå dem), og pakk Express async-handlere ind for at videreføre fejl — forhindrer hængende anmodninger, stille fejl og proceskollaps.

De globale handlere giver et ultimativt sikkerhedsnet, men korrekt håndtering per operation er hvad der gør async Node-kode robust og fejlfindings-venlig.