Bagaimana cara membuat custom decorator?

Question

Accepted Answer

NestJS memungkinkan Anda membuat **custom decorator** untuk merangkum logika yang dapat digunakan kembali — paling umum **parameter decorator** (untuk mengekstrak data dari request) dan **metadata decorator** (untuk melampirkan data yang dibaca oleh guards/interceptor). Decorator ini menjaga kode agar tetap DRY dan ekspresif.

## Custom parameter decorator — ekstrak 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` membangun parameter decorator: fungsinya menerima `ExecutionContext`, mengekstrak data, dan mengembalikan nilai untuk disuntikkan. Ini menggantikan akses berulang `@Req() req` + `req.user` dengan `@CurrentUser()` yang bersih dan dapat digunakan kembali.

## Parameter decorator dengan 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 (agar guards/interceptor dapat membacanya)

```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` — sebuah metadata decorator yang dibaca guard melalui `Reflector` — adalah pola kanonik untuk autorisasi berbasis peran.

## Mengkomposisi decorator

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

Membuat custom decorator adalah teknik NestJS yang penting untuk menjaga kode tetap DRY, ekspresif, dan mudah dipertahankan. **Custom parameter decorator** (`createParamDecorator`) memungkinkan Anda merangkum ekstraksi data request yang umum (seperti `@CurrentUser()`) menjadi anotasi yang bersih dan dapat digunakan kembali — jauh lebih baik daripada mengulangi `@Req() req` dan menggali ke dalam object request di setiap handler. **Custom metadata decorator** (`SetMetadata`) adalah fondasi dari pola autorisasi NestJS: pendekatan standar `@Roles()` + `RolesGuard` (dibaca melalui `Reflector`) untuk kontrol akses berbasis peran sepenuhnya bergantung pada pemahaman metadata decorator.

Dan **mengkomposisi decorator** (`applyDecorators`) memungkinkan Anda membundel decorator terkait (misalnya `@Auth()` yang menerapkan guards dan metadata bersama) untuk aplikasi yang ringkas dan konsisten.

Memahami cara membuat decorator ini adalah yang memungkinkan Anda membangun API NestJS yang ekspresif dan idiomatis serta mengimplementasikan pola umum (current-user injection, RBAC) dengan cara yang dimaksudkan framework. Ini meningkatkan Anda dari hanya menggunakan decorator bawaan menjadi memperluas gaya deklaratif framework untuk kebutuhan aplikasi Anda sendiri — keterampilan yang berharga dan sering diterapkan dalam proyek NestJS nyata.