I NestJS er en provider enhver klasse som kan injiseres som en avhengighet, og en service er den vanligste typen — en klasse som inneholder forretningslogikk. Å markere en klasse med @Injectable() gjør den til en provider som NestJS sitt DI-system kan opprette og injisere.
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; }
}
@Injectable() dekoratøren forteller NestJS at denne klassen deltar i dependency injection — den kan injiseres inn i kontrollere eller andre 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
}
}
Du deklarerer avhengigheten som en konstruktørparameter; NestJS oppretter og leverer instansen — du skriver aldri 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 må registreres i en moduls providers array for at DI skal vite om dem, og exports deler dem med andre moduler.
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 og services er kjernen i NestJS's arkitektur og dets dependency-injection-drevne design.
Services inneholder applikasjonens forretningslogikk, atskilt fra kontrollere (som bare håndterer HTTP-forhold) — denne separasjonen av ansvar gjør logikken gjenbrukbar på tvers av kontrollere, lett testbar isolert, og velorganisert.
Å forstå at @Injectable() markerer en klasse som en injiserbar provider, at providers registreres i moduler og injiseres via konstruktører (DI opprett instansene for deg), og at de er singletons som standard, er grunnleggende NestJS-kunnskap for daglig bruk.
Provider/service-mønsteret, kombinert med kontrollere og moduler, er ryggraden i hver NestJS-applikasjon — å mestre det er essensielt for å bygge velstrukturerte, vedlikeholdbare backends og er blant de første konseptene man lærer i rammeverket.