Conas a chruthaíonn tú dearthóirí custaimeacha?

Question

Accepted Answer

Tugann NestJS deis duit **dearthóirí custaimeacha** a chruthú chun loighic athúsáidte a dhúnmhagadh — is minice **dearthóirí paraiméadair** (chun sonraí a bhaint as an iarratas) agus **dearthóirí meiteashonraí** (chun sonraí a cheangal a léifidh gardaí/idirghabhálaithe). Coinníonn siad an cód tirim agus soiléir.

## Dearthóir paraiméadair custaimeach — sonraí iarratas a bhaint

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

Tógann `createParamDecorator` dearthóir paraiméadair: faigheann a fheidhm an `ExecutionContext`, baineann sonraí, agus filleann an luach a bhí le instealladh. Cuireann sé seo in ionad athrá `@Req() req` + `req.user` le `@CurrentUser()` geal, athúsáidte.

## Dearthóir paraiméadair le hargóintí

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

## Dearthóir meiteashonraí custaimeach (do ghardaí/idirghabhálaithe a léamh)

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

Is é an teicníc caighdeánach é an teicníc `@Roles()` + `RolesGuard` — dearthóir meiteashonraí a léann garda trí `Reflector` — do údarú bunaithe ar ról.

## Dearthóirí a dhréachtú

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

## Cén fáth a bhfuil sé tábhachtach

Is teicníc thábhachtach NestJS a bhí ann dearthóirí custaimeacha a chruthú chun an cód a choimeád tirim, soiléir agus inchothromaithe. **Dearthóirí paraiméadair custaimeach** (`createParamDecorator`) tugann deis duit loighic bhaint sonraí ghnáth an iarratas (mar `@CurrentUser()`) a dhúnmhagadh i nótaíonn geal, athúsáidte — i bhfad níos fearr ná `@Req() req` a athdhéanamh agus an réad iarratas a bhaint as gach láimhseoir. **Dearthóirí meiteashonraí custaimeach** (`SetMetadata`) is bhunús iad do phatrúin údaruithe NestJS: braitheann an chur chuige caighdeánach `@Roles()` + `RolesGuard` (a léitear trí `Reflector`) ar dhealramh rolla ar thuiscint ar dhearaí meiteashonraí ar fad.

Agus **dearthóirí a dhréachtú** (`applyDecorators`) tugann deis duit dearthóirí gaolmhara a bhacadh le chéile (m.sh. `@Auth()` a chuireann gardaí agus meiteashonraí i bhfeidhm le chéile) do dhéanamh achomhairc geal, comhsheasmhach.

Tuigint ar conas a chruthú iad seo is ea a ligeann duit APIanna soiléire, idiomaiteach NestJS a thógáil agus patrúin ghnáth (instealladh úsáideora reatha, RBAC) a chur i bhfeidhm ar an dóigh a bhí beartaithe ag an chreat — scil fiúntach, i bhfad-fheidhmíochta i dtionscadail NestJS fíor.

Ardaíonn sé tú ó dhíreach dearthóirí tógtha i gceist a úsáid go dtí stíl dheachlarative an chreata a leathnairt ar son riachtanais d'iarratas féin — scil luachmhar, go minic-fheidhmíochta i dtionscadail NestJS fíor.