როგორ იყენებს NestJS დეკორატორებს?

Question

Accepted Answer

NestJS აგებულია **TypeScript დეკორატორების** გარშემოთ — სპეციალური `@`-პრეფიქსის მქონე ანოტაციები, რომლებიც **მეტადენებს** ამაგრებენ კლასებზე, მეთოდებზე და პარამეტრებზე. NestJS კითხულობს ამ მეტადენებს (რეფლექციის მეშვეობით) რაუტინგის, დამოკიდებულების ინჟექციის, ვალიდაციის და სხვა რამის დეკლარაციულად დაკორექტირების მიზნით. დეკორატორები ყველგან არის Nest-ში.

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

```ts
@Controller("users")     // this class is a CONTROLLER, prefix /users
export class UsersController {}

@Injectable()            // this class is a PROVIDER (injectable)
export class UsersService {}

@Module({ ... })         // this class is a MODULE
export class UsersModule {}
```

კლასის დეკორატორები აცხადებენ რა *არის* კლასი NestJS არქიტექტურაში (კონტროლერი, პროვაიდერი, მოდული) და კonfiguresთ მას.

## მეთოდის დეკორატორები — მარშრუტების რუკა და ქცევის გამოყენება

```ts
@Get()                   // GET request handler
@Post()                  // POST handler
@Get(":id")              // GET /users/:id
@HttpCode(204)           // set the response status code
@UseGuards(AuthGuard)    // apply a guard to this route
@UseInterceptors(LoggingInterceptor)
findAll() {}
```

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

```ts
findOne(
  @Param("id") id: string,       // route parameter
  @Query("sort") sort: string,   // query string
  @Body() dto: CreateUserDto,    // request body
  @Headers("auth") auth: string, // header
) {}
```

პარამეტრის დეკორატორები დეკლარაციულად იღებენ ზუსტად ის მონაცემებს, რაც გჭირდებათ მოთხოვნიდან — არ არის საჭირო `req`-ის ხელით ანალიზი.

## თვისების/ვალიდაციის დეკორატორები (DTO-ებზე)

```ts
export class CreateUserDto {
  @IsEmail()                     // validation rules (class-validator)
  email: string;

@IsString()
  @MinLength(8)
  password: string;
}
```

## რატომ დეკორატორები? დეკლარაციული მეტადენა

```text
Decorators attach METADATA that NestJS reads at runtime (via reflection) to:
  ✓ Register routes (@Get, @Controller)
  ✓ Wire dependency injection (@Injectable, @Inject)
  ✓ Apply guards/interceptors/pipes (@UseGuards, etc.)
  ✓ Validate input (@IsEmail, @IsString)
→ Behavior is declared WHERE it applies, concisely and readably.
```

## მორგებული დეკორატორები

```ts
// you can create your own — e.g. extract the current user from the request
export const CurrentUser = createParamDecorator((data, ctx) =>
  ctx.switchToHttp().getRequest().user
);
// usage: findProfile(@CurrentUser() user: User) {}
```

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

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

ისინი იძლევიან **დეკლარაციულ**, მეტადენებითი მიდგომას: ინიციატივის კონფიგურაციის ნაცვლად, თქვენ ანოტირებთ კლასებს, მეთოდებს და პარამეტრებს რაუტინგის (`@Controller`, `@Get`), დამოკიდებულების ინჟექციის (`@Injectable`), ჯვარედინი ქცევის (`@UseGuards`, `@UseInterceptors`) და ვალიდაციის (`@IsEmail`) დეკლარირებისთვის ზუსტად სად სად უნდა გამოიყენებოდეს — მოკლე და წაკითხვადი.

ეს მეტადენა-რეფლექციის მეშვეობით მექანიზმი (იგივე იდეა Angular-ისა და Java/Spring ანოტაციების უკან) არის ის, რაც საშუალებას აძლევს NestJS-ის სუფთა, სტრუქტურირებულ სტილს.

კატეგორიების (კლასი, მეთოდი, პარამეტრი, თვისების დეკორატორები) ამოცნობა, ჩვეულებრივი დეკორატორების ცოდნა და მორგებული დეკორატორების შექმნის უნარი არის ფუნდამენტური NestJS კომპეტენცია — დეკორატორები არის ის ხერხი, რომლითაც თითქმის ყველა ფიჩер გამოხატულია, რაც მათ ჩარჩოში სწავლის პირველ და ყველაზე მნიშვნელოვან რამეებად აქცევს.