In NestJS is een provider elke klasse die als afhankelijkheid kan worden geïnjecteerd, en een service is het meest voorkomende soort — een klasse die bedrijfslogica bevat. Een klasse markeren met @Injectable() maakt het een provider die het DI-systeem van NestJS kan maken en injecteren.
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; }
}
De @Injectable() decorator vertelt NestJS dat deze klasse deelneemt aan dependency injection — hij kan worden geïnjecteerd in controllers of andere 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
}
}
Je declareert de afhankelijkheid als een constructor-parameter; NestJS maakt en levert het exemplaar — je schrijft nooit 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 {}
Providers moeten in de providers-array van een module worden geregistreerd zodat de DI er kennis van neemt, en exports deelt ze met andere 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.
Providers en services vormen de kern van de architectuur van NestJS en het op dependency injection gerichte ontwerp.
Services bevatten de bedrijfslogica van de applicatie, gescheiden van controllers (die alleen HTTP-concerns afhandelen) — deze scheiding van verantwoordelijkheden maakt logica herbruikbaar over controllers heen, gemakkelijk testbaar in isolatie, en goed georganiseerd.
Begrijpen dat @Injectable() een klasse markeert als een injecteerbare provider, dat providers in modules worden geregistreerd en via constructors worden geïnjecteerd (waarbij DI de exemplaren voor je maakt), en dat ze standaard singletons zijn, is fundamentele dagelijkse NestJS-kennis.
Het provider/service-patroon, gecombineerd met controllers en modules, vormt de ruggengraat van elke NestJS-applicatie — het onder de knie krijgen is essentieel voor het bouwen van goed gestructureerde, onderhoudbare back-ends en hoort bij de eerste concepten die je in het framework moet leren.