How do you handle errors in async Node code?

Question

Accepted Answer

Error handling differs by async style, and getting it wrong causes silent failures or crashes. The key rules: use `try/catch` with async/await, always handle Promise rejections, and never let errors in async callbacks escape unhandled.

## async/await — use 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 — always .catch

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

A Promise rejection with no `.catch` (or no try/catch around `await`) becomes an **unhandled rejection** — which in modern Node terminates the process.

## The classic trap: errors in async callbacks escape 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` only catches errors in the **current** synchronous call stack. By the time the timer/callback runs, the `try` block is long gone. Handle the error *inside* the callback.

## Express async route handlers need wrapping

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

## Global safety nets (last resort, not primary handling)

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

These are safety nets to log and (for uncaught exceptions) exit cleanly — not a substitute for handling errors where they occur.

## Why it matters

Unhandled async errors are a top cause of crashed or silently-broken Node services.

Mastering the rules — `try/catch` around `await`, always `.catch` Promises, handle errors *inside* async callbacks (try/catch can't reach them), and wrap Express async handlers to forward errors — prevents hanging requests, silent failures, and process crashes.

The global handlers provide a final safety net, but correct per-operation handling is what makes async Node code robust and debuggable.