NestJS मा dependency injection कसरी काम गर्छ?

Question

Accepted Answer

**Dependency Injection (DI)** एक मूल NestJS pattern हो जहाँ framework ले **स्वचलित रूपमा बनाएर र प्रदान गर्छ** जुन dependencies एक class लाई चाहिन्छ, constructor मा class आफै बनाउनु भन्दा। तपाईंले constructor मा आवश्यक कुरा declare गर्नुहुन्छ, र NestJS ले यो supply गर्छ — जसले loosely-coupled, testable code मा नेतृत्व गर्छ।

## Constructor मा कसरी declare गर्न्छ

```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 पढ्छ, corresponding registered providers खोज्छ, तिनलाई बनाएछ (यदि पहिले नै छैन), र तिनलाई pass गर्छ — पूरो dependency graph को स्वचलित रूपमा समाधान गर्छ।

## 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 — killer benefit

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

Klass आफै यसको dependencies बनाएन भएकोले, testing को लागि तपाईं mocks मा swap गर्न सक्नुहुन्छ — DI ले NestJS apps को अत्यन्त testable बनाउछ।

## Non-class values को injection गर्ने

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

## यो किन महत्त्वपूर्ण छ

Dependency injection NestJS को पूरो architecture को अन्तर्निहित pattern हो — यो कसरी controllers ले services पाउछ, services ले repositories र अन्य services पाउछ, र पूरो application एकसाथ जोडिन्छ।

यसलाई बुझ्न आवश्यक छ किनभने लगभग हरेक NestJS class DI मा भाग लिन्छ: तपाईंले constructor मा dependencies declare गर्नुहुन्छ र framework को IoC container ले तिनलाई स्वचलित रूपमा resolve गरी प्रदान गर्छ, manual instantiation र tight coupling लाई हटाएर।

फायदाहरू महत्त्वपूर्ण र केन्द्रीय छन् किनभने NestJS किन valued छ: **loose coupling** (abstractions पर निर्भर गर्नु), **testability** (real dependencies को सट्टामा mocks inject गर्नु — thorough unit testing लाई सजिलो बनाइन्छ), reusability (shared singletons), र maintainability।

DI Angular र Spring जस्तै frameworks बाट उधार लिइएको हो, र यसलाई master गर्नु — कसरी dependencies declare, register, inject, र mock गर्ने — well-structured, testable NestJS applications बनाउन आवश्यक छ र framework मा बुझ्न सबैभन्दा महत्त्वपूर्ण concepts मध्ये एक हो।