NestJS मध्ये अवलंबित्व इंजेक्शन कसे कार्य करते?

Question

Accepted Answer

**Dependency Injection (DI)** हा NestJS चा मुख्य नमुना आहे जेथे फ्रेमवर्क **स्वयंचलितपणे अवलंबित्व तयार करते आणि प्रदान करते** ज्याची वर्गाला आवश्यकता असते, अन्यथा वर्ग स्वतः ते तयार करते. आप कन्स्ट्रक्टरमध्ये आवश्यक असलेले घोषित करता, आणि NestJS ते प्रदान करते — सैतीक कपलिंग, परीक्षण योग्य कोडकडे नेत.

## हे कसे कार्य करते: कन्स्ट्रक्टरमध्ये घोषित करा

```ts
@Injectable()
export class UsersService {
  // declare dependencies as constructor parameters — Nest injects them
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // you NEVER write `new DatabaseService()` — Nest creates and provides it
}
```

Nest कन्स्ट्रक्टरच्या पॅरामीटरच्या प्रकार वाचते, संबंधित पंजीकृत प्रदायक शोधतो, ते तयार करते (जर आधीपासून नाहीत तर), आणि त्यांना पास करते — संपूर्ण अवलंबित्व ग्राफ स्वयंचलितपणे सोडवते.

## DI प्रवाह

```text
1. A class is marked @Injectable() → it's a provider
2. The provider is registered in a module's `providers` array
3. Another class declares it as a constructor parameter
4. NestJS's IoC container resolves and INJECTS the instance automatically
```

## नोंदणी आणि संकल्प

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // register all providers
  controllers: [UsersController],
})
export class UsersModule {}
// Nest's container now knows how to construct each and inject them where needed
```

## DI मूल्यवान का आहे

```text
✓ Loose coupling — classes depend on ABSTRACTIONS, not on constructing concrete deps
✓ Testability — inject MOCK dependencies in tests easily (no real DB needed)
✓ Reusability — one shared instance (singleton) used across the app
✓ Maintainability — change an implementation in one place (the module registration)
```

## परीक्षण योग्यता — मुख्य लाभ

```ts
// in a test, provide a fake DatabaseService — no real database required
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject a mock
  ],
}).compile();
```

कारण वर्ग त्याच्या अवलंबित्व तयार करत नाही, आप परीक्षणासाठी मॉक्स मध्ये बदल करू शकता — DI NestJS अनुप्रयोगांना अत्यंत परीक्षण योग्य बनवते.

## गैर-वर्ग मूल्य इंजेक्ट करणे

```ts
// use injection tokens for config/values, not just classes
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

## हे का महत्वाचे आहे

अवलंबित्व इंजेक्शन हा मूलभूत नमुना आहे जो NestJS च्या संपूर्ण आर्किटेक्चरला समर्थन देतो — हे असे आहे की नियंत्रक सेवा कसे मिळतात, सेवांना संग्रहस्थान आणि इतर सेवा कसे मिळतात, आणि संपूर्ण अनुप्रयोग कसे जोडलेला असतो.

हे समजणे आवश्यक आहे कारण जवळजवळ प्रत्येक NestJS वर्ग DI मध्ये भाग घेते: आप कन्स्ट्रक्टरमध्ये अवलंबित्व घोषित करता आणि फ्रेमवर्कचे IoC कंटेनर त्यांना स्वयंचलितपणे सोडवते आणि प्रदान करते, हाताने इंस्टेंशिएशन आणि घट्ट कपलिंग दूर करते.

लाभ महत्वपूर्ण आणि NestJS का मूल्यवान असल्याचा कारण केंद्रीय आहेत: **सैतीक कपलिंग** (अमूर्तवरील अवलंबन), **परीक्षण योग्यता** (वास्तविक अवलंबित्व ऐवजी मॉक्स इंजेक्ट करा — व्यापक एकक परीक्षण सहज बनवतो), पुन्हा वापरक्षमता (साझा सिंगलटन), आणि देखभाल.

DI Angular आणि Spring सारख्या फ्रेमवर्कपासून उधार घेतला आहे, आणि त्यात प्रभुत्व मिळविणे — अवलंबित्व कसे घोषित, नोंदणी, इंजेक्ट आणि मॉक करायचे — सुव्यवस्थित, परीक्षण योग्य NestJS अनुप्रयोग तयार करण्यासाठी आवश्यक आहे आणि फ्रेमवर्कमध्ये गहनतेने समजावयास हवी असलेल्या सर्वात महत्वाच्या संकल्पनांपैकी एक आहे.