Node.js में ERR_INVALID_URL को कैसे ठीक करें

ERR_INVALID_URL का कारण क्या है?

ERR_INVALID_URL त्रुटि (औपचारिक रूप से TypeError [ERR_INVALID_URL]: Invalid URL) Node.js द्वारा तब फेंकी जाती है जब URL कंस्ट्रक्टर या पुराना url.parse() फ़ंक्शन ऐसी स्ट्रिंग प्राप्त करता है जिसे एक वैध URL के रूप में पार्स नहीं किया जा सकता। यह त्रुटि उपयोगकर्ता इनपुट को प्रोसेस करते समय, कॉन्फ़िगरेशन फ़ाइलों को पार्स करते समय, या बाहरी स्रोतों से आने वाले URL को हैंडल करते समय आम है।

URL कंस्ट्रक्टर WHATWG URL Standard का पालन करता है, जो पुराने RFC-आधारित पार्सिंग की तुलना में अधिक सख्त है। एक वैध URL के रूप में स्वीकार किए जाने के लिए किसी स्ट्रिंग में एक वैध स्कीम (जैसे https:), एक वैध अथॉरिटी (होस्टनेम), और सही ढंग से फ़ॉर्मेट किए गए पथ एवं क्वेरी घटक होने चाहिए।

// यह ERR_INVALID_URL फेंकता है
try {
  const url = new URL('not-a-url');
} catch (err) {
  console.log(err.code);    // 'ERR_INVALID_URL'
  console.log(err.message); // 'Invalid URL: not-a-url'
  console.log(err.input);   // 'not-a-url'
}

सामान्य कारण और समाधान

कारण 1: प्रोटोकॉल/स्कीम का न होना। URL कंस्ट्रक्टर को https:// या http:// जैसी स्कीम की आवश्यकता होती है। example.com/path या www.example.com जैसी स्ट्रिंग्स विफल हो जाएँगी।

// विफल: कोई प्रोटोकॉल नहीं
new URL('example.com/path');  // ERR_INVALID_URL

// समाधान: प्रोटोकॉल जोड़ें
new URL('https://example.com/path');  // काम करता है!

// समाधान: यदि प्रोटोकॉल न हो तो जोड़ें
function ensureProtocol(urlString) {
  if (!/^https?:\/\//i.test(urlString)) {
    return 'https://' + urlString;
  }
  return urlString;
}
new URL(ensureProtocol('example.com/path'));  // काम करता है!

कारण 2: बिना एन्कोड किए विशेष वर्ण। स्पेस, कर्ली ब्रेसेस, पाइप, और कुछ Unicode वर्ण जैसे वर्ण बिना एन्कोडिंग के URL में अनुमत नहीं हैं।

// विफल: बिना एन्कोड किए स्पेस और विशेष वर्ण
new URL('https://example.com/my file.pdf');    // ERR_INVALID_URL
new URL('https://example.com/path?q=a b');     // कुछ संस्करणों में विफल हो सकता है

// समाधान: समस्याग्रस्त हिस्सों को एन्कोड करें
const filename = encodeURIComponent('my file.pdf');
new URL('https://example.com/' + filename);    // काम करता है!

// समाधान: स्पेस वाले पूर्ण URL के लिए encodeURI का उपयोग करें
const rawUrl = 'https://example.com/my file.pdf';
new URL(encodeURI(rawUrl));  // काम करता है!

कारण 3: खराब percent-encoding। यदि किसी URL में एक प्रतिशत चिह्न ऐसा है जिसके ठीक बाद दो हेक्साडेसिमल अंक नहीं हैं, तो पार्सर उसे अस्वीकार कर देता है।

// विफल: खराब percent encoding
new URL('https://example.com/100%done');       // ERR_INVALID_URL
new URL('https://example.com/path?q=50%');     // ERR_INVALID_URL

// समाधान: अकेले प्रतिशत चिह्न को %25 के रूप में एन्कोड करें
function fixPercentSigns(urlString) {
  return urlString.replace(/%(?![0-9A-Fa-f]{2})/g, '%25');
}
new URL(fixPercentSigns('https://example.com/100%done'));
// काम करता है! URL बन जाता है https://example.com/100%25done

कारण 4: खाली या null इनपुट। URL कंस्ट्रक्टर को खाली स्ट्रिंग, null, या undefined पास करना भी इस त्रुटि को ट्रिगर करता है।

// विफल: खाली या null इनपुट
new URL('');           // ERR_INVALID_URL
new URL(null);         // ERR_INVALID_URL
new URL(undefined);    // ERR_INVALID_URL

// समाधान: पार्स करने से पहले इनपुट को वैध करें
function parseUrl(input) {
  if (!input || typeof input !== 'string') {
    return null;
  }
  try {
    return new URL(input);
  } catch {
    return null;
  }
}

कारण 5: बेस के बिना सापेक्ष (relative) URL। URL कंस्ट्रक्टर डिफ़ॉल्ट रूप से पहले तर्क को एक निरपेक्ष (absolute) URL मानता है। /path/to/page जैसे सापेक्ष URL के लिए दूसरे तर्क के रूप में एक बेस URL की आवश्यकता होती है।

// विफल: बेस के बिना सापेक्ष URL
new URL('/api/users');  // ERR_INVALID_URL

// समाधान: एक बेस URL प्रदान करें
new URL('/api/users', 'https://example.com');
// काम करता है! → https://example.com/api/users

// API क्लाइंट्स के लिए उपयोगी पैटर्न
const BASE_URL = 'https://api.example.com';
const endpoint = new URL('/v2/users?page=1', BASE_URL);
console.log(endpoint.href);
// "https://api.example.com/v2/users?page=1"

पार्स करने से पहले URL को कैसे वैध करें

Node.js में किसी URL को वैध करने का सबसे भरोसेमंद तरीका try-catch ब्लॉक के अंदर URL कंस्ट्रक्टर का उपयोग करना है। कोई अंतर्निहित URL.isValid() मेथड मौजूद नहीं है (Node.js 22 तक), इसलिए त्रुटि को कैच करना मानक तरीका है।

// सरल URL वैलिडेटर
function isValidUrl(string) {
  try {
    new URL(string);
    return true;
  } catch {
    return false;
  }
}

console.log(isValidUrl('https://example.com'));  // true
console.log(isValidUrl('not-a-url'));            // false
console.log(isValidUrl(''));                     // false

// अनुमत प्रोटोकॉल के साथ वैलिडेटर
function isValidHttpUrl(string) {
  try {
    const url = new URL(string);
    return url.protocol === 'http:' || url.protocol === 'https:';
  } catch {
    return false;
  }
}

console.log(isValidHttpUrl('https://example.com'));     // true
console.log(isValidHttpUrl('ftp://example.com'));       // false
console.log(isValidHttpUrl('javascript:alert(1)'));     // false

सुरक्षित URL पार्सिंग पैटर्न

यहाँ एक मज़बूत URL पार्सिंग पैटर्न है जो सभी सामान्य त्रुटि मामलों को संभालता है और एक पार्स किया गया URL ऑब्जेक्ट या एक अर्थपूर्ण त्रुटि लौटाता है।

class UrlParser {
  static parse(input, base) {
    // इनपुट को वैध करें
    if (!input || typeof input !== 'string') {
      return { ok: false, error: 'Input must be a non-empty string' };
    }

    // व्हाइटस्पेस हटाएँ
    const trimmed = input.trim();

    // सामान्य समस्याओं को ठीक करें
    let urlString = trimmed;

    // प्रोटोकॉल न हो तो जोड़ें
    if (/^[a-zA-Z0-9]/.test(urlString) && !urlString.includes('://')) {
      urlString = 'https://' + urlString;
    }

    // अकेले प्रतिशत चिह्नों को ठीक करें
    urlString = urlString.replace(/%(?![0-9A-Fa-f]{2})/g, '%25');

    try {
      const url = base ? new URL(urlString, base) : new URL(urlString);

      // वैकल्पिक: सुरक्षित प्रोटोकॉल तक सीमित करें
      if (!['http:', 'https:'].includes(url.protocol)) {
        return { ok: false, error: 'Unsupported protocol: ' + url.protocol };
      }

      return { ok: true, url };
    } catch (err) {
      return { ok: false, error: err.message };
    }
  }
}

// उपयोग
const result = UrlParser.parse('example.com/path?q=hello world');
if (result.ok) {
  console.log(result.url.href);
} else {
  console.error(result.error);
}

रोकथाम के सर्वोत्तम तरीके

इन तरीकों का पालन करने से आपको अपने Node.js अनुप्रयोगों में ERR_INVALID_URL त्रुटियों से बचने और अधिक सुदृढ़ URL हैंडलिंग बनाने में मदद मिलेगी।

• URL पार्सिंग को हमेशा try-catch में लपेटें। कभी यह न मानें कि कोई URL स्ट्रिंग वैध है, विशेष रूप से जब यह उपयोगकर्ता इनपुट, पर्यावरण चर, डेटाबेस, या बाहरी API से आती हो।
• स्ट्रिंग जोड़ने के बजाय URL API का उपयोग करें। स्ट्रिंग्स को जोड़ने के बजाय URL कंस्ट्रक्टर और URLSearchParams का उपयोग करके URL बनाएँ। यह API एन्कोडिंग स्वचालित रूप से संभालता है।
• स्टार्टअप पर पर्यावरण चर को वैध करें। यदि आपका अनुप्रयोग पर्यावरण चर या कॉन्फ़िग फ़ाइलों से URL पढ़ता है, तो उन्हें अनुप्रयोग के शुरू होने पर वैध करें, न कि जब उनका पहली बार उपयोग हो।
• URL में एम्बेड करने से पहले उपयोगकर्ता इनपुट को एन्कोड करें। क्वेरी पैरामीटर मानों के लिए हमेशा encodeURIComponent() और उपयोगकर्ताओं द्वारा प्रदान किए गए पूर्ण URL के लिए encodeURI() का उपयोग करें।
• जटिल मामलों के लिए URL बिल्डर का उपयोग करें। कई गतिशील हिस्सों वाले URL बनाने के लिए, एक हेल्पर फ़ंक्शन या क्लास बनाएँ जो एन्कोडिंग को समान रूप से संभालता हो।
• त्रुटियों पर मूल इनपुट को लॉग करें। जब आप कोई ERR_INVALID_URL त्रुटि कैच करें, तो समस्या को डिबग करने में मदद के लिए उस इनपुट को लॉग करें जिसके कारण यह हुई (यदि इसमें संवेदनशील डेटा हो सकता है तो सैनिटाइज़ करके)।

// अच्छा तरीका: स्टार्टअप पर कॉन्फ़िग URL को वैध करें
const requiredUrls = ['API_BASE_URL', 'AUTH_SERVER_URL', 'WEBHOOK_URL'];

for (const envVar of requiredUrls) {
  const value = process.env[envVar];
  if (!value) {
    throw new Error(envVar + ' environment variable is required');
  }
  try {
    new URL(value);
  } catch {
    throw new Error(envVar + ' is not a valid URL: ' + value);
  }
}

// अच्छा तरीका: URL बनाने के लिए URL API का उपयोग करें
function buildApiUrl(endpoint, params) {
  const url = new URL(endpoint, process.env.API_BASE_URL);
  for (const [key, value] of Object.entries(params)) {
    url.searchParams.set(key, String(value));
  }
  return url.toString();
}

const searchUrl = buildApiUrl('/api/search', {
  q: 'Node.js & Express',
  page: 1
});
// "https://api.example.com/api/search?q=Node.js+%26+Express&page=1"