¿Cómo funciona la inyección de dependencias en NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** es un patrón central de NestJS donde el framework **crea y proporciona automáticamente** las dependencias que una clase necesita, en lugar de que la clase las construya por sí misma. Declaras qué necesitas en el constructor, y NestJS lo suministra — lo que genera código débilmente acoplado y testeable.

## Por qué es importante: declarar en el 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 lee los tipos de parámetros del constructor, busca los providers registrados correspondientes, los crea (si no existen ya), y los pasa — resolviendo automáticamente toda la gráfica de dependencias.

## El flujo de 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
```

## Registro y resolución

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

## Por qué DI es valioso

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

## Testabilidad — el beneficio clave

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

Como la clase no construye sus dependencias, puedes intercambiar mocks para pruebas — DI hace que las aplicaciones NestJS sean altamente testeables.

## Inyectando valores que no son clases

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

## Por qué es importante

La inyección de dependencias es el patrón fundamental que sustenta toda la arquitectura de NestJS — es cómo los controladores obtienen servicios, los servicios obtienen repositorios y otros servicios, y cómo toda la aplicación se conecta.

Entenderlo es esencial porque casi todas las clases de NestJS participan en DI: declaras dependencias en el constructor y el contenedor IoC del framework las resuelve y proporciona automáticamente, eliminando la instanciación manual y el acoplamiento estrecho.

Los beneficios son significativos y centrales para entender por qué NestJS es valorado: **acoplamiento débil** (depender de abstracciones), **testabilidad** (inyectar mocks en lugar de dependencias reales — haciendo fácil realizar pruebas unitarias exhaustivas), reutilización (singletons compartidos), y mantenibilidad.

DI se toma prestado de frameworks como Angular y Spring, y dominarla — cómo declarar, registrar, inyectar y mockear dependencias — es necesario para construir aplicaciones NestJS bien estructuradas y testeables, y es uno de los conceptos más importantes para entender profundamente en el framework.