คุณสร้าง custom decorator อย่างไร?

Question

Accepted Answer

NestJS ให้คุณสร้าง **custom decorator** เพื่อห่อหุ้ม logic ที่นำกลับมาใช้ซ้ำได้ — ที่พบบ่อยที่สุดคือ **parameter decorator** (เพื่อดึงข้อมูลจาก request) และ **metadata decorator** (เพื่อแนบข้อมูลที่ guard/interceptor อ่าน) พวกมันทำให้โค้ดเป็น DRY และสื่อความหมาย

## Custom parameter decorator — ดึงข้อมูลจาก 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` สร้าง parameter decorator: ฟังก์ชันของมันรับ `ExecutionContext`, ดึงข้อมูล และส่งคืนค่าที่จะ inject สิ่งนี้แทนที่การเข้าถึง `@Req() req` + `req.user` ซ้ำ ๆ ด้วย `@CurrentUser()` ที่สะอาดและนำกลับมาใช้ซ้ำได้

## Parameter decorator พร้อม argument

```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 (ให้ guard/interceptor อ่าน)

```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` — metadata decorator ที่ guard อ่านผ่าน `Reflector` — เป็นรูปแบบมาตรฐานสำหรับ authorization ตาม role

## การ compose 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
```

## ทำไมจึงสำคัญ

การสร้าง custom decorator เป็นเทคนิคสำคัญของ NestJS สำหรับทำให้โค้ดเป็น DRY, สื่อความหมาย และดูแลรักษาง่าย **custom parameter decorator** (`createParamDecorator`) ให้คุณห่อหุ้มการดึงข้อมูลจาก request ที่พบบ่อย (เช่น `@CurrentUser()`) ให้เป็นคำกำกับที่สะอาดและนำกลับมาใช้ซ้ำได้ — ดีกว่าการเขียน `@Req() req` ซ้ำและขุดเข้าไปใน object ของ request ในทุก handler มาก **custom metadata decorator** (`SetMetadata`) เป็นรากฐานของรูปแบบ authorization ของ NestJS: แนวทางมาตรฐาน `@Roles()` + `RolesGuard` (อ่านผ่าน `Reflector`) สำหรับ role-based access control พึ่งพาการเข้าใจ metadata decorator ทั้งหมด

และการ **compose decorator** (`applyDecorators`) ให้คุณรวม decorator ที่เกี่ยวข้อง (เช่น `@Auth()` ที่ใช้ guard และ metadata ด้วยกัน) เพื่อการใช้งานที่กระชับและสม่ำเสมอ

การเข้าใจวิธีสร้างสิ่งเหล่านี้คือสิ่งที่ทำให้คุณสร้าง API NestJS ที่สื่อความหมายและตามแบบฉบับได้ และ implement รูปแบบที่พบบ่อย (การ inject current-user, RBAC) ในแบบที่เฟรมเวิร์กตั้งใจ

มันยกระดับคุณจากการเพียงใช้ decorator ในตัว ไปสู่การขยายสไตล์ declarative ของเฟรมเวิร์กให้ตรงกับความต้องการของแอปพลิเคชันของคุณเอง — ทักษะที่มีค่าและใช้บ่อยในโปรเจกต์ NestJS จริง