타입 안전한 i18n — 번역 키를 타입으로 보장하기

// 일반적인 i18n — 문자열 키로 접근
function t(key: string): string {
  return translations[key] ?? key;
}

t('greeting');      // OK
t('greating');      // ⚠️ 오타인데 에러 없음! 런타임에 키가 그대로 표시됨

// translations/ko.ts
const ko = {
  common: {
    greeting: '안녕하세요, {{name}}님!',
    confirm: '확인',
    cancel: '취소',
  },
  auth: {
    login: '로그인',
    logout: '로그아웃',
    welcome: '{{name}}님, 환영합니다!',
  },
  errors: {
    notFound: '{{resource}}을(를) 찾을 수 없습니다',
    serverError: '서버 오류가 발생했습니다',
  },
} as const;

export type Translations = typeof ko;
export default ko;

// 중첩 객체의 모든 경로를 점 표기법으로 추출
type DotPath<T, Prefix extends string = ''> = T extends object
  ? {
      [K in keyof T & string]: T[K] extends object
        ? DotPath<T[K], `${Prefix}${K}.`>
        : `${Prefix}${K}`;
    }[keyof T & string]
  : never;

type TranslationKey = DotPath<Translations>;
// 'common.greeting' | 'common.confirm' | 'common.cancel' |
// 'auth.login' | 'auth.logout' | 'auth.welcome' |
// 'errors.notFound' | 'errors.serverError'

// 점 경로로 값의 타입을 가져오기
type GetByPath<T, Path extends string> =
  Path extends `${infer Key}.${infer Rest}`
    ? Key extends keyof T
      ? GetByPath<T[Key], Rest>
      : never
    : Path extends keyof T
      ? T[Path]
      : never;

// 보간 변수 추출 ({{name}} 패턴)
type ExtractInterpolations<S extends string> =
  S extends `${string}{{${infer Var}}}${infer Rest}`
    ? Var | ExtractInterpolations<Rest>
    : never;

// 타입 안전한 t 함수
function t<K extends TranslationKey>(
  key: K,
  ...args: ExtractInterpolations<GetByPath<Translations, K> & string> extends never
    ? []
    : [params: Record<ExtractInterpolations<GetByPath<Translations, K> & string>, string>]
): string {
  // 구현 (경로 탐색 + 보간 치환)
  return '';
}

// ✅ 타입 안전한 사용
t('common.confirm');                              // 보간 변수 없음 — params 불필요
t('common.greeting', { name: '홍길동' });          // name이 필수
t('errors.notFound', { resource: '사용자' });       // resource가 필수

// ❌ 컴파일 에러
// t('common.greating');                           // 오타 — Error
// t('common.greeting');                           // name 누락 — Error
// t('common.greeting', { nama: '홍길동' });        // 오타 — Error

// next-intl 예시
import { useTranslations } from 'next-intl';

// 네임스페이스별 타입
type Messages = typeof import('../messages/ko.json');

declare module 'next-intl' {
  interface IntlMessages extends Messages {}
}

// 사용 — 타입 안전
function Component() {
  const t = useTranslations('common');
  return <p>{t('greeting', { name: '홍길동' })}</p>;
  // ✅ 키와 보간 변수가 타입 체크됨
}

// 모든 언어가 같은 키를 가지고 있는지 검증
type ValidateTranslations<
  Base extends Record<string, any>,
  Target extends Record<string, any>
> = {
  [K in keyof Base]: K extends keyof Target
    ? Base[K] extends Record<string, any>
      ? Target[K] extends Record<string, any>
        ? ValidateTranslations<Base[K], Target[K]>
        : never // 구조 불일치
      : Target[K] extends string
        ? true
        : never
    : never; // 키 누락
};

// 한국어 기준으로 영어 번역 검증
const en = {
  common: {
    greeting: 'Hello, {{name}}!',
    confirm: 'Confirm',
    cancel: 'Cancel',
  },
  auth: {
    login: 'Login',
    logout: 'Logout',
    welcome: 'Welcome, {{name}}!',
  },
  errors: {
    notFound: '{{resource}} not found',
    serverError: 'Server error occurred',
  },
} as const satisfies Record<keyof Translations, any>;