Si funksionon përfshirja e varësisë në NestJS?

Question

Accepted Answer

**Përfshirja e Varësisë (DI)** është një model bërthamor i NestJS ku framework-u **automatikisht krijon dhe furnizon** varësitë që një klasë ka nevojë, në vend që klasa të i ndërtohet vetë. Ti deklarohen atë që ke nevojë në konstruktor, dhe NestJS e furnizon atë — duke çuar në kod të lirshëm të lidhur dhe të testueshem.

## Si funksionon: deklarohet në konstruktor

```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 lexon llojet e parametrave të konstruktorit, kërkon furnizuesit e regjistruar të korrespondues, i krijon ato (nëse nuk ekzistojnë tashmë), dhe i kalon ato — duke zgjidhur automatikisht të gjithë grafikun e varésisë.

## Rrjedha e 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
```

## Regjistrimi dhe zgjidhja

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

## Pse DI është e vlefshme

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

## Testueshmëri — përfitimi vdekjeprurës

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

Pasi klasa nuk konstrukton varësitë e saj, mund të ndërrojë në mock-a për testim — DI e bën aplikacionet NestJS shumë të testueshem.

## Përfshirja e vlerave jo-klasash

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

## Pse rëndeson

Përfshirja e varësisë është modeli themelor që qëndron nën të gjithë arkitekturën e NestJS — kjo është se si kontrolluesit marrin shërbime, shërbimeve u duan repo dhe shërbime të tjera, dhe i gjithë aplikacioni është i lidhur bashkë.

E kuptimit atë është thelbësore sepse pothuajse çdo klasë NestJS pjesëmarrë në DI: tu deklarojnë varësitë në konstruktor dhe kontejneri IoC i framework-ut i zgjidh dhe i furnizon ato automatikisht, duke eliminuar ndërtimin manual dhe lidhjen e ngurtë.

Përfitimet janë të rëndësishme dhe në qendër të pse NestJS vlerësohet: **lidhja e lirshme** (varen nga abstraksionet), **testueshmëri** (përfshij mock-a në vend të varësive reale — duke e bërë testimin e njësisë të plotë të lehtë), përdorueshmëri (singleton-et e ndara), dhe manutenueshmëri.

DI përjeton nga framework-a si Angular dhe Spring, dhe zotërim i saj — se si të deklarosh, regjistrosh, përfshij, dhe tallosh varësitë — është e nevojshme për ndërtimin e aplikacioneve NestJS të mirëstrukturuara, të testueshem dhe është një nga konceptet më të rëndësishme për të kuptuar thellë në framework-u.