Unashughulikiaje makosa katika msimbo wa async wa Node?

Question

Accepted Answer

Kushughulikia makosa hutofautiana kulingana na mtindo wa async, na kukosea husababisha kushindwa kimya au kuanguka kwa programu. Kanuni muhimu: tumia `try/catch` na async/await, daima shughulikia Promise rejections, na kamwe usiruhusu makosa katika async callbacks kutoroka bila kushughulikiwa.

## async/await — tumia 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 — daima .catch

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

Promise rejection isiyo na `.catch` (au isiyo na try/catch kuzunguka `await`) huwa **unhandled rejection** — ambayo katika Node ya kisasa humaliza process.

## Mtego wa kawaida: makosa katika async callbacks hutoroka 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` hukamata tu makosa katika call stack ya **sasa** ya synchronous. Kufikia wakati timer/callback inaendeshwa, kizuizi cha `try` kimeshakwisha tangu zamani. Shughulikia kosa *ndani* ya callback.

## Handlers za async za njia za Express zinahitaji kufungwa

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

## Nyavu za usalama za kimataifa (njia ya mwisho, si ushughulikiaji wa msingi)

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

Hizi ni nyavu za usalama za kurekodi na (kwa uncaught exceptions) kutoka kwa usafi — si mbadala wa kushughulikia makosa pale yanapotokea.

## Kwa nini ni muhimu

Makosa ya async yasiyoshughulikiwa ni mojawapo ya sababu kuu za huduma za Node kuanguka au kuvunjika kimya.

Kubobea kanuni — `try/catch` kuzunguka `await`, daima `.catch` kwa Promises, shughulikia makosa *ndani* ya async callbacks (try/catch haiwezi kuyafikia), na funga handlers za async za Express ili kupeleka makosa mbele — kunazuia maombi yaliyoning'inia, kushindwa kimya, na kuanguka kwa process.

Handlers za kimataifa hutoa nyavu ya mwisho ya usalama, lakini ushughulikiaji sahihi kwa kila operesheni ndio unaofanya msimbo wa async wa Node kuwa imara na rahisi kutatua.