Piye carane nggawe custom decorators?

Question

Accepted Answer

NestJS ngliloni sampeyan nggawe **custom decorators** kanggo enkapsulasi logika sing bisa dibaleni — paling umum **parameter decorators** (kanggo njupuk data saka request) lan **metadata decorators** (kanggo nglampirake data sing diwaca dening guards/interceptors). Iku njaga kode supaya tetep DRY lan ekspresif.

## Custom parameter decorator — njupuk data 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` mbangun parameter decorator: fungsinira nampa `ExecutionContext`, njupuk data, lan mulang nilai kanggo disuntikake. Iki ngganti akses `@Req() req` + `req.user` sing repetitif karo `@CurrentUser()` sing bersih lan bisa dibaleni.

## Parameter decorator karo argumen

```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 (kanggo guards/interceptors maca)

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

Kombinasi `@Roles()` + `RolesGuard` — metadata decorator sing guard bisa maca via `Reflector` — minangka pola kanonik kanggo otorisasi berbasis peran.

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

## Mengapa iki penting

Nggawe custom decorators minangka teknik NestJS sing penting kanggo njaga kode tetep DRY, ekspresif, lan mudah dipangopeni. **Custom parameter decorators** (`createParamDecorator`) ngliloni sampeyan enkapsulasi ekstraksi data request sing umum (kaya `@CurrentUser()`) menyang anotasi sing bersih lan bisa dibaleni — luwih apik tinimbang mbaleni `@Req() req` lan nggaleh obyek request ing saben handler. **Custom metadata decorators** (`SetMetadata`) minangka fondasi pola otorisasi NestJS: pendekatan standar `@Roles()` + `RolesGuard` (maca via `Reflector`) kanggo kontrol akses berbasis peran gumantung saenake ing ngerti metadata decorators.

Lan **nggabungke decorators** (`applyDecorators`) ngliloni sampeyan bundel decorators sing gayut (cth `@Auth()` sing ngetrapake guards lan metadata bareng) kanggo aplikasi sing ringkas lan konsisten.

Pamahaman babagan cara nggawe iki minangka sing ngliloni sampeyan mbangun APIs NestJS sing ekspresif lan idiomatik lan ngetrapake pola umum (current-user injection, RBAC) kanthi cara sing dimaksudake framework — katrampilan sing bermanfaat lan asring diterapake ing proyek NestJS nyata.

Iku ngunggakake sampeyan saka mung nggunakake decorators sing isih kaya-kaya menyang nggelar gaya deklaratif framework kanggo kabutuhan aplikasi sariran sampeyan — katrampilan sing kok kantep, asring-asring digunakake ing proyek NestJS nyata.