NestJS లో dependency injection ఎలా పని చేస్తుంది?

Question

Accepted Answer

**Dependency Injection (DI)** అనేది NestJS యొక్క ప్రధాన pattern, ఇక్కడ framework **స్వయంచాలకంగా dependencies ను సృష్టించి అందిస్తుంది**, క్లాస్ స్వయంగా నిర్మించటానికి బదులుగా. మీరు constructor లో మీకు కావలసిన వాటిని ప్రకటించండి, మరియు NestJS దానిని సরఫరా చేస్తుంది — ఇది 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 లను చదువుతుంది, సంబంధిత నిబంధించిన 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 ను highly testable చేస్తుంది.

## Non-class values ను inject చేయడం

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

## ఇది ఎందుకు ముఖ్యమైనది

Dependency injection అనేది NestJS యొక్క సంపూర్ణ architecture ని underlining చేసే ఫౌండేషనల్ pattern — ఇది controllers కు services, services కు repositories మరియు ఇతర services, మరియు మొత్తం application ఎలా wire చేయబడుతుందో. దానిని అర్థం చేసుకోవడం అవసరం ఎందుకంటే దాదాపు ప్రతి NestJS class DI లో పాల్గొంటుంది: మీరు constructor లో dependencies ని declare చేస్తారు మరియు framework యొక్క IoC container ఆటోమేటిక్‌గా వాటిని resolve చేస్తుంది మరియు సরఫరా చేస్తుంది, manual instantiation మరియు tight coupling ను తొలిగించుకుంటుంది.

లాభాలు గణనీయమైనవి మరియు NestJS ఎందుకు విలువైనదిగా కనబడుతుందో దానికి కేంద్రస్థానికమైనవి: **loose coupling** (abstractions పై depend చేయండి), **testability** (real dependencies కు బదులుగా mocks inject చేయండి — thorough unit testing చేయడం సులభం), reusability (shared singletons), మరియు maintainability.

DI Angular మరియు Spring వంటి frameworks నుండి borrowed చేయబడింది, మరియు దానిని master చేయడం — how to declare, register, inject, మరియు mock dependencies — well-structured, testable NestJS applications నిర్మాణ కోసం అవసరమైనది మరియు framework లో deeply అర్థం చేసుకోవలసిన అత్యంత ముఖ్యమైన concepts లలో ఒకటి.