No NestJS, um provedor é qualquer classe que pode ser injetada como uma dependência, e um serviço é o tipo mais comum — uma classe que contém lógica de negócio. Marcar uma classe com @Injectable() a torna um provedor que o sistema de DI do NestJS pode criar e injetar.
import { Injectable } from "@nestjs/common";
@Injectable() // marks the class as a provider (injectable)
export class UsersService {
private users = [];
findAll() { return this.users; } // business logic
findOne(id: string) { return this.users.find(u => u.id === id); }
create(data) { this.users.push(data); return data; }
}
O decorador @Injectable() informa ao NestJS que esta classe participa da injeção de dependência — ela pode ser injetada em controladores ou outros provedores.
@Controller("users")
export class UsersController {
// NestJS sees this parameter and INJECTS a UsersService instance automatically
constructor(private usersService: UsersService) {}
@Get()
findAll() {
return this.usersService.findAll(); // use the injected service
}
}
Você declara a dependência como um parâmetro do construtor; o NestJS cria e fornece a instância — você nunca escreve new UsersService().
@Module({
controllers: [UsersController],
providers: [UsersService], // register the provider so DI can resolve it
exports: [UsersService], // make it available to OTHER modules that import this one
})
export class UsersModule {}
Os provedores devem ser registrados no array providers de um módulo para que o DI saiba sobre eles, e exports os compartilha com outros módulos.
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
Controller → handles HTTP (routing, request/response)
Service → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
TESTABLE (test the service in isolation), and ORGANIZED.
Provedores e serviços são o cerne da arquitetura do NestJS e de seu design orientado por injeção de dependência.
Serviços contêm a lógica de negócio da aplicação, mantida separada dos controladores (que lidam apenas com preocupações HTTP) — essa separação de responsabilidades torna a lógica reutilizável entre controladores, facilmente testável isoladamente e bem-organizada.
Entender que @Injectable() marca uma classe como um provedor injetável, que provedores são registrados em módulos e injetados via construtores (o DI criando as instâncias para você), e que são singletons por padrão é conhecimento fundamental do dia a dia no NestJS.
O padrão provedor/serviço, combinado com controladores e módulos, é a espinha dorsal de toda aplicação NestJS — dominá-lo é essencial para construir back-ends bem-estruturados e sustentáveis e está entre os primeiros conceitos a aprender no framework.