როგორ ამუშავებთ შეცდომებს async Node კოდში?

Question

Accepted Answer

შეცდომების დამუშავება განსხვავდება async სტილის მიხედვით, და თუ არასწორად გააკეთებთ, ეს იწვევს ჩsilent failures-ს ან crashes-ს. ძირითადი წესები: გამოიყენეთ `try/catch` async/await-ის სახელმწიფოთან, ყოველთვის დაამუშავეთ Promise rejections, და არასოდეს დაუშვათ async callbacks-ში შეცდომები დაუმუშავებელი.

## async/await — გამოიყენეთ 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 — ყოველთვის .catch

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

Promise rejection, რომელსაც არ აქვს `.catch` (ან არ აქვს try/catch `await`-ის გარშემო), ხდება **unhandled rejection** — რომელიც თანამედროვე Node-ში ხელმძღვანელობს პროცესის დასრულებას.

## კლასიკური ხაფანგი: შეცდომები async callbacks-ში 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` მხოლოდ **მიმდინარე** synchronous call stack-ში ამუშავებს შეცდომებს. როდესაც timer/callback აირის, `try` ბლოკი უკვე მოშორებულია. დაამუშავეთ შეცდომა *callback-ის შიგნით*.

## Express async route handlers-ს სჭირდება 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
}));
```

## Global safety nets (ბოლო საშუალება, არა პირველი არჩევანი)

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

ეს არის safety nets-ი log-ისა და (uncaught exceptions-ის დროს) სუფთა გასვლისთვის — არა შემცვლელი შეცდომების დამუშავების ნაცვლად სადაც ისინი ხდება.

## რატომ არის ეს მნიშვნელოვანი

Unhandled async errors არის Node services-ის crash-ის ან silent-broken-ის ერთი ხშირი მიზეზი.

წესების დაუფლება — `try/catch` `await`-ის გარშემო, ყოველთვის `.catch` Promises, შეცდომების დამუშავება *async callbacks-ის შიგნით* (try/catch მათ ვერ მიაღწევს), და Express async handlers-ის wrapping errors-ის forward-ისთვის — თავს ხსნის hanging requests-ებს, silent failures-ს და process crashes-ებს.

Global handlers უზრუნველყოფს საბოლოო safety net-ს, მაგრამ სწორი per-operation handling არის ის, რაც async Node კოდს robust და debuggable-ს ხდის.