NestJS ਵਿੱਚ, ਇੱਕ provider ਕੋਈ ਵੀ ਕਲਾਸ ਹੈ ਜੋ ਇੱਕ ਨਿਰਭਰਤਾ ਦੇ ਤੌਰ ਤੇ injected ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਅਤੇ ਇੱਕ service ਸਭ ਤੋਂ ਆਮ ਕਿਸਮ ਹੈ — ਇੱਕ ਕਲਾਸ ਜੋ ਵਪਾਰਕ ਤਰਕ ਰੱਖਦੀ ਹੈ। ਇੱਕ ਕਲਾਸ ਨੂੰ @Injectable() ਨਾਲ ਚਿਹਨਿਤ ਕਰਨਾ ਇਸਨੂੰ ਇੱਕ provider ਬਣਾਉਂਦਾ ਹੈ ਜੋ NestJS ਦੀ DI ਪ್ਰਣਾਲੀ ਬਣਾ ਸਕਦੀ ਹੈ ਅਤੇ inject ਕਰ ਸਕਦੀ ਹੈ।
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() decorator NestJS ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਇਹ ਕਲਾਸ dependency injection ਵਿੱਚ ਭਾਗ ਲੈਂਦੀ ਹੈ — ਇਸਨੂੰ controllers ਜਾਂ ਹੋਰ providers ਵਿੱਚ inject ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
@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
}
}
ਤੁਸੀਂ ਨਿਰਭਰਤਾ ਨੂੰ ਇੱਕ ਕੰਸਟ੍ਰਕਟਰ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ ਤੇ ਘੋਸ਼ਿਤ ਕਰਦੇ ਹੋ; 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 ਅਤੇ services NestJS ਦੀ ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਇਸਦੀ dependency-injection-driven ਡਿਜ਼ਾਈਨ ਦਾ ਮੂਲ ਹਨ।
Services ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਵਪਾਰਕ ਤਰਕ ਰੱਖਦੀਆਂ ਹਨ, ਕੰਟਰੋਲਰਾਂ ਤੋਂ ਅਲੱਗ ਕੀਤੀਆਂ ਗਈਆਂ (ਜੋ ਸਿਰਫ HTTP ਚਿੰਤਾਵਾਂ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ) — ਸਮੱਸਿਆਵਾਂ ਦਾ ਇਹ ਵੰਡ ਤਰਕ ਨੂੰ ਕਈ ਕੰਟਰੋਲਰਾਂ ਵਿੱਚ ਮੁੜ-ਵਰਤਸ਼ੀਲ ਬਣਾਉਂਦਾ ਹੈ, ਇਸਨੂੰ ਵੱਖੋ-ਵੱਖਰਾ ਆਸਾਨੀ ਨਾਲ ਪਰਖਣਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਬਣਾਉਂਦਾ ਹੈ।
") ਇਸ ਗੱਲ ਨੂੰ ਸਮਝਣਾ ਕਿ @Injectable() ਇੱਕ ਕਲਾਸ ਨੂੰ ਇੱਕ injectable provider ਦੇ ਤੌਰ ਤੇ ਚਿਹਨਿਤ ਕਰਦਾ ਹੈ, ਕਿ providers ਨੂੰ ਮਾਡਿਊਲਾਂ ਵਿੱਚ ਰਜਿਸਟਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕੰਸਟ੍ਰਕਟਰਾਂ ਰਾਹੀਂ injected ਕੀਤੇ ਜਾਂਦੇ ਹਨ (DI ਤੁਹਾਡੇ ਲਈ ਉਦਾਹਰਨਾਂ ਬਣਾਉਂਦਾ ਹੈ), ਅਤੇ ਕਿ ਉਹ ਡਿਫਾਲਟ ਦੁਆਰਾ singletons ਹਨ, ਰੋਜ਼ਮਰਾਂ ਦੀ NestJS ਜਾਣਕਾਰੀ ਦਾ ਆਧਾਰ ਹੈ।
Provider/service ਪੈਟਰਨ, ਕੰਟਰੋਲਰਾਂ ਅਤੇ ਮਾਡਿਊਲਾਂ ਦੇ ਨਾਲ, ਹਰ NestJS ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਰੀੜ ਦੀ ਹੱਡੀ ਹੈ — ਇਸ ਵਿੱਚ ਮੁਹਾਰਤ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਰਚਿਤ, ਰੱਖ-ਸੰਭਾਲ ਯੋਗ back-ends ਬਣਾਉਣ ਲਈ ਲਾਜ਼ਮੀ ਹੈ ਅਤੇ ਫਰੇਮਵਰਕ ਵਿੱਚ ਸਿੱਖਣ ਦੀਆਂ ਪਹਿਲੀਆਂ ਧਾਰਨਾਵਾਂ ਵਿੱਚੋਂ ਹੈ।