Awilix TypeScript: DI कंटेनर के लिए पूर्ण गाइड

Awilix एक शक्तिशाली और लचीला डिपेंडेंसी इंजेक्शन (DI) कंटेनर है जो Node.js और ब्राउज़रों के लिए TypeScript में लिखा गया है। यह आपके एप्लिकेशन में डिपेंडेंसी को मैनेज करने का एक सुंदर तरीका प्रदान करता है, जिससे कोड अधिक मॉड्यूलर, टेस्टेबल और मेंटेन करने योग्य बनता है। इस लेख में हम विस्तार से जानेंगे कि TypeScript प्रोजेक्ट्स में Awilix का उपयोग कैसे करें, इंस्टॉलेशन से लेकर एडवांस तकनीकों तक।

1. यह क्या है और इसकी आवश्यकता क्यों है

आधुनिक सॉफ्टवेयर डेवलपमेंट में, इनवर्जन ऑफ कंट्रोल (IoC) और डिपेंडेंसी इंजेक्शन (DI) स्केलेबल और टेस्टेबल एप्लिकेशन बनाने के लिए डी-फैक्टो मानक बन गए हैं। Awilix एक DI कंटेनर का कार्यान्वयन है जो ऑब्जेक्ट्स (सर्विसेज, रिपॉजिटरीज, कंट्रोलर्स आदि) के निर्माण और उनके जीवनचक्र को संभालता है। मैन्युअल रूप से क्लासेस के अंदर इंस्टेंस बनाने (जो मजबूत कपलिंग का कारण बनता है) के बजाय, आप अपनी डिपेंडेंसी को कंटेनर में रजिस्टर करते हैं, और यह स्वचालित रूप से उन्हें वहां "इंजेक्ट" करता है जहां उनकी आवश्यकता होती है।

इसकी आवश्यकता क्यों है? सबसे पहले, यह टेस्टिंग को बहुत आसान बनाता है। आप यूनिट टेस्ट के दौरान वास्तविक इम्प्लीमेंटेशन (जैसे डेटाबेस) को मॉक ऑब्जेक्ट से आसानी से बदल सकते हैं, बस कंटेनर में दूसरी डिपेंडेंसी रजिस्टर करके। दूसरा, यह एप्लिकेशन आर्किटेक्चर को बेहतर बनाता है, जिससे आपको सिंगल रिस्पॉन्सिबिलिटी प्रिंसिपल (SRP) का पालन करने और अपनी डिपेंडेंसी को स्पष्ट रूप से घोषित करने के लिए मजबूर होना पड़ता है। तीसरा, Awilix ऑब्जेक्ट्स के विभिन्न "लाइफटाइम" (सिंगलटन, ट्रांजिएंट, स्कोप) को सपोर्ट करता है, जिससे मेमोरी और स्टेट को लचीले ढंग से मैनेज किया जा सकता है।

Awilix अपनी सख्त टाइपिंग के कारण TypeScript के लिए विशेष रूप से अच्छा है। यह डिपेंडेंसी को रजिस्टर और रिजॉल्व करने के लिए बिल्ट-इन टाइप्स प्रदान करता है, जिससे रनटाइम के बजाय कंपाइल टाइम पर ही एरर पकड़ी जा सकती है। यह लाइब्रेरी एसिंक्रोनस डिपेंडेंसी रिजॉल्वेशन, क्लासेस, फैक्ट्री फंक्शन्स और पहले से मौजूद ऑब्जेक्ट इंस्टेंस के साथ काम करने को सपोर्ट करती है।

2. इंस्टॉलेशन

अपने TypeScript प्रोजेक्ट में Awilix इंस्टॉल करने के लिए टर्मिनल में निम्नलिखित कमांड चलाएं:

npm install awilix

Awilix में TypeScript के लिए बिल्ट-इन सपोर्ट है, इसलिए आपको अलग से टाइप्स पैकेज (@types/awilix) इंस्टॉल करने की आवश्यकता नहीं है। सभी टाइप्स मुख्य लाइब्रेरी में ही शामिल हैं।

3. क्विक स्टार्ट — न्यूनतम कार्यशील उदाहरण

चलिए एक बहुत ही सरल एप्लिकेशन बनाते हैं जो उपयोगकर्ता का स्वागत करता है। हमारे पास एक Greeter क्लास होगी जो Logger पर निर्भर करती है।

import { createContainer, asClass, Lifetime } from 'awilix';

// 1. डिपेंडेंसी परिभाषित करें
class Logger {
  log(message: string): void {
    console.log(`[LOG]: ${message}`);
  }
}

class Greeter {
  private logger: Logger;

  // कंस्ट्रक्टर के माध्यम से डिपेंडेंसी इंजेक्ट की जाएगी
  constructor({ logger }: { logger: Logger }) {
    this.logger = logger;
  }

  greet(name: string): void {
    this.logger.log(`Hello, ${name}!`);
  }
}

// 2. कंटेनर बनाएं
const container = createContainer();

// 3. डिपेंडेंसी रजिस्टर करें
container.register({
  logger: asClass(Logger, { lifetime: Lifetime.SINGLETON }),
  greeter: asClass(Greeter, { lifetime: Lifetime.TRANSIENT }),
});

// 4. Greeter का इंस्टेंस रिजॉल्व करें (प्राप्त करें)
const greeter = container.resolve<Greeter>('greeter');

// 5. उपयोग करें
greeter.greet('World'); // आउटपुट: [LOG]: Hello, World!

इस उदाहरण में, हमने एक कंटेनर बनाया, दो क्लासेस रजिस्टर कीं (Logger को सिंगलटन और Greeter को ट्रांजिएंट ऑब्जेक्ट के रूप में), और फिर Greeter को रिजॉल्व किया। Awilix ने स्वचालित रूप से Logger का एक इंस्टेंस बनाया और उसे Greeter के कंस्ट्रक्टर में पास कर दिया।

4. मुख्य तरीके/फंक्शन/क्लासेस

आइए Awilix के मुख्य API को देखें। प्रत्येक तरीके के लिए सिग्नेचर, विवरण और उदाहरण दिया गया है।

4.1. createContainer()

सिग्नेचर: