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 શોધે છે, તેમને બનાવે છે (જો અગાઉથી ન હોય તો), અને તેમને પાસ કરે છે — આપોઆપ સમગ્ર 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
```

## રજિસ્ટ્રેશન અને 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 સ્વેપ કરી શકો છો — DI NestJS apps ને ખૂબ જ testable બનાવે છે.

## Non-class values ઇજેક્ટ કરો

```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 પર dependent), **testability** (true dependencies ની જગ્યાએ mocks ઇજેક્ટ કરો — جو thorough unit testing ને સહેલું બનાવે છે), reusability (shared singletons), અને maintainability.

DI Angular અને Spring જેવી frameworks માંથી લીધેલ છે, અને તેને માસ્ટર કરવું — કેવી રીતે declare, register, inject, અને mock dependencies — NestJS applications કે well-structured, testable બનાવવા માટે જરૂરી છે અને તે ફ્રેમવર્ક માં સમજવા કોશિષ્ટ મહત્વનો ખ્યાલ છે.