Kina kake jiyya da kurakurai a cikin async Node code?

Question

Accepted Answer

Jiyyar kurakurai ba ta tashi daidai ba dangane da salon async, kuma idan ka yi kuskure za ka kasance mai daɗo zaman ɗilhi ko kuraje. Jagorin muhimmi: yi amfani da `try/catch` tare da async/await, koyaushe jiyya da Promise rejections, kuma don kasua ɗaga wajen kurakurai a cikin async callbacks ba tare da jiyya ba.

## async/await — yi amfani da 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 — koyaushe .catch

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

Rejection na Promise ba tare da `.catch` (ko `await` da jiya) ba ta zama **unhandled rejection** — wanda a Node na al'ada ya kai ga tunatawa na tsari.

## Darajar zaki: kurakurai a cikin async callbacks suna tashi daga 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` kawai ya karbi kurakurai a cikin **haligarta** synchronous call stack. A lokacin da timer/callback ya durƙa, `try` block ya tafi. Jiyya kurakurai *ciki* callback.

## Express async route handlers masu buƙatuwa jiya

```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 (ƙarshe, ba shine jiyya ta farko ba)

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

Wadannan su ne safety nets don zua da kurakurai da kuma (don unhandled exceptions) kashe kyau — ba shine muje gida akan jiyyar kurakurai inda suke ba.

## Me ya sa yana da muhimmi

Kurakurai ba tare da jiyya na async sune matsalar na gida ta Node services na tunkaric ko bayyanannen gazawa.

Pilantarwa wajen sanin jagorin — `try/catch` kewaye `await`, koyaushe `.catch` Promises, jiyya kurakurai *ciki* async callbacks (try/catch ba zai iya samun su ba), da kuma jiya Express async handlers don gadawa kurakurai — sanye bayansa, bayyanannen gazawa, da tunatawa na tsari.

Global handlers suna ba safety net na ƙarshe, amma jiyyar daidai ta kowane aiki ce ke sa async Node code ƙarfi da iya a debugging.