Miten käsittelet virheitä async Node-koodissa?

Question

Accepted Answer

Virheiden käsittely vaihtelee async-tyylin mukaan, ja väärä käsittely aiheuttaa hiljaiset virheet tai kaatumisia. Pääsäännöt: käytä `try/catch` async/await kanssa, käsittele aina Promise-rejections ja älä anna async-callback-virheille paeta käsittelemättöminä.

## async/await — käytä 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 — aina .catch

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

Promise-rejection ilman `.catch` (tai ilman try/catch `await` ympärillä) muuttuu **käsittelemättömäksi rejection** — joka modernissa Nodessa lopettaa prosessin.

## Klassinen ansa: virheet async-callback-funktiossa paetaan try/catch:stä

```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` vangitsee vain virheet **nykyisessä** synkronisessa call stackissa. Kun ajastin/callback suoritetaan, `try`-lohko on kauan poissa. Käsittele virhe *callback-funktion sisällä*.

## Express async-reitinkäsittelijät vaativat käärimistä

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

## Globaalit turvajärjestelmät (viimeinen keino, ei ensisijainen käsittely)

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

Nämä ovat turvajärjestelmiä lokiin kirjoittamista varten ja (käsittelemättömien poikkeusten tapauksessa) siistin poistumisen tapauksessa — eivät korvike virheille, jotka käsitellään siellä, missä ne ilmenevät.

## Miksi sillä on merkitystä

Käsittelemättömät async-virheet ovat yksi pääsyistä Node-palveluiden kaatumisiin tai äänettömään epäonnistumiseen.

Sääntöjen hallitseminen — `try/catch` `await` ympärillä, aina `.catch` Promises:lle, virheiden käsittely *async-callback-funktion sisällä* (try/catch ei voi saavuttaa niitä), ja Express async-käsittelijöiden kääriminen virheille eteenpäin siirtämiseen — estää riippuvat pyynnöt, äänetön epäonnistuminen ja prosessin kaatuminen.

Globaalit käsittelijät tarjoavat lopullisen turvajärjestelmän, mutta oikea käsittely per operaatio on se, joka tekee async Node-koodista vankkaa ja debuggattavaa.