Si i trajtoni gabimet në kodin async të Node?

Question

Accepted Answer

Trajtimi i gabimeve ndryshon sipas stilit async, dhe nëse e bëni gabim shkakton dështime të heshtura ose rrëzime. Rregullat kryesore: përdorni `try/catch` me async/await, trajtoni gjithmonë refuzimet e Promise, dhe mos lejoni që gabimet në callback-ët asynchron të shpëtojnë pa u trajtuar.

## async/await — përdorni 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 — gjithmonë .catch

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

Një refuzim Promise pa `.catch` (ose pa try/catch rreth `await`) bëhet një **refuzim i patrajtuani** — i cili në Node-in modern përfundon procesin.

## Kursa klasike: gabimet në callback-ët async shpëtojnë nga 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` kap vetëm gabimet në stack-un **aktual** sinkron të thirrjeve. Kur timer-i/callback-i ekzekutohet, blloku `try` është shumë larg. Trajtoni gabimin *brenda* callback-it.

## Përpunuesit e rutave async të Express-it kanë nevojë për mbështjellje

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

## Rrjeta globale sigurimi (zgjidhje e fundit, jo trajtim parësor)

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

Këto janë rrjeta sigurimi për të regjistruar dhe (për përjashtime të patrajtuara) për të dalë me pastërti — jo zëvendësim për trajtimin e gabimeve ku ndodhen.

## Pse është i rëndësishëm

Gabimet asynchron të patrajtuara janë një nga shkaqet më të mëdha të shërbimeve Node të rrëzuara ose dështuar në heshtje.

Zotërimi i rregullave — `try/catch` rreth `await`, gjithmonë `.catch` Promises, trajtoni gabimet *brenda* callback-ëve async (try/catch nuk mund t'i arrijë ato), dhe mbështillni përpunuesit e rutave të Express-it për të drejtuar gabimet — parandalon kërkesa të varura, dështime të heshtura, dhe rrëzime procesi.

Përpunuesit globalë ofrojnë një rrjete final sigurimi, por trajtimi korrekt për operacion është ajo që e bën kodin async të Node të fortë dhe të kapshëm për diagnostikim.