NestJS में dependency injection कैसे काम करता है?

Question

Accepted Answer

**Dependency Injection (DI)** एक मुख्य NestJS पैटर्न है जहाँ फ्रेमवर्क **स्वचालित रूप से बनाता है और प्रदान करता है** जो dependency एक क्लास को चाहिए, बजाय इसके कि क्लास उन्हें स्वयं बनाए। आप constructor में घोषित करते हैं कि आपको क्या चाहिए, और NestJS इसे प्रदान करता है — जिससे loosely-coupled, testable कोड मिलता है।

## यह कैसे काम करता है: constructor में घोषित करें

```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 constructor के parameter types को पढ़ता है, संबंधित registered providers को खोजता है, उन्हें बनाता है (यदि पहले से न हों), और उन्हें pass करता है — स्वचालित रूप से पूरे dependency graph को resolve करता है।

## DI flow

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

## Registration और resolution

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

## Testability — मुख्य लाभ

```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();
```

चूँकि क्लास अपनी dependencies को नहीं बनाता है, आप testing के लिए mocks को swap कर सकते हैं — DI NestJS apps को अत्यधिक testable बनाता है।

## Non-class values को inject करना

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

## यह महत्वपूर्ण क्यों है

Dependency injection वह मूल पैटर्न है जो NestJS के पूरे आर्किटेक्चर को रेखांकित करता है — यह है कि कैसे controllers services प्राप्त करते हैं, services repositories और अन्य services प्राप्त करते हैं, और पूरी application कैसे जुड़ी है।

इसे समझना आवश्यक है क्योंकि लगभग हर NestJS क्लास DI में भाग लेता है: आप constructor में dependencies घोषित करते हैं और फ्रेमवर्क का IoC container उन्हें स्वचालित रूप से resolve और प्रदान करता है, manual instantiation और tight coupling को समाप्त करता है।

लाभ महत्वपूर्ण और केंद्रीय हैं कि NestJS की सराहना क्यों की जाती है: **loose coupling** (abstractions पर निर्भर), **testability** (true dependencies के बजाय mocks को inject करें — जो thorough unit testing को आसान बनाता है), reusability (shared singletons), और maintainability।

DI Angular और Spring जैसी frameworks से लिया गया है, और इसे master करना — कैसे declare, register, inject, और mock dependencies करें — well-structured, testable NestJS applications बनाने के लिए आवश्यक है और framework में समझने के लिए सबसे महत्वपूर्ण अवधारणाओं में से एक है।