Katika NestJS, provider ni class yoyote inayoweza kuingizwa (injected) kama dependency, na service ni aina inayojulikana zaidi — class inayoshikilia business logic. Kuweka alama @Injectable() kwenye class huifanya kuwa provider ambayo mfumo wa DI wa NestJS unaweza kuiunda na kuiingiza.
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; }
}
Decorator ya @Injectable() huiambia NestJS kuwa class hii hushiriki katika dependency injection — inaweza kuingizwa ndani ya controllers au providers nyingine.
@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
}
}
Unatangaza dependency kama parameter ya constructor; NestJS huunda na kutoa instance — kamwe huandiki 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 lazima zisajiliwe katika array ya providers ya module ili DI iweze kuzijua, na exports huzishirikisha na modules nyingine.
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 na services ni msingi wa usanifu wa NestJS na muundo wake unaoendeshwa na dependency injection.
Services hushikilia business logic ya programu, ikitenganishwa na controllers (zinazoshughulikia mambo ya HTTP pekee) — mgawanyo huu wa majukumu huifanya logic kuwa inayoweza kutumika tena katika controllers nyingi, rahisi kupimwa kwa kujitegemea, na imepangwa vizuri.
Kuelewa kuwa @Injectable() huweka alama kwenye class kama provider inayoweza kuingizwa, kuwa providers husajiliwa katika modules na huingizwa kupitia constructors (DI ikiunda instances kwa niaba yako), na kuwa ni singletons kwa msingi ni maarifa ya msingi ya kila siku ya NestJS.
Muundo wa provider/service, ukiungana na controllers na modules, ni uti wa mgongo wa kila programu ya NestJS — kuumudu ni muhimu kwa kujenga back-ends zilizopangwa vizuri na zinazoweza kudumishwa, na ni miongoni mwa dhana za kwanza kujifunza katika framework hii.