Dans NestJS, un provider est une classe qui peut être injectée comme dépendance, et un service est le type le plus courant — une classe qui contient la logique métier. En marquant une classe avec @Injectable(), on en fait un provider que le système DI de NestJS peut créer et injecter.
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; }
}
Le décorateur @Injectable() indique à NestJS que cette classe participe à l'injection de dépendances — elle peut être injectée dans des contrôleurs ou d'autres providers.
@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
}
}
Vous déclarez la dépendance comme paramètre du constructeur ; NestJS crée et fournit l'instance — vous n'écrivez jamais 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 {}
Les providers doivent être enregistrés dans le tableau providers du module pour que le DI les connaisse, et exports les partage avec d'autres modules.
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.
Les providers et les services sont au cœur de l'architecture de NestJS et de sa conception basée sur l'injection de dépendances.
Les services contiennent la logique métier de l'application, séparée des contrôleurs (qui ne gèrent que les aspects HTTP) — cette séparation des préoccupations rend la logique réutilisable entre les contrôleurs, facilement testable isolément, et bien organisée.
Comprendre que @Injectable() marque une classe comme un provider injectable, que les providers sont enregistrés dans les modules et injectés via les constructeurs (le DI créant les instances pour vous), et qu'ils sont des singletons par défaut, est une connaissance fondamentale de NestJS au quotidien.
Le motif provider/service, combiné avec les contrôleurs et les modules, est l'épine dorsale de chaque application NestJS — le maîtriser est essentiel pour construire des back-ends bien structurés et maintenables, et fait partie des premiers concepts à apprendre dans le framework.