Kuinka luot muokattavia dekoraattoreita?

Question

Accepted Answer

NestJS sallii **muokattavien dekoraattoreiden** luomisen uudelleenkäytettävän logiikan kapselointiin — yleisimmin **parametridekoraattoreihin** (pyynnön tietojen erottamiseen) ja **metatieto-dekoraattoreihin** (tietojen liittämiseen, joita varjelijat/sieppaajat lukevat). Ne pitävät koodin kuivana ja ilmaisullisesti selkeänä.

## Mukautettu parametridekoraattori — pyynnön tietojen erottaminen

```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` rakentaa parametridekoraattoria: sen funktio vastaanottaa `ExecutionContext`in, erottaa tiedot ja palauttaa injektointia varten arvon. Tämä korvaa toistuvat `@Req() req` + `req.user` -käytöt puhtaalla, uudelleenkäytettävällä `@CurrentUser()`illa.

## Parametridekoraattori argumenteilla

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

## Mukautettu metatieto-dekoraattori (varjelijoiden/sieppaajien luettavaksi)

```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` -yhdistelmä — metatieto-dekoraattori, jonka varjelijat lukevat `Reflector`in kautta — on kanoninen kuvio roolipohjaista valtuutusta varten.

## Dekoraattoreiden yhdistäminen

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

## Miksi tämä on tärkeää

Muokattavien dekoraattoreiden luominen on tärkeä NestJS-tekniikka koodin kuivaksi, ilmaisulliseksi ja ylläpidettäväksi pitämiselle. **Mukautetut parametridekoraattorit** (`createParamDecorator`) antavat sinun kapseloida yleiset pyynnön tietojen erottelut (kuten `@CurrentUser()`) puhtaiksi, uudelleenkäytettäviksi merkinnöiksi — paljon parempi kuin toistaa `@Req() req` ja kaivaa pyynnön objektista jokaisessa käsittelijässä. **Mukautetut metatieto-dekoraattorit** (`SetMetadata`) ovat NestJS:n valtuutuskuvioiden perusta: vakio `@Roles()` + `RolesGuard` (luetaan `Reflector`in kautta) -lähestymistapa rooliperusteiselle pääsynvalvonnalle riippuu täysin metatieto-dekoraattoreiden ymmärtämisestä.

Ja **dekoraattoreiden yhdistäminen** (`applyDecorators`) antaa sinun niputtaa niihin liittyvät dekoraattorit (esim. `@Auth()`, joka soveltaa vartijoita ja metatieto-dekoraattoreita yhdessä) ytimekkäälle, johdonmukaiselle soveltamiselle.

Ymmärtäminen siitä, kuinka luoda näitä, on se, mitä antaa sinulle mahdollisuuden rakentaa ilmaisullisia, idiomatttisia NestJS-API:ta ja toteuttaa yleisiä kuvioita (nykyisen käyttäjän injektio, RBAC) kehyksen tarkoittamalla tavalla.

Se nostaa sinut pelkän sisäisten dekoraattoreiden käytöstä kehyksen deklaratiiviisen tyylin laajentamiseen omien sovellusvaatimustesi mukaan — arvokas, usein sovellettu taito oikeissa NestJS-projekteissa.