Node.js Error Handling (In Hindi)

नमस्ते दोस्तों! आज हम बैकएंड डेवलपमेंट के सबसे महत्वपूर्ण और संवेदनशील टॉपिक पर बात करने वाले हैं - Node.js Error Handling।

जब हम एक नया प्रोजेक्ट शुरू करते हैं, तो हमारा पूरा ध्यान नए फीचर्स बनाने, APIs डिजाइन करने और डेटाबेस को कनेक्ट करने पर होता है। लेकिन एक अनुभवी डेवलपर (Senior Developer) और एक फ्रेशर में यही अंतर होता है कि सीनियर डेवलपर कोड लिखने से पहले यह सोचता है कि "अगर यह कोड फेल हुआ, तो क्या होगा?"

अगर आप NodeJS या एक्सप्रेस में काम कर रहे हैं, और आपने एरर हैंडलिंग को नजरअंदाज कर दिया, तो आपका पूरा सर्वर एक छोटे से अनहैंडल्ड एरर की वजह से क्रैश हो सकता है। इमेजिन कीजिए, आपकी वेबसाइट पर हजारों यूज़र्स हैं, और किसी एक यूजर के गलत इनपुट की वजह से आपका पूरा बैकएंड डाउन हो जाता है। यह किसी भी बिजनेस के लिए एक नाइटमेयर (Nightmare) जैसा है।

तो चलिए दोस्तों, आज हम बिल्कुल बेसिक से लेकर प्रोडक्शन-ग्रेड एडवांस्ड लेवल तक समझेंगे कि NodeJS में प्रोफेशनल तरीके से एरर्स को कैसे मैनेज किया जाता है। अपनी चाय की चुस्की लीजिए, और मेरे साथ इस कोड जर्नी में शामिल हो जाइए!

---

Errors क्या होते हैं और ये क्यों आते हैं?

सरल शब्दों में कहें तो, एरर हमारे प्रोग्राम के नॉर्मल फ्लो में आने वाली एक रुकावट है। जब हमारे रनटाइम एनवायरनमेंट को कुछ ऐसा मिलता है जिसे वह प्रोसेस नहीं कर पाता, तो वह एक एरर थ्रो (Throw) करता है।

ध्यान देने वाली बात ये है कि NodeJS एक सिंगल-थ्रेडेड (Single-threaded) इवेंट लूप पर काम करता है। इसका मतलब है कि अगर कोई अनहैंडल्ड एक्सेप्शन (Unhandled Exception) आता है, तो वह पूरे प्रोसेस को ब्लॉक कर देगा और आपका सर्वर तुरंत बंद हो जाएगा। इसलिए एरर को कैच (Catch) करना और उसे सही ढंग से हैंडल करना बेहद जरूरी है।

---

Operational Errors बनाम Programmer Errors

एरर हैंडलिंग शुरू करने से पहले हमें यह समझना होगा कि एरर्स को दो मुख्य श्रेणियों में बांटा जा सकता है। यह क्लासिफिकेशन समझना बहुत जरूरी है क्योंकि दोनों तरह के एरर्स को डील करने का तरीका बिल्कुल अलग होता है:

1. Operational Errors (ऑपरेशनल एरर्स)

ये वे एरर्स हैं जो प्रोग्रामर की गलती की वजह से नहीं होते, बल्कि रनटाइम के दौरान बाहरी कारणों से आते हैं। इन एरर्स की भविष्यवाणी की जा सकती है और इन्हें अच्छे से हैंडल किया जाना चाहिए।

• उदाहरण: डेटाबेस कनेक्शन फेल होना (जैसे MongoDB सर्वर का डाउन होना)।
• फाइल सिस्टम में किसी फाइल का न मिलना (File not found)।
• यूजर द्वारा गलत इनपुट या अमान्य क्रेडेंशियल्स देना।
• नेटवर्क टाइमआउट या एपीआई रिक्वेस्ट का फेल होना।

2. Programmer Errors (प्रोग्रामर एरर्स)

ये वे गलतियां हैं जो डेवलपर के खराब कोड लिखने की वजह से होती हैं। ये असल में "बग्स" (Bugs) होते हैं जिन्हें डेवलपमेंट के समय ही ठीक किया जाना चाहिए।

• उदाहरण: किसी undefined वेरिएबल की प्रॉपर्टी को रीड करने की कोशिश करना (उदा. cannot read property of undefined)।
• सिंटैक्स एरर (Syntax Errors) या पैरामीटर पास करने में गलती।
• प्रॉमिस (Promise) को सही से रिजॉल्व या रिजेक्ट न करना।

याद रखें दोस्तों: ऑपरेशनल एरर्स को हम कैच करके यूजर को एक सुंदर सा मैसेज दिखाते हैं, जबकि प्रोग्रामर एरर्स आने पर हमें अक्सर प्रोसेस को रीस्टार्ट करना पड़ता है क्योंकि हमारा एप्लिकेशन एक "अनप्रेडिक्टेबल स्टेट" (Unpredictable State) में चला जाता है।

---

Basic Error Handling: The Error Object in Node.js

Node.js में इन-बिल्ट Error क्लास होती है जो हमें एरर से जुड़ी सारी जरूरी जानकारी देती है। जब भी हम कोई एरर बनाते हैं, तो हमें दो सबसे महत्वपूर्ण चीजें मिलती हैं: message और stack (स्टैक ट्रेस)।

चलिए, एक छोटा सा उदाहरण देखते हैं कि बेसिक एरर कैसे क्रिएट और थ्रो किया जाता है:

try {
    const user = null;
    if (!user) {
        throw new Error("User data is required but got null!");
    }
} catch (error) {
    console.error("Error Message:", error.message);
    console.error("Stack Trace:", error.stack);
}

यहाँ error.message सिर्फ एरर का डिस्क्रिप्शन देता है, जबकि error.stack हमें यह बताता है कि यह एरर किस फाइल की किस लाइन नंबर पर जेनरेट हुआ है। डेवलपमेंट के दौरान स्टैक ट्रेस हमारा सबसे बड़ा मददगार होता है!

---

Asynchronous Error Handling: The Biggest Challenge

Node.js की असली ताकत उसकी एसिंक्रोनस (Asynchronous) प्रकृति में है। लेकिन यही बात एरर हैंडलिंग को थोड़ा पेचीदा बना देती है। अगर आप एसिंक्रोनस कोड में साधारण try-catch इस्तेमाल करेंगे, तो वह काम नहीं करेगा।

1. Callbacks में Error-First Pattern

पुराने दिनों में जब प्रॉमिसेस नहीं थे, तब हम "Error-First Callback" का इस्तेमाल करते थे। इसमें पहला पैरामीटर हमेशा एरर ऑब्जेक्ट होता है:

const fs = require('fs');

fs.readFile('non-existent-file.txt', 'utf8', (err, data) => {
    if (err) {
        console.error("Oops, error reading file:", err.message);
        return;
    }
    console.log("File Data:", data);
});

2. Promises और Async/Await के साथ Error Handling

मॉडर्न MERN Stack डेवलपमेंट में हम प्रॉमिसेस और async/await का इस्तेमाल करते हैं। यहाँ एरर हैंडलिंग के लिए try-catch ब्लॉक का उपयोग किया जाता है, जो हमारे कोड को साफ और पठनीय (readable) बनाता है:

const fetchUserData = async (userId) => {
    try {
        const response = await fakeDatabaseCall(userId);
        return response;
    } catch (error) {
        console.error("Failed to fetch user:", error.message);
        throw error; // एरर को आगे प्रोपेगेट करना
    }
};

---

ExpressJS में Centralized Error Handling आर्किटेक्चर बनाना

अगर आप अपने ExpressJS प्रोजेक्ट की हर एक रूट (Route) फाइल में बार-बार try-catch लिख रहे हैं, तो आप अपना समय बर्बाद कर रहे हैं और कोड को गंदा कर रहे हैं।

एक प्रोफेशनल आर्किटेक्चर में हमारे पास एक Centralized Error Handling Middleware होना चाहिए जो पूरे एप्लिकेशन के एरर्स को एक ही जगह से मैनेज करे। चलिए इसे स्टेप-बाय-स्टेप स्क्रैच से बनाते हैं!

स्टेप 1: Custom AppError Class बनाना

सबसे पहले, हम एक कस्टम एरर क्लास बनाएंगे जो इन-बिल्ट Error क्लास को एक्सटेंड करेगी। इससे हम एरर के साथ HTTP स्टेटस कोड (Status Code) और यह ऑपरेशनल एरर है या नहीं (isOperational), यह भी ट्रैक कर पाएंगे।

// Class: AppError.js
class AppError extends Error {
    constructor(message, statusCode) {
        super(message);
        
        this.statusCode = statusCode;
        this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
        this.isOperational = true; // यह ऑपरेशनल एरर को मार्क करने के लिए है

        Error.captureStackTrace(this, this.constructor);
    }
}

module.exports = AppError;

स्टेप 2: Async functions के लिए Controller Wrapper (catchAsync) बनाना

हम हर कंट्रोलर फ़ंक्शन में try-catch लिखने से बचने के लिए एक हायर-ऑर्डर फ़ंक्शन (Helper function) बनाएंगे। यह एक्सप्रेस के next() फ़ंक्शन की मदद से एरर को सीधे ग्लोबल एरर हैंडलर को भेज देगा:

// Utility: catchAsync.js
const catchAsync = (fn) => {
    return (req, res, next) => {
        fn(req, res, next).catch(next);
    };
};

module.exports = catchAsync;

स्टेप 3: Global Error Handling Middleware बनाना

अब हम एक्सप्रेस के लिए एक स्पेशल मिडलवेयर बनाएंगे। ध्यान देने वाली बात ये है कि एक्सप्रेस में जब किसी मिडलवेयर के पास 4 आर्गुमेंट्स होते हैं (err, req, res, next), तो एक्सप्रेस उसे एरर हैंडलिंग मिडलवेयर के रूप में पहचानता है।

// Middleware: errorController.js
const AppError = require('./AppError');

const sendErrorDev = (err, res) => {
    res.status(err.statusCode).json({
        status: err.status,
        error: err,
        message: err.message,
        stack: err.stack
    });
};

const sendErrorProd = (err, res) => {
    // अगर एरर ऑपरेशनल है, तो यूजर को क्लीन मैसेज दिखाएं
    if (err.isOperational) {
        res.status(err.statusCode).json({
            status: err.status,
            message: err.message
        });
    } else {
        // अगर यह प्रोग्रामर एरर है, तो संवेदनशील जानकारी लीक न करें
        console.error('ERROR 💥:', err);
        res.status(500).json({
            status: 'error',
            message: 'Something went very wrong on our side!'
        });
    }
};

module.exports = (err, req, res, next) => {
    err.statusCode = err.statusCode || 500;
    err.status = err.status || 'error';

    if (process.env.NODE_ENV === 'development') {
        sendErrorDev(err, res);
    } else if (process.env.NODE_ENV === 'production') {
        let error = { ...err };
        error.message = err.message;

        // विशिष्ट एरर्स को कस्टमाइज़ करना (जैसे MongoDB CastError या ValidationError)
        if (err.name === 'CastError') {
            const message = `Invalid ${err.path}: ${err.value}.`;
            error = new AppError(message, 400);
        }
        
        if (err.code === 11000) {
            const value = err.errmsg.match(/(["'])(\\?.)*?\1/)[0];
            const message = `Duplicate field value: ${value}. Please use another value!`;
            error = new AppError(message, 400);
        }

        sendErrorProd(error, res);
    }
};

---

पूरा प्रोडक्शन-रेडी एक्सप्रेस एप्लीकेशन सेटअप (Complete Code)

चलिए, अब इन सभी टुकड़ों को एक साथ जोड़ते हैं और एक वास्तविक, चालू सर्वर फाइल (server.js) तैयार करते हैं। इस कोड को आप सीधे अपने प्रोजेक्ट में इस्तेमाल कर सकते हैं:

const express = require('express');
const mongoose = require('mongoose');
const AppError = require('./AppError');
const catchAsync = require('./catchAsync');
const globalErrorHandler = require('./errorController');

const app = express();
app.use(express.json());

// सिम्युलेटेड डेटाबेस मॉडल (सिर्फ प्रदर्शन के लिए)
const UserSchema = new mongoose.Schema({
    username: {
        type: String,
        required: [true, 'Please provide a username'],
        unique: true
    },
    email: {
        type: String,
        required: [true, 'Please provide an email']
    }
});
const User = mongoose.model('User', UserSchema);

// 1. Route handler using our 'catchAsync' wrapper
app.get('/api/users/:id', catchAsync(async (req, res, next) => {
    const user = await User.findById(req.params.id);

    // अगर डेटाबेस में यूजर नहीं मिला, तो कस्टम एरर फेंकें
    if (!user) {
        return next(new AppError('No user found with that ID', 404));
    }

    res.status(200).json({
        status: 'success',
        data: { user }
    });
}));

app.post('/api/users', catchAsync(async (req, res, next) => {
    const newUser = await User.create({
        username: req.body.username,
        email: req.body.email
    });

    res.status(201).json({
        status: 'success',
        data: { user: newUser }
    });
}));

// 2. Unhandled Routes Handling (404 Error)
app.all('*', (req, res, next) => {
    next(new AppError(`Can't find ${req.originalUrl} on this server!`, 404));
});

// 3. Centralized Global Error Handler Middleware
app.use(globalErrorHandler);

// सर्वर को शुरू करना
const PORT = process.env.PORT || 3000;
const server = app.listen(PORT, () => {
    console.log(`Server is running beautifully on port ${PORT}...`);
});

---

अनहैंडल्ड प्रॉमिस रिजेक्शन्स और अनकॉट एक्सेप्शन्स को कैसे संभालें?

मान लीजिए कि आपके कोडबेस के बाहर कहीं कोई एरर आता है, जैसे कि MongoDB डेटाबेस का क्रेडेंशियल गलत होने की वजह से कनेक्शन रिजेक्ट हो गया, या फिर कोड में कोई स्पेलिंग मिस्टेक हो गई जिसे हमने try-catch में नहीं घेरा।

ऐसे समय पर हमारे काम आते हैं दो स्पेशल प्रोसेस इवेंट्स:

1. Unhandled Rejections (अनहैंडल्ड प्रॉमिस रिजेक्शन)

जब भी कोई प्रॉमिस रिजेक्ट होता है लेकिन हम उसे कहीं भी .catch() या try-catch में हैंडल नहीं करते, तब यह इवेंट ट्रिगर होता है:

process.on('unhandledRejection', (err) => {
    console.log('UNHANDLED REJECTION! 💥 Server is shutting down gracefully...');
    console.error(err.name, err.message);
    
    // सर्वर को ग्रेसफुली क्लोज करें ताकि ऑनगोइंग रिक्वेस्ट्स पूरी हो सकें
    server.close(() => {
        process.exit(1); // प्रोसेस को बंद करना जरूरी है
    });
});

2. Uncaught Exceptions (अनकॉट एक्सेप्शन)

जब कोई सिंक्रोनस कोड में एरर आता है जिसे कहीं भी कैच नहीं किया गया होता (उदा. वेरिएबल डिफाइन किए बिना इस्तेमाल करना):

process.on('uncaughtException', (err) => {
    console.log('UNCAUGHT EXCEPTION! 💥 Server shutting down...');
    console.error(err.name, err.message, err.stack);
    
    // चूंकि यह सिंक्रोनस एरर है, प्रोसेस को तुरंत बंद करना ही एकमात्र सुरक्षित विकल्प है
    process.exit(1);
});

प्रो टिप (Pro Tip): हमेशा ध्यान रखें कि uncaughtException लिस्नर को आपके कोड में सबसे ऊपर (फाइल की पहली लाइन पर) होना चाहिए, ताकि वह बाद में आने वाले सभी सिंक्रोनस एरर्स को डिटेक्ट कर सके।

---

बेस्ट प्रैक्टिसेस और सामान्य गलतियाँ (Best Practices & Clean Code Tips)

• Never Swallow Errors: कभी भी खाली कैच ब्लॉक न छोड़ें (catch(err) {})। ऐसा करने से बग्स छिप जाते हैं और डिबगिंग एक बुरे सपने में बदल जाती है।
• Always Crash on Programmer Errors: अगर आपके पास कोई ऐसा एरर है जिसे आप नहीं जानते (Programmer Error), तो प्रोसेस को बंद (Crash) कर दें और उसे किसी प्रोसेस मैनेजर जैसे PM2 की मदद से रीस्टार्ट करें। खराब स्थिति में सर्वर चालू रखना डेटा करप्शन का कारण बन सकता है।
• Use Logs Wisely: प्रोडक्शन में कंसोल लॉग्स (Console logs) का इस्तेमाल करने के बजाय Winston या Bunyan जैसे प्रोफेशनल लॉगर लाइब्रेरीज़ का इस्तेमाल करें।
• Secure Error Information: प्रोडक्शन एनवायरनमेंट में कभी भी यूजर को डेटाबेस एरर्स या इंटरनल कोड की लाइन नंबर्स (Stack Trace) न दिखाएं। इससे हैकर्स को आपके सिस्टम के बारे में संवेदनशील जानकारियां मिल सकती हैं।

---

संक्षेप में कहें तो...

तो दोस्तों, आज हमने सीखा कि कैसे एक मजबूत और कभी न क्रैश होने वाला NodeJS बैकएंड सर्वर बनाया जाता है। हमने ऑपरेशनल और प्रोग्रामर एरर्स के बीच का अंतर समझा, अपनी खुद की कस्टम AppError क्लास डिजाइन की, catchAsync हेल्पर से अपने कोड को "DRY" (Don't Repeat Yourself) बनाया, और अंत में अनहैंडल्ड प्रॉमिस और एक्सेप्शन्स को ग्रेसफुली हैंडल करना सीखा। इन कॉन्सेप्ट्स को अपने प्रोजेक्ट्स में लागू कीजिए और अपने कोड को नेक्स्ट लेवल पर ले जाइए!

---