तपाई async Node कोडमा त्रुटिहरू कसरी सम्हाल्नुहुन्छ?

Question

Accepted Answer

त्रुटि व्यवस्थापन async शैलीको आधारमा भिन्न हुन्छ, र यदि यो गलत छ भने यसले मूक असफलता वा क्र्यास गराउँछ। मुख्य नियमहरू: async/await सँग `try/catch` प्रयोग गर्नुहोस्, सधैं 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` छैन (वा `await` को वरिपरि try/catch छैन) **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
}));
```

## विश्वव्यापी सुरक्षा नेटहरू (अन्तिम उपाय, प्राथमिक हन्डलिङ होइन)

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

यो लग गर्न र (unhandled exceptions को लागि) सफलतापूर्वक बाहिर निस्कन सुरक्षा नेटहरू हुन् — त्रुटिहरू जहाँ उत्पन्न हुन्छन् त्यहाँ हन्डल गर्नको विकल्प होइन।

## यो किन महत्त्वपूर्ण छ

अनह्यान्डल गरिएको async त्रुटिहरू Node services को क्र्यास वा मूक-टुटेको शीर्ष कारणहरूमा एक हुन्।

नियमहरूमा महारत — `await` को वरिपरि `try/catch`, सधैं `.catch` Promises, async callbacks को *भित्र* त्रुटिहरू ह्यान्डल गर्नुहोस् (try/catch तिनलाई पुग्न सक्दैन), र Express async handlers लाई त्रुटिहरू अगाडि बढाउन wrap गर्नुहोस् — लत्केको अनुरोधहरू, मूक असफलताहरू, र प्रक्रिया क्र्यासहरू रोक्छ।

विश्वव्यापी हन्डलरहरूले अन्तिम सुरक्षा नेट प्रदान गर्छन्, तर सही प्रति-अपरेशन हन्डलिङ नै हो जसले async Node कोडलाई robust र debuggable बनाउँछ।