Conas a oibríonn fíorphluiceoireacht spleáchais i NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** is a core NestJS pattern where the framework **automatically creates and provides** the dependencies a class needs, rather than the class constructing them itself. You declare what you need in the constructor, and NestJS supplies it — leading to loosely-coupled, testable code.

## How it works: declare in the 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 reads the constructor's parameter types, looks up the corresponding registered providers, creates them (if not already), and passes them in — automatically resolving the whole dependency graph.

## The 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 and 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
```

## Why DI is valuable

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

Because the class doesn't construct its dependencies, you can swap in mocks for testing — DI makes NestJS apps highly testable.

## Injecting non-class values

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

## Cén fáth a bhfuil sé tábhachtach

Is é fíorphluiceoireacht spleáchais an patrún bunúsach atá ag tacú le ailtireacht iomlán NestJS — is é an bealach a bhfuigheann rialtóirí seirbhísí, go bhfuigheann seirbhísí stór gealadóirí agus seirbhísí eile, agus an chaoi a bhfuil an fheidhmchlár iomlán fógtha le chéile.

Tá sé riachtanach a thuiscint toisc go bhfuil beagnach gach rang NestJS páirteach i DI: deir tú na spleáchais sa tógálaí agus réitíonn an coimeádán IoC an fhramework agus soláthraíonn siad iad go foluain, agus cuirtear deireadh le tógáil ordúil agus cuplóireacht dhocht.

Tá na buntáistí suntasach agus lárnach do dheis a bhfuil NestJS mór-oilte ann: **cuplóireacht scéimh** (bheith ag brath ar dhiosc), **inchomrádh** (insteallbhféadfar boganna in áit spleáchais fíor — rud a dhéanann tástáil aonaid dhoimhneoir éasca), athúsáid (singletons roinnte), agus intriomáireacht.

Tá DI faighte ó frameworks ar nós Angular agus Spring, agus a dhoimhniú — conas a dhearbhú, a chlárú, a stealladh, agus a bhréagadh spleáchais — go bhfuil gá dó do thógáil ar dheireadh structúrtha, inchomrádh NestJS agus is é ceann de na coincheapa is tábhachtaí a thuiscint go maith sa fhramework.