Bạn tạo custom decorator như thế nào?

Question

Accepted Answer

NestJS cho phép bạn tạo **custom decorator** để đóng gói logic tái sử dụng — phổ biến nhất là **parameter decorator** (để trích xuất dữ liệu từ request) và **metadata decorator** (để gắn dữ liệu được guard/interceptor đọc). Chúng giữ cho code DRY và biểu cảm.

## Custom parameter decorator — trích xuất dữ liệu request

```ts
import { createParamDecorator, ExecutionContext } from "@nestjs/common";

// trích xuất user đã xác thực (được auth guard gắn vào request)
export const CurrentUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;        // trả về bất cứ gì bạn muốn inject
  },
);

// cách dùng — sạch sẽ và dễ đọc
@Get("profile")
getProfile(@CurrentUser() user: User) {     // thay vì @Req() req và req.user
  return user;
}
```

`createParamDecorator` dựng một parameter decorator: hàm của nó nhận `ExecutionContext`, trích xuất dữ liệu, và trả về giá trị để inject. Cái này thay thế việc truy cập `@Req() req` + `req.user` lặp đi lặp lại bằng một `@CurrentUser()` sạch sẽ, tái sử dụng được.

## Parameter decorator với tham số

```ts
// trích xuất một thuộc tính cụ thể: @CurrentUser("email")
export const CurrentUser = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const user = ctx.switchToHttp().getRequest().user;
    return data ? user?.[data] : user;   // `data` là tham số truyền vào decorator
  },
);
// @CurrentUser("email") email: string  → chỉ inject user.email
```

## Custom metadata decorator (để guard/interceptor đọc)

```ts
import { SetMetadata } from "@nestjs/common";

// một decorator @Roles() GẮN metadata vào một route
export const Roles = (...roles: string[]) => SetMetadata("roles", roles);

// cách dùng
@Roles("admin", "editor")
@Get("users")
listUsers() {}
```

```ts
// một guard đọc metadata qua Reflector
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}
  canActivate(ctx: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>("roles", ctx.getHandler());   // đọc nó
    const { user } = ctx.switchToHttp().getRequest();
    return !roles || roles.some(r => user.roles?.includes(r));
  }
}
```

Kết hợp `@Roles()` + `RolesGuard` — một metadata decorator mà một guard đọc qua `Reflector` — là pattern chuẩn mực cho phân quyền dựa trên role.

## Kết hợp decorator

```ts
import { applyDecorators } from "@nestjs/common";
// gói nhiều decorator thành một decorator tái sử dụng được
export function Auth(...roles: string[]) {
  return applyDecorators(SetMetadata("roles", roles), UseGuards(AuthGuard, RolesGuard));
}
// cách dùng: @Auth("admin")  — áp dụng metadata + guard trong một decorator
```

## Tại sao điều này quan trọng

Tạo custom decorator là một kỹ thuật quan trọng của NestJS để giữ code DRY, biểu cảm và dễ bảo trì. **Custom parameter decorator** (`createParamDecorator`) cho phép bạn đóng gói việc trích xuất dữ liệu request phổ biến (như `@CurrentUser()`) thành các chú thích sạch sẽ, tái sử dụng được — tốt hơn nhiều so với việc lặp lại `@Req() req` và đào sâu vào đối tượng request trong mỗi handler. **Custom metadata decorator** (`SetMetadata`) là nền tảng của các pattern phân quyền của NestJS: cách tiếp cận chuẩn `@Roles()` + `RolesGuard` (đọc qua `Reflector`) cho kiểm soát truy cập dựa trên role phụ thuộc hoàn toàn vào việc hiểu metadata decorator.

Và **kết hợp decorator** (`applyDecorators`) cho phép bạn gói các decorator liên quan (vd. một `@Auth()` áp dụng guard và metadata cùng nhau) để áp dụng súc tích, nhất quán.

Hiểu cách tạo những thứ này là điều cho phép bạn xây dựng các API NestJS biểu cảm, thành ngữ và triển khai các pattern phổ biến (inject user hiện tại, RBAC) theo cách framework dự định.

Nó nâng bạn từ chỉ dùng các decorator tích hợp lên mở rộng phong cách khai báo của framework cho nhu cầu của ứng dụng riêng — một kỹ năng giá trị, thường được áp dụng trong các dự án NestJS thực tế.