ES2024 데코레이터로 TS 타입추론 깨질 때

function Log(_value: Function, _context: ClassMethodDecoratorContext) {
  return function (...args: any[]) {
    console.log("call", args);
    // 원래 메서드 호출을 빼먹은 예시(문제 재현용)
  };
}

class Api {
  // 오버로드
  fetch(id: number): Promise<string>;
  fetch(id: string): Promise<number>;
  @Log
  fetch(id: number | string) {
    return typeof id === "number" ? Promise.resolve("ok") : Promise.resolve(123);
  }
}

const api = new Api();
// 기대: api.fetch(1) 은 Promise<string>
// 현실: 데코레이터로 인해 타입이 넓어지거나 any처럼 보일 수 있음

type AnyFn = (this: any, ...args: any[]) => any;

function wrapMethod<T extends AnyFn>(
  original: T,
  wrapper: (original: T) => T
): T {
  return wrapper(original);
}

function Log<T extends AnyFn>(value: T, _context: ClassMethodDecoratorContext): T {
  return wrapMethod(value, (original) => {
    const wrapped = function (this: ThisParameterType<T>, ...args: Parameters<T>) {
      console.log("call", args);
      return original.apply(this, args);
    } as T;

    return wrapped;
  });
}

class Api {
  fetch(id: number): Promise<string>;
  fetch(id: string): Promise<number>;
  @Log
  fetch(id: number | string) {
    return typeof id === "number" ? Promise.resolve("ok") : Promise.resolve(123);
  }
}

const api = new Api();
const a = api.fetch(1);      // Promise<string>
const b = api.fetch("x");    // Promise<number>

function Time(value: Function, _context: ClassMethodDecoratorContext) {
  return function (...args: any[]) {
    const t0 = performance.now();
    const r = value.apply(this, args);
    console.log(performance.now() - t0);
    return r;
  };
}

class Builder {
  private v = 0;

  @Time
  add(n: number) {
    this.v += n;
    return this;
  }

  build() {
    return this.v;
  }
}

new Builder().add(1).add(2).build();
// 데코레이터 적용 후 add() 체이닝 타입이 흔들릴 수 있음

type Method<TThis, TArgs extends any[], TReturn> = (this: TThis, ...args: TArgs) => TReturn;

function Time<TThis, TArgs extends any[], TReturn>(
  value: Method<TThis, TArgs, TReturn>,
  _context: ClassMethodDecoratorContext
): Method<TThis, TArgs, TReturn> {
  return function (this: TThis, ...args: TArgs) {
    const t0 = performance.now();
    const r = value.apply(this, args);
    console.log(performance.now() - t0);
    return r;
  };
}

type Accessor<TThis, TValue> = {
  get(this: TThis): TValue;
  set(this: TThis, v: TValue): void;
};

function ClampNumber<TThis>(
  value: Accessor<TThis, number>,
  _context: ClassAccessorDecoratorContext
): Accessor<TThis, number> {
  return {
    get() {
      return value.get.call(this);
    },
    set(v) {
      value.set.call(this, Math.max(0, Math.min(100, v)));
    },
  };
}

class Model {
  accessor score = 0;

  @ClampNumber
  accessor rating = 0;
}

interface Cache {
  get(key: string): string | undefined;
}

class MemoryCache implements Cache {
  private m = new Map<string, string>();
  get(key: string) {
    return this.m.get(key);
  }
}

// 런타임에 주입되는 값이 Cache 계약을 만족해야 함
const defaultCache = new MemoryCache() satisfies Cache;

function Inject(_value: undefined, context: ClassFieldDecoratorContext) {
  context.addInitializer(function () {
    // 여기서 (this as any)[context.name] 에 프록시/구현체 주입한다고 가정
  });
}

class Service {
  @Inject
  cache!: Cache; // 구현체가 아니라 계약으로 선언
}

type AnyFn = (this: any, ...args: any[]) => any;

export function makeMethodDecorator(
  wrap: <T extends AnyFn>(original: T, name: string | symbol) => T
) {
  return function <T extends AnyFn>(
    value: T,
    context: ClassMethodDecoratorContext
  ): T {
    return wrap(value, context.name);
  };
}

export const Trace = makeMethodDecorator((original, name) => {
  const wrapped = function (this: ThisParameterType<typeof original>, ...args: Parameters<typeof original>) {
    const t0 = Date.now();
    try {
      return original.apply(this, args);
    } finally {
      const dt = Date.now() - t0;
      console.log(`[trace] ${String(name)} ${dt}ms`);
    }
  } as typeof original;

  return wrapped;
});

class UserService {
  @Trace
  findUser(id: string) {
    return { id };
  }
}