Si krijoni dekoratorë të personalizuar?

Question

Accepted Answer

NestJS ju lejon të krijoni **dekoratorë të personalizuar** për të kapsuluarsë logjikën e ripërdorshme — më të zakonshmet janë **dekoratorët e parametrave** (për nxjerrjen e të dhënave nga kërkesa) dhe **dekoratorët e metapodateve** (për bashkangitjen e të dhënave të lexuara nga guards/interceptors). Ata mbajnë kodin DRY dhe shprehës.

## Dekorator i personalizuar i parametrave — nxjerrja e të dhënave të kërkesës

```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` ndërton një dekorator parametrash: funksioni i tij merr `ExecutionContext`-in, nxjerr të dhënat, dhe kthen vlerën për të injektuar. Kjo zëvendëson qasjen e përsëritur `@Req() req` + `req.user` me një `@CurrentUser()` të pastër dhe të ripërdorshëm.

## Dekorator parametrash me argumente

```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
```

## Dekorator i personalizuar i metapodateve (për guards/interceptors që të lexojnë)

```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));
  }
}
```

Kombinacioni `@Roles()` + `RolesGuard` — një dekorator metapodat që një guard lexon përmes `Reflector` — është modeli kanonik për autorizimin bazuar në role.

## Përbërja e dekoratorëve

```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
```

## Pse është e rëndësishme

Krijoni dekoratorë të personalizuar është një teknikë e rëndësishme NestJS për ruajtjen e kodit DRY, shprehës dhe të mirëmbajtshëm. **Dekoratorët e personalizuar të parametrave** (`createParamDecorator`) ju lejojnë të kapsuluarsë ekstraktimin e zakonshëm të të dhënave të kërkesës (si `@CurrentUser()`) në shënime të pastra dhe të ripërdorshme — shumë më mirë se sa të përsërisni `@Req() req` dhe të gërmuani në objektin e kërkesës në çdo handler. **Dekoratorët e personalizuar të metapodateve** (`SetMetadata`) janë themeli i modeleve të autorizimit të NestJS: qasja standarde `@Roles()` + `RolesGuard` (e lexuar përmes `Reflector`) për kontrollin e qasjes bazuar në role varet plotësisht nga kuptimi i dekoratorëve të metapodateve.

Dhe **përbërja e dekoratorëve** (`applyDecorators`) ju lejon të grumbulloni dekoratorët e lidhur (p.sh. një `@Auth()` që zbaton guards dhe metapodate së bashku) për aplikimin e qartë dhe të qëndrueshëm.

Kuptimi i mënyrës për të krijuar këto është ajo që ju lejon të ndërtoni APIs shprehëse dhe idiomatike NestJS dhe të zbatoni modele të zakonshme (injektimi i përdoruesit aktual, RBAC) në mënyrën e synuar të framework-it — një aftësi të vlefshme dhe shpesh e aplikuar në projekte reale NestJS.

Ejo ju ngre mbi thjesht përdorimin e dekoratorëve të ndërtuar për të zgjeruar stilin deklaratif të framework-it për nevojat e aplikacionit tuaj — një aftësi e vlefshme dhe e aplikuar shpesh në projekte reale NestJS.