Kif tittratta l-iżbali fil-kodiċi async Node?

Question

Accepted Answer

It-trattament ta' żbali huwa differenti skont l-istil async, u jekk isir ħażin jikkawża fallimenti silenzi jew kolassi. Ir-regoli prinċipali: uża `try/catch` ma' async/await, ħawwad dejjem Promise rejections, u qatt tħalli żbali fil-async callbacks joħroġu untreated.

## async/await — uża 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 — dejjem .catch

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

Rifjut Promise mingħajr `.catch` (jew mingħajr try/catch madwar `await`) isir **unhandled rejection** — li fil-Node modern itina' it-proċess.

## Il-ħanet klassiċi: żbali fil-async callbacks joħorġu mill-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` biss jittratta żbali fil-**attwali** synchronous call stack. Meta timer/callback jitħaddem, il-blokk `try` diġà ħala. Ħawwad iż-żball *ġewwa* il-callback.

## Express async route handlers jeħtieġu 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
}));
```

## Xibkiet ta' sigurtà globali (aħħar riżort, mhux primary handling)

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

Dawk huma xibkiet ta' sigurtà biex nirreġistu u (għal exceptions mhux ittrattati) nħarġu b'mod nadif — mhux sostitut għat-trattament ta' żbali fejn iseħħu.

## Għaliex hija importanti

Zbali async mhux ittrattati huma wieħed mill-akbar kawża ta' servizzi Node li jikkollassau jew li failaw silenzjozament.

Mastering ir-regoli — `try/catch` madwar `await`, dejjem `.catch` Promises, ħawwad żbali *ġewwa* async callbacks (try/catch ma jistgħux jilħqu), u involvi async route handlers tal-Express biex wieħed jippropagaw żbali — prevni requests ta' suspended, failimenti silenzi, u kolassi tal-proċess.

Il-handlers globali jipprovdu xibka ta' sigurtà finali, iżda proper per-operation handling hu dak li jagħmel async Node code robust u debuggable.