ES2024 Records & Tuples로 TS 타입추론 극대화

// 의도: 깊은 불변 + 값 동등성을 갖는 키
// (현 시점에서는 TS/런타임에서 동일 모델을 유틸로 대체)

type QueryKey = readonly unknown[];

function makeQueryKey<const T extends QueryKey>(...parts: T) {
  return parts;
}

const key1 = makeQueryKey("user", { id: 1 });
//    ^? readonly ["user", { readonly id: 1 }]

const key2 = makeQueryKey("user", { id: 1 });

// 현재 JS에서는 key1 !== key2 (참조 다름)
// Records & Tuples가 제공하려는 모델에서는 값 동등성으로 같게 취급 가능

type Fetcher<K extends QueryKey, R> = (key: K) => Promise<R>;

function createQuery<K extends QueryKey, R>(key: K, fetcher: Fetcher<K, R>) {
  return { key, fetcher };
}

const q = createQuery(
  makeQueryKey("user", { id: 1 }),
  async (key) => {
    // key[0]은 "user"로, key[1].id는 1로 리터럴 추론 가능
    const [, params] = key;
    return { name: "Alice", id: params.id };
  }
);

function stableStringify(value: unknown): string {
  // 매우 단순화된 예시. 실무에서는 순환 참조/정렬/타입 처리 필요
  return JSON.stringify(value, (_k, v) => {
    if (v && typeof v === "object" && !Array.isArray(v)) {
      return Object.keys(v as Record<string, unknown>)
        .sort()
        .reduce((acc, key) => {
          (acc as any)[key] = (v as any)[key];
          return acc;
        }, {} as Record<string, unknown>);
    }
    return v;
  });
}

function toCacheKey<const K extends QueryKey>(key: K): string {
  return stableStringify(key);
}

const cacheKey = toCacheKey(makeQueryKey("user", { id: 1 }));

type DeepReadonly<T> =
  T extends (...args: any[]) => any ? T :
  T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] :
  T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } :
  T;

function defineConfig<const T extends object>(cfg: T): DeepReadonly<T> {
  return cfg as any;
}

const config = defineConfig({
  retry: { max: 3, backoffMs: 200 },
  endpoint: "/api",
  features: ["a", "b"],
});

// config.retry.max = 4; // 타입 에러

type AppConfig = {
  endpoint: string;
  retry: { max: number; backoffMs: number };
  features: readonly string[];
};

const config2 = {
  endpoint: "/api",
  retry: { max: 3, backoffMs: 200 },
  features: ["a", "b"],
} satisfies AppConfig;

// config2.endpoint는 "/api" 리터럴로 유지될 수 있음

const events = {
  USER_SIGNED_IN: { name: "USER_SIGNED_IN", payload: { method: "password" as const } },
  ITEM_VIEWED: { name: "ITEM_VIEWED", payload: { itemId: 0 as number } },
} as const;

type EventName = keyof typeof events;

type EventOf<N extends EventName> = typeof events[N];

type AnyEvent = EventOf<EventName>;

function track<E extends AnyEvent>(event: E) {
  // event.name에 따라 payload 타입이 더 똑똑하게 유지되길 원함
}

track(events.USER_SIGNED_IN);

function makeEvent<N extends EventName>(name: N, payload: EventOf<N>["payload"]) {
  return { name, payload } as const;
}

const e1 = makeEvent("ITEM_VIEWED", { itemId: 123 });
// const e2 = makeEvent("ITEM_VIEWED", { itemId: "x" }); // 타입 에러

type Handler<Req, Res> = (req: Req) => Promise<Res>;

type Routes = {
  readonly [path: string]: {
    readonly method: "GET" | "POST";
    readonly handler: Handler<any, any>;
  };
};

const routes = {
  "/users": {
    method: "GET",
    handler: async () => [{ id: 1, name: "Alice" }],
  },
  "/users/create": {
    method: "POST",
    handler: async (_req: { name: string }) => ({ ok: true as const }),
  },
} as const satisfies Routes;

type Path = keyof typeof routes;

type RouteOf<P extends Path> = (typeof routes)[P];

type MethodOf<P extends Path> = RouteOf<P>["method"];

async function callApi<P extends Path>(path: P, method: MethodOf<P>) {
  const route = routes[path];
  if (route.method !== method) {
    throw new Error("Method mismatch");
  }
  return route.handler({});
}

callApi("/users", "GET");
// callApi("/users", "POST"); // 타입 단계에서 막히는 방향으로 설계 가능

function deepFreeze<T>(obj: T): T {
  if (!obj || typeof obj !== "object") return obj;
  Object.freeze(obj);
  for (const key of Object.keys(obj as any)) {
    deepFreeze((obj as any)[key]);
  }
  return obj;
}

type Json = null | boolean | number | string | Json[] | { [k: string]: Json };

function snapshot<const T extends Json>(value: T): DeepReadonly<T> {
  return deepFreeze(value) as any;
}

const input = snapshot({ filter: { q: "abc" }, page: 1 });