타입스크립트의 데코레이터

{
  "compilerOptions": {
    // ...
    "experimentalDecorators": true
  },
}

function AddTimestamp<T extends { new (...args: any[]): {} }>(constructor: T) {
  return class extends constructor {
    createdAt = new Date();
  };
}

@AddTimestamp
class Seat {
  constructor(private seatNumber: string, private isAvailable: boolean) {}
}

const seat = new Seat("123", true);

// Seat {
//   seatNumber: '123',
//   isAvailable: true,
//   createdAt: 2025-12-10T11:05:00.357Z
// }
console.log(seat);

interface PropertyDescriptor {
    configurable?: boolean;
    enumerable?: boolean;
    value?: any;
    writable?: boolean;
    get?(): any;
    set?(v: any): void;
}

function LogExecution(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  // 원본 메서드를 저장
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`[${new Date().toISOString()}] ${propertyKey} 호출, 인자:`, args);
    const result = originalMethod.apply(this, args);
    console.log(`[${new Date().toISOString()}] ${propertyKey} 완료, 결과:`, result);
    return result;
  };
}

class PaymentService {
  @LogExecution
  processPayment(userId: number, amount: number) {
    return { success: true, userId, amount };
  }
}

const service = new PaymentService();
const paymentResult = service.processPayment(1, 5000);
console.log(paymentResult);

// [2025-01-01T12:00:00.000Z] processPayment 호출, 인자: [1, 5000]
// [2025-01-01T12:00:00.000Z] processPayment 완료, 결과: { success: true, userId: 1, amount: 5000 }
// { success: true, userId: 1, amount: 5000 }

function ValidatePositive(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalSetter = descriptor.set;

  descriptor.set = function (value: number) {
    if (value < 0) {
      throw new Error(`${propertyKey}: 금액은 0 이상이어야 합니다`);
    }

    if (originalSetter) {
      originalSetter.call(this, value);
    }
  };
}

class SeatUsage {
  private _chargedAmount: number = 0;

  get chargedAmount() {
    return this._chargedAmount;
  }

  @ValidatePositive
  set chargedAmount(value: number) {
    this._chargedAmount = value;
  }
}

const usage = new SeatUsage();
console.log(usage); // SeatUsage { _chargedAmount: 0 }

usage.chargedAmount = 3000;
console.log(usage); // SeatUsage { _chargedAmount: 3000 }

usage.chargedAmount = -1000; // Error: chargedAmount: 금액은 0 이상이어야 합니다

const columnMetadata: Map<string, any> = new Map();

type ColumnOptions = {
  type: string;
  nullable?: boolean;
};

function Column(options: ColumnOptions) {
  return function (target: any, propertyKey: string) {
    const className = target.constructor.name;
    const key = `${className}.${propertyKey}`;
    columnMetadata.set(key, options);
  };
}

class Member {
  @Column({ type: "varchar", nullable: false })
  name: string;

  @Column({ type: "int", nullable: true })
  remainingTime: number;
}

console.log(columnMetadata.get("Member.name"));
// { type: 'varchar', nullable: false }
console.log(columnMetadata.get("Member.remainingTime"));
// { type: 'int', nullable: true }

const requiredParams: Map<string, number[]> = new Map();

function Required(target: any, propertyKey: string, parameterIndex: number) {
  const key = `${target.constructor.name}.${propertyKey}`;
  const indices = requiredParams.get(key) || [];
  indices.push(parameterIndex);
  requiredParams.set(key, indices);
}

function Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  const key = `${target.constructor.name}.${propertyKey}`;

  descriptor.value = function (...args: any[]) {
    const indices = requiredParams.get(key) || [];
    for (const index of indices) {
      if (!args[index]) {
        throw new Error(`매개변수 ${index}번은 필수입니다`);
      }
    }
    return originalMethod.apply(this, args);
  };
}

class SeatService {
  @Validate
  assignSeat(@Required seatNumber: number, @Required memberId: number) {
    return { seatNumber, memberId };
  }
}

const seatService = new SeatService();
seatService.assignSeat(1, 100);

// @ts-ignore
seatService.assignSeat(1, undefined); // Error: 매개변수 1번은 필수입니다

/**
 * 일반 데코레이터 방식으로 파라미터를 직접 받을 수 없음
 */
function SimpleLog(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  console.log(`${propertyKey} 정의됨`);
}

/**
 * 데코레이터 팩토리로 인자를 받을 수 있음
 */
function Route(path: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    if (!target.constructor.routes) {
      target.constructor.routes = [];
    }

    target.constructor.routes.push({ path, method: propertyKey });
  };
}

class SeatController {
  @Route("/seats")
  getAllSeats() {
    return [];
  }

  @Route("/seats/:id")
  getSeatById(id: number) {
    return { id };
  }
}

console.log((SeatController as any).routes);
// [{ path: '/seats', method: 'getAllSeats' }, { path: '/seats/:id', method: 'getSeatById' }]

function First() {
  console.log("First 평가");
  return function (target: any, key: string, desc: PropertyDescriptor) {
    console.log("First 실행");
  };
}

function Second() {
  console.log("Second 평가");
  return function (target: any, key: string, desc: PropertyDescriptor) {
    console.log("Second 실행");
  };
}

class SeatReservationService {
  @First()
  @Second()
  createOrder() {}
}

// 출력:
// First 평가
// Second 평가
// Second 실행
// First 실행