Como a injeção de dependência funciona no NestJS?

Question

Accepted Answer

**Injeção de Dependência (DI)** é um padrão central do NestJS onde o framework **cria e fornece automaticamente** as dependências que uma classe precisa, em vez da classe construí-las por si mesma. Você declara o que precisa no construtor, e o NestJS fornece — levando a código fracamente acoplado e testável.

## Como funciona: declare no construtor

```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 lê os tipos de parâmetros do construtor, procura pelos provedores registrados correspondentes, cria-os (se ainda não existirem) e os passa — resolvendo automaticamente todo o gráfico de dependência.

## O fluxo 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 e resolução

```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 que DI é 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)
```

## Testabilidade — o benefício decisivo

```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 a classe não constrói suas dependências, você pode substituir por mocks para testes — DI torna as aplicações NestJS altamente testáveis.

## Injetando valores que não são classes

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

## Por que isso importa

Injeção de dependência é o padrão fundamental que sustenta toda a arquitetura do NestJS — é como controllers recebem serviços, serviços recebem repositórios e outros serviços, e toda a aplicação é conectada.

Entender isso é essencial porque quase toda classe NestJS participa de DI: você declara dependências no construtor e o contêiner IoC do framework as resolve e fornece automaticamente, eliminando instanciação manual e acoplamento forte.

Os benefícios são significativos e centrais para o motivo pelo qual o NestJS é valorizado: **acoplamento fraco** (dependa de abstrações), **testabilidade** (injete mocks em vez de dependências reais — tornando testes unitários abrangentes fáceis), reutilização (singletons compartilhados) e manutenibilidade.

DI é emprestado de frameworks como Angular e Spring, e dominá-lo — como declarar, registrar, injetar e mockar dependências — é necessário para construir aplicações NestJS bem estruturadas e testáveis e é um dos conceitos mais importantes a entender profundamente no framework.