Async Node code-இல் errors-ஐ எப்படிக் கையாள்வீர்கள்?

Question

Accepted Answer

Error handling async பாணியால் வேறுபடுகிறது, மேலும் அதைத் தவறாகச் செய்வது silent failures அல்லது crashes-ஐ ஏற்படுத்துகிறது. முக்கிய விதிகள்: async/await உடன் `try/catch`-ஐப் பயன்படுத்தவும், எப்போதும் Promise rejections-ஐக் கையாளவும், மேலும் async callbacks-இல் உள்ள errors கையாளப்படாமல் தப்பிக்க அனுமதிக்காதீர்கள்.

## 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
```

`.catch` இல்லாத (அல்லது `await`-ஐச் சுற்றி try/catch இல்லாத) ஒரு Promise rejection ஒரு **unhandled rejection** ஆகிறது — இது நவீன Node-இல் process-ஐ முடிக்கிறது.

## உன்னதமான பொறி: async callbacks-இல் உள்ள errors 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-இல் உள்ள errors-ஐ மட்டுமே catch செய்கிறது. timer/callback இயங்கும் நேரத்தில், `try` block நீண்ட நேரத்திற்கு முன்பே போய்விடும். error-ஐ 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); });
```

இவை log செய்வதற்கும் (uncaught exceptions-க்கு) சுத்தமாக வெளியேறுவதற்கும் safety nets — errors எங்கு நிகழ்கின்றனவோ அங்கு அவற்றைக் கையாள்வதற்கு மாற்று அல்ல.

## இது ஏன் முக்கியம்

கையாளப்படாத async errors crash ஆன அல்லது அமைதியாக உடைந்த Node services-க்கு ஒரு முக்கிய காரணம்.

விதிகளில் தேர்ச்சி பெறுவது — `await`-ஐச் சுற்றி `try/catch`, எப்போதும் Promises-ஐ `.catch`, async callbacks-க்கு *உள்ளே* errors-ஐக் கையாளுதல் (try/catch அவற்றை அடைய முடியாது), மற்றும் errors-ஐ அனுப்ப Express async handlers-ஐ wrap செய்தல் — தொங்கும் requests, silent failures, மற்றும் process crashes-ஐத் தடுக்கிறது.

Global handlers ஒரு இறுதி safety net-ஐ வழங்குகின்றன, ஆனால் per-operation சரியான கையாளுதல் தான் async Node code-ஐ robust மற்றும் debuggable ஆக்குகிறது.