NestJS માં, એક provider એવો કોઈ પણ વર્ગ છે જે ઇજેક્ટ થઇ શકે છે, અને એક service સૌથી સામાન્ય પ્રકાર છે — એક વર્ગ જે બિઝનેસ લોજિક ધરાવે છે. વર્ગને @Injectable() સાથે માર્ક કરવાથી તે એક provider બને છે જે NestJS ના DI સિસ્ટમ દ્વારા બનાવવામાં અને ઇજેક્ટ કરવામાં આવી શકે છે.
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() ડેકોરેટર NestJS ને કહે છે કે આ વર્ગ dependency injection માં ભાગ લે છે — તે નિયંત્રક અથવા અન્ય 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
}
}
તમે dependency ને constructor પેરામીટર તરીકે જાહેર કરો છો; NestJS ઇન્સ્ટન્સ બનાવે છે અને તેમ આપે છે — તમે 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 ને મોડ્યુલના providers એરેમાં નોંધાવવું આવશ્યક છે જેથી DI તેમને જાણે, અને exports તેમને અન્ય મોડ્યુલો સાથે શેર કરે છે.
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 અને સેવાઓ NestJS ના આર્કિટેક્ચર અને તેની dependency-injection-driven ડિઝાઇનનો મૂલ છે.
સેવાઓ એપ્લિકેશનના બિઝનેસ લોજિક ધરાવે છે, નિયંત્રકો (જે માત્ર HTTP સમસ્યાઓને સંભાળે છે) થી જુદા રાખવામાં આવે છે — આ separation of concerns લોજિકને નિયંત્રકો પર પુનઃવપરાશ શક્ય બનાવે છે, અલગતામાં સરળતાથી test કરી શકાય છે, અને સારી રીતે આયોજિત છે.
યह સમજવું કે @Injectable() વર્ગને injectable provider તરીકે માર્ક કરે છે, કે providers મોડ્યુલમાં નોંધાયેલા છે અને constructors દ્વારા ઇજેક્ટ કરવામાં આવે છે (DI તમારા માટે instances બનાવે છે), અને તે ડિફોલ્ટ રીતે singletons છે, તે NestJS નું મૂળભૂત રોજિંદા જ્ઞાન છે.
Provider/service પેટર્ન, નિયંત્રકો અને મોડ્યુલો સાથે, દરેક NestJS એપ્લિકેશનની પાયાનું કામ છે — તેને માસ્ટર કરવું સુવ્યવસ્થિત, રક્ષણીય back-ends બનાવવા માટે આવશ્યક છે અને framework માં શીખવાના પ્રથમ ખ્યાલોમાંથી એક છે.