Bagaimana cara menangani error di kode async Node?

Question

Accepted Answer

Penanganan error berbeda menurut gaya async, dan jika dilakukan dengan salah maka akan menyebabkan kegagalan senyap atau crash. Aturan kunci: gunakan `try/catch` dengan async/await, selalu tangani penolakan Promise, dan jangan pernah biarkan error di async callback lolos tanpa penanganan.

## async/await — gunakan 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 — selalu .catch

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

Penolakan Promise tanpa `.catch` (atau tanpa try/catch di sekitar `await`) menjadi **unhandled rejection** — yang pada Node modern menghentikan proses.

## Jebakan klasik: error di async callback lolos dari 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` hanya menangkap error di **current** synchronous call stack. Pada saat timer/callback dijalankan, blok `try` sudah lama berlalu. Tangani error *di dalam* callback.

## Express async route handler perlu dibungkus

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

## Jaringan keamanan global (pilihan terakhir, bukan penanganan utama)

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

Ini adalah jaringan keamanan untuk mencatat dan (untuk unhandled exception) shutdown bersih — bukan pengganti penanganan error di mana pun error terjadi.

## Mengapa ini penting

Error async yang tidak ditangani adalah penyebab utama service Node yang crash atau gagal diam-diam.

Menguasai aturannya — `try/catch` di sekitar `await`, selalu `.catch` Promise, tangani error *di dalam* async callback (try/catch tidak bisa menjangkaunya), dan bungkus Express async handler untuk meneruskan error — mencegah request yang menggantung, kegagalan senyap, dan crash proses.

Handler global menyediakan jaringan keamanan terakhir, tetapi penanganan yang benar per operasi adalah yang membuat kode async Node menjadi robust dan dapat di-debug.