როგორ ქმნით custom decorators?

Question

Accepted Answer

NestJS საშუალებას გაძლევთ შექმნათ **custom decorators** გადამეორებადი ლოგიკის ინკაფსულაციისთვის — ყველაზე ხშირად **parameter decorators** (მონაცემების request-დან ამოსაღებად) და **metadata decorators** (მონაცემების guards/interceptors-ის მიერ წასაკითხად). ისინი კოდს აკეთებენ DRY-ს და გამოხატულებაში풍부.

## Custom parameter decorator — request მონაცემების ამოღება

```ts
import { createParamDecorator, ExecutionContext } from "@nestjs/common";

// extract the authenticated user (attached to the request by an auth guard)
export const CurrentUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;        // return whatever you want injected
  },
);

// usage — clean and readable
@Get("profile")
getProfile(@CurrentUser() user: User) {     // instead of @Req() req and req.user
  return user;
}
```

`createParamDecorator` ქმნის parameter decorator-ს: მისი ფუნქცია იღებს `ExecutionContext`-ს, ამოღებს მონაცემებს და აბრუნებს მნიშვნელობას inject-ის მისაღებად. ეს იცვლება განმეორებადი `@Req() req` + `req.user` წვდომის깨끗한, გადამეორებადი `@CurrentUser()`-ით.

## Parameter decorator არგუმენტებით

```ts
// extract a specific property: @CurrentUser("email")
export const CurrentUser = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const user = ctx.switchToHttp().getRequest().user;
    return data ? user?.[data] : user;   // `data` is the argument passed to the decorator
  },
);
// @CurrentUser("email") email: string  → injects just user.email
```

## Custom metadata decorator (guards/interceptors-ის წასაკითხად)

```ts
import { SetMetadata } from "@nestjs/common";

// a @Roles() decorator that ATTACHES metadata to a route
export const Roles = (...roles: string[]) => SetMetadata("roles", roles);

// usage
@Roles("admin", "editor")
@Get("users")
listUsers() {}
```

```ts
// a guard reads the metadata via Reflector
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}
  canActivate(ctx: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>("roles", ctx.getHandler());   // read it
    const { user } = ctx.switchToHttp().getRequest();
    return !roles || roles.some(r => user.roles?.includes(r));
  }
}
```

`@Roles()` + `RolesGuard` კომბინაცია — metadata decorator, რომელსაც guard კითხულობს `Reflector`-ის მეშვეობით — არის canonical ნიმუში role-based authorization-ისთვის.

## Decorators-ის კომპოზიცია

```ts
import { applyDecorators } from "@nestjs/common";
// bundle multiple decorators into one reusable decorator
export function Auth(...roles: string[]) {
  return applyDecorators(SetMetadata("roles", roles), UseGuards(AuthGuard, RolesGuard));
}
// usage: @Auth("admin")  — applies metadata + guards in one decorator
```

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

Custom decorators-ის შექმნა NestJS-ის მნიშვნელოვანი ტექნიკაა კოდის DRY-ის, გამოხატულებითობის და შენარჩუნებისთვის. **Custom parameter decorators** (`createParamDecorator`) საშუალებას გაძლევთ ინკაფსულაციოთ common request-data extraction (როგორიცაა `@CurrentUser()`)깨끗ა, გადამეორებადი annotations-ში — გაცილებით უკეთესი, ვიდრე `@Req() req`-ის განმეორება და request object-ის თითოეული handler-ში ასკვლა. **Custom metadata decorators** (`SetMetadata`) არის NestJS-ის authorization ნიმუშების საფუძველი: სტანდარტული `@Roles()` + `RolesGuard` (წაკითხული `Reflector`-ის მეშვეობით) approach role-based access control-ის განზრახვით მთლიანად დამოკიდებულია metadata decorators-ის გაგებაზე.

და **decorators-ის კომპოზიცია** (`applyDecorators`) საშუალებას გაძლევთ დააკავშიროთ დაკავშირებული decorators (მაგ. `@Auth()`, რომელიც guards და metadata-ს ერთად ქმნის) concise, თანმიმდევრული აპლიკაციის მისაღებად.
each როგორ შეიქმნას ეს არის, რაც საშუალებას გაძლევთ ააგოთ expressive, idiomatic NestJS APIs და განახორციელოთ common ნიმუშები (current-user injection, RBAC) framework-ის წინამიზის გზით.

ეს აამაღლებს თქვენს მხოლოდ built-in decorators-ის გამოყენებიდან framework-ის declarative style-ის თქვენი აპლიკაციის საჭიროებებისთვის გაფართოებამდე — ღირებული, ხშირად გამოყენებული უნარი real NestJS projects-ში.