Dependency injection hufanya kazi vipi katika NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** ni muundo wa msingi wa NestJS ambapo framework **huunda na kutoa kiotomatiki** dependencies ambazo class inahitaji, badala ya class kuziunda yenyewe. Unatangaza unachohitaji ndani ya constructor, na NestJS huitoa — jambo linaloleta code isiyounganishwa kwa nguvu na inayoweza kupimwa.

## Jinsi inavyofanya kazi: tangaza ndani ya 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 husoma aina za parameter za constructor, hutafuta providers zinazolingana zilizosajiliwa, huziunda (kama bado hazijaundwa), na huzipitisha ndani — ikitatua kiotomatiki grafu nzima ya dependencies.

## Mtiririko wa 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
```

## Usajili na utatuzi

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

## Kwa nini DI ina thamani

```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 — faida kuu

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

Kwa sababu class haiundi dependencies zake, unaweza kubadilisha kwa mocks kwa ajili ya kupima — DI huzifanya programu za NestJS kuwa rahisi sana kupimwa.

## Kuingiza thamani zisizo za class

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

## Kwa nini ni muhimu

Dependency injection ndiyo muundo wa msingi unaobeba usanifu wote wa NestJS — ndiyo jinsi controllers zinavyopata services, services zinavyopata repositories na services nyingine, na jinsi programu nzima inavyounganishwa pamoja.

Kuelewa ni muhimu kwa sababu karibu kila class ya NestJS hushiriki katika DI: unatangaza dependencies ndani ya constructor na IoC container ya framework huzitatua na kuzitoa kiotomatiki, ikiondoa uundaji wa mkono na muunganiko wa nguvu (tight coupling).

Faida zake ni kubwa na za msingi kwa sababu zinazoifanya NestJS kuthaminiwa: **loose coupling** (kutegemea abstractions), **testability** (kuingiza mocks badala ya dependencies halisi — jambo linalofanya unit testing kamili kuwa rahisi), uwezo wa kutumika tena (singletons zilizoshirikiwa), na udumishaji.

DI imekopwa kutoka kwa frameworks kama Angular na Spring, na kuumudu — jinsi ya kutangaza, kusajili, kuingiza, na ku-mock dependencies — ni lazima kwa kujenga programu za NestJS zilizopangwa vizuri na zinazoweza kupimwa, na ni mojawapo ya dhana muhimu zaidi kuelewa kwa kina katika framework hii.