რა არის კონტროლერები NestJS-ში?

Question

Accepted Answer

**კონტროლერები** ამუშავებენ შემოსულ **HTTP მოთხოვნებს** და ბრუნდებიან პასუხები. ისინი განსაზღვრავენ თქვენი აპლიკაციის მარშრუტებს და მოქმედებენ როგორც შესვლის წერტილი — მოთხოვნების მიღება, მონაცემების ამოღება, დელეგირება სერვისებთან და შედეგების დაბრუნება. ისინი ცალკე ინარჩუნებენ მარშრუტიზაციის ამოცანებს ბიზნეს ლოგიკისგან.

## კონტროლერის განსაზღვრა

```ts
import { Controller, Get, Post, Body, Param } from "@nestjs/common";

@Controller("users")          // the route PREFIX → all routes start with /users
export class UsersController {
  constructor(private usersService: UsersService) {}   // inject a service via DI

@Get()                       // GET /users
  findAll() {
    return this.usersService.findAll();
  }

@Get(":id")                  // GET /users/:id
  findOne(@Param("id") id: string) {        // extract the route param
    return this.usersService.findOne(id);
  }

@Post()                      // POST /users
  create(@Body() dto: CreateUserDto) {       // extract the request body
    return this.usersService.create(dto);
  }
}
```

## როგორ მუშაობს: დეკორატორები აკავშირებენ მეთოდებს მარშრუტებთან

```text
@Controller("users") → route prefix /users
@Get() / @Post() / @Put() / @Patch() / @Delete() → HTTP method + sub-path
Combined: @Get(":id") inside @Controller("users") → GET /users/:id
```

დეკორატორები დეკლარაციულად აკავშირებენ კლასის მეთოდებს HTTP მარშრუტებთან — სუფთა და წაკითხვადი, მარშრუტის ხელით რეგისტრაციის გარეშე.

## პარამეტრის დეკორატორები ამოღებენ მოთხოვნის მონაცემებს

```ts
@Get(":id")
example(
  @Param("id") id: string,        // route parameter (/users/:id)
  @Query("sort") sort: string,    // query string (?sort=name)
  @Body() body: CreateUserDto,    // request body
  @Headers("authorization") auth: string,  // a header
  @Req() req: Request,            // the raw request object (rarely needed)
) {}
```

Nest-ის პარამეტრის დეკორატორები (`@Param`, `@Query`, `@Body`, `@Headers`) სუფთად ამოღებენ ზუსტად იმ მონაცემებს, რომელიც დაგჭირდებათ — `req`-ის ხელით დაშლაა გარეშე.

## კონტროლერები უნდა იყვნენ წამკრთალი

```ts
// ✅ controller delegates to a service — stays thin
@Post()
create(@Body() dto: CreateUserDto) {
  return this.usersService.create(dto);   // business logic lives in the SERVICE
}
// ❌ don't put database queries / business logic directly in the controller
```

უმჯობესი პრაქტიკა: კონტროლერები **წამკრთალი** დაიჭირეთ — ისინი ამუშავებენ HTTP-ის ამოცანებს (მარშრუტიზაცია, მონაცემების ამოღება, პასუხის დაბრუნება) და ყველა ბიზნეს ლოგიკას დელეგირებენ **სერვისებთან**. ეს გამიჯვნა ინარჩუნებს კოდს ტესტირებადს და ორგანიზებულს.

## რატომ არის ეს მნიშვნელოვანი

კონტროლერები არის NestJS-ის ფундამენტური სამშენებლო ბლოკი — ყველა HTTP მოთხოვნის შესვლის წერტილი და სადაც თქვენი API-ის მარშრუტები განსაზღვრულია.

გაგება, თუ როგორ აკავშირებენ დეკორატორები (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) მეთოდებს მარშრუტებთან და ამოღებენ მოთხოვნის მონაცემებს დეკლარაციულად არის ყოველდღიური NestJS-ის ცოდნა — ეს არის როგორ აშენებთ ნებისმიერ ენდპოინტს.

ნაკი მნიშვნელოვანი არის კონტროლერების **წამკრთალი** შენახვის პრინციპი (მხოლოდ HTTP-ის ამოცანების ამუშავება და ბიზნეს ლოგიკის დელეგირება ინექტირებული სერვისებთან), რომელიც ემსახურება NestJS-ის განმიჯნეს-ამოცანების ფილოსოფიას და ინარჩუნებს კოდს შენახვადს და ტესტირებადს.

კონტროლერები, სერვისებთან და მოდულებთან ერთად, ქმნის ყველა NestJS აპლიკაციის ძირითად სტრუქტურას, რაც მათ აუცილებელს ხდის დასაწყისიდანვე გასაგები.