NestJS-ში, provider არის ნებისმიერი კლასი, რომელიც შეიძლება inject იყოს დამოკიდებულებად, ხოლო service არის ყველაზე გავრცელებული ტიპი — კლასი, რომელიც შეიცავს business logic. კლასის @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() დეკორატორი NestJS-ს ეტყვის, რომ ეს კლასი მონაწილეობს dependency injection-ში — მისი injection შეიძლება controllers ან სხვა 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
}
}
დამოკიდებულებას ცხადსახელი ქმნით როგორც constructor პარამეტრს; NestJS ქმნის და მიაწვდის instance-ს — თქვენ არასოდეს წერთ 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 უნდა იყოს რეგისტრირებული module-ის providers მასივში, რათა DI-მ იცოდეს მათ შესახებ, და exports გაზიარებს მათ სხვა 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 და services არის NestJS-ის არქიტექტურის ჯერი და მის dependency-injection-driven დიზაინის ფუძე.
Services-ებში ინახება აპლიკაციის business logic, დამოვიანდელი controllers-ისგან (რომელიც ზრდის მხოლოდ HTTP საკითხებს) — ეს ზეწოდების გამოყოფა ხდის logic-ს reusable-ს controllers-ის შორის, ადვილად testable-ს იზოლაციაში, და კარგად ორგანიზებულს.
ის, რომ @Injectable() აღნიშნავს კლასს როგორც injectable provider-ს, რომ providers-ი რეგისტრირებულია modules-ებში და injected არის constructors-ის მეშვეობით (DI ქმნის instances-ებს თქვენთვის), და რომ ისინი არის singletons ნაგულისხმევად, არის ფუნდამენტური ყოველდღიური NestJS ცოდნა.
Provider/service pattern, combined with controllers და modules, არის ყველა NestJS აპლიკაციის ხერხემალი — მისი დაუფლება აუცილებელია კარგად დაკომპონებული, maintainable back-end-ების აგებისთვის და მეორდება framework-ის პირველ კონცეფციებს შორის.