TypeScript any 타입 완벽 제거 실전 가이드: 타입 안정성 200% 높이는 검증된 전략

// ❌ any로 인한 실제 버그 사례

interface UserResponse {
  id: number
  name: string
  email: string
  createdAt: string
}

// 문제 1: API 응답을 any로 처리
async function fetchUser(userId: number): Promise<any> {
  const response = await fetch(`/api/users/${userId}`)
  return response.json()
}

// 문제 2: any 타입이기 때문에 오타를 잡지 못함
async function displayUserInfo() {
  const user = await fetchUser(123)

  // 실제로는 createdAt인데 createAt으로 오타
  console.log(user.createAt) // undefined 반환, 에러 없음!

  // name이 string이지만 숫자 메서드 호출 가능
  console.log(user.name.toFixed(2)) // 런타임 에러!

  // 존재하지 않는 프로퍼티 접근
  console.log(user.address.city) // 런타임 에러!
}

// 결과: 컴파일 성공, 런타임 크래시!

// ESLint 설정으로 any 사용 추적
// .eslintrc.json

{
  "rules": {
    "@typescript-eslint/no-explicit-any": "warn", // 명시적 any 경고
    "@typescript-eslint/no-unsafe-assignment": "warn", // any 할당 경고
    "@typescript-eslint/no-unsafe-member-access": "warn", // any 멤버 접근 경고
    "@typescript-eslint/no-unsafe-call": "warn", // any 함수 호출 경고
    "@typescript-eslint/no-unsafe-return": "warn" // any 반환 경고
  }
}

// tsconfig.json에서 strict 모드 활성화
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true, // 암묵적 any 금지
    "strictNullChecks": true
  }
}

// 커스텀 스크립트로 any 개수 세기
// count-any.ts
import * as ts from 'typescript'
import * as fs from 'fs'
import * as path from 'path'

interface AnyUsage {
  file: string
  line: number
  type: 'explicit' | 'implicit'
}

function findAnyUsages(sourceFile: ts.SourceFile): AnyUsage[] {
  const usages: AnyUsage[] = []

  function visit(node: ts.Node) {
    // any 타입 어노테이션 찾기
    if (ts.isTypeReferenceNode(node) && node.typeName.getText() === 'any') {
      const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart())
      usages.push({
        file: sourceFile.fileName,
        line: line + 1,
        type: 'explicit'
      })
    }

    ts.forEachChild(node, visit)
  }

  visit(sourceFile)
  return usages
}

// 사용 예시
const fileName = 'src/app.ts'
const sourceCode = fs.readFileSync(fileName, 'utf-8')
const sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest)
const anyUsages = findAnyUsages(sourceFile)

console.log(`총 ${anyUsages.length}개의 any 타입 발견`)
anyUsages.forEach(usage => {
  console.log(`${usage.file}:${usage.line} - ${usage.type}`)
})

// any 위험도 평가 기준

/**
 * 🔴 높은 우선순위 (즉시 수정)
 * - API 응답 타입
 * - 전역 상태 관리
 * - 공용 유틸리티 함수
 */
interface HighPriority {
  category: 'api' | 'state' | 'util'
  riskLevel: 'critical'
  examples: string[]
}

const highPriorityAny: HighPriority = {
  category: 'api',
  riskLevel: 'critical',
  examples: [
    'API 응답 데이터',
    '전역 상태 객체',
    '여러 곳에서 사용되는 유틸 함수'
  ]
}

/**
 * 🟡 중간 우선순위 (단계적 수정)
 * - 컴포넌트 props
 * - 이벤트 핸들러
 * - 내부 헬퍼 함수
 */

/**
 * 🟢 낮은 우선순위 (시간될 때 수정)
 * - 테스트 코드의 모킹
 * - 임시 스크립트
 * - 한 번만 사용되는 코드
 */

// 실제 우선순위 결정 프로세스
function prioritizeAnyFixes(anyLocations: AnyUsage[]): AnyUsage[] {
  return anyLocations.sort((a, b) => {
    // API 관련 파일이 가장 높은 우선순위
    if (a.file.includes('/api/')) return -1
    if (b.file.includes('/api/')) return 1

    // 전역 상태 관련 두 번째 우선순위
    if (a.file.includes('/store/')) return -1
    if (b.file.includes('/store/')) return 1

    // 공용 유틸 세 번째 우선순위
    if (a.file.includes('/utils/')) return -1
    if (b.file.includes('/utils/')) return 1

    return 0
  })
}

// any vs unknown 비교

// ❌ any: 모든 것을 허용 (위험)
function processDataBad(data: any) {
  console.log(data.name.toUpperCase()) // 타입 체크 없음
  console.log(data.age + 1) // 타입 체크 없음
  return data.something.nested.value // 런타임 에러 가능
}

// ✅ unknown: 타입 검증 후 사용 (안전)
function processDataGood(data: unknown) {
  // 타입 가드로 안전하게 검증
  if (typeof data === 'object' && data !== null && 'name' in data) {
    const obj = data as { name: string }
    console.log(obj.name.toUpperCase())
  }

  // 직접 사용 시도 시 컴파일 에러
  // console.log(data.name) // ❌ 에러: Object is of type 'unknown'
}

// 실무 예제: API 응답 처리
interface User {
  id: number
  name: string
  email: string
}

// ❌ any 사용
async function fetchUserBad(id: number): Promise<any> {
  const response = await fetch(`/api/users/${id}`)
  return response.json() // any 반환
}

// ✅ unknown + 타입 가드 조합
async function fetchUserGood(id: number): Promise<User> {
  const response = await fetch(`/api/users/${id}`)
  const data: unknown = await response.json()

  // 런타임 타입 검증
  if (!isUser(data)) {
    throw new Error('Invalid user data')
  }

  return data // 이제 User 타입
}

// 타입 가드 함수
function isUser(data: unknown): data is User {
  return (
    typeof data === 'object' &&
    data !== null &&
    'id' in data &&
    'name' in data &&
    'email' in data &&
    typeof (data as User).id === 'number' &&
    typeof (data as User).name === 'string' &&
    typeof (data as User).email === 'string'
  )
}

// 실무에서 자주 사용하는 패턴

// ✅ 타입 안전한 JSON 파싱 유틸리티
function parseJSON<T>(
  jsonString: string,
  validator: (data: unknown) => data is T
): T {
  try {
    const data: unknown = JSON.parse(jsonString)

    if (!validator(data)) {
      throw new Error('Invalid JSON structure')
    }

    return data
  } catch (error) {
    throw new Error(`JSON parsing failed: ${error}`)
  }
}

// 사용 예시
interface Config {
  apiUrl: string
  timeout: number
  retries: number
}

function isConfig(data: unknown): data is Config {
  return (
    typeof data === 'object' &&
    data !== null &&
    'apiUrl' in data &&
    'timeout' in data &&
    'retries' in data &&
    typeof (data as Config).apiUrl === 'string' &&
    typeof (data as Config).timeout === 'number' &&
    typeof (data as Config).retries === 'number'
  )
}

const configString = '{"apiUrl":"https://api.example.com","timeout":5000,"retries":3}'
const config = parseJSON(configString, isConfig)

console.log(config.apiUrl) // 타입 안전!
console.log(config.timeout.toFixed(0)) // 타입 안전!

// 잘못된 데이터는 에러 발생
const badString = '{"apiUrl":123}' // apiUrl이 숫자
// const badConfig = parseJSON(badString, isConfig) // 에러 발생

// localStorage는 항상 unknown으로 처리

// ❌ any 사용 (위험)
function getStoredDataBad<T>(key: string): T {
  const data = localStorage.getItem(key)
  return data ? JSON.parse(data) : null // any 반환
}

// ✅ unknown + 타입 가드 (안전)
function getStoredData<T>(
  key: string,
  validator: (data: unknown) => data is T
): T | null {
  const item = localStorage.getItem(key)

  if (!item) {
    return null
  }

  try {
    const data: unknown = JSON.parse(item)

    if (!validator(data)) {
      console.warn(`Invalid data for key: ${key}`)
      return null
    }

    return data
  } catch (error) {
    console.error(`Failed to parse stored data: ${error}`)
    return null
  }
}

// 사용 예시
interface UserPreferences {
  theme: 'light' | 'dark'
  language: string
  notifications: boolean
}

function isUserPreferences(data: unknown): data is UserPreferences {
  return (
    typeof data === 'object' &&
    data !== null &&
    'theme' in data &&
    'language' in data &&
    'notifications' in data &&
    ((data as UserPreferences).theme === 'light' ||
     (data as UserPreferences).theme === 'dark') &&
    typeof (data as UserPreferences).language === 'string' &&
    typeof (data as UserPreferences).notifications === 'boolean'
  )
}

// 타입 안전하게 localStorage 사용
const preferences = getStoredData('userPreferences', isUserPreferences)

if (preferences) {
  console.log(preferences.theme) // 'light' | 'dark' 타입
  console.log(preferences.notifications) // boolean 타입
}

// ❌ any를 사용한 범용 함수
function getFirstElementBad(arr: any[]): any {
  return arr[0]
}

const num = getFirstElementBad([1, 2, 3]) // any 반환
const str = getFirstElementBad(['a', 'b']) // any 반환

// 타입 안정성 상실
console.log(num.toFixed(2)) // 런타임에서만 확인 가능
console.log(str.toUpperCase()) // 런타임에서만 확인 가능

// ✅ 제네릭 사용
function getFirstElement<T>(arr: T[]): T | undefined {
  return arr[0]
}

const numResult = getFirstElement([1, 2, 3]) // number | undefined
const strResult = getFirstElement(['a', 'b']) // string | undefined

// 타입 안정성 확보
if (numResult !== undefined) {
  console.log(numResult.toFixed(2)) // ✅ 안전
}

if (strResult !== undefined) {
  console.log(strResult.toUpperCase()) // ✅ 안전
}

// 실무에서 가장 많이 사용하는 패턴

// ✅ 타입 안전한 API 클라이언트
interface ApiResponse<T> {
  data: T
  status: number
  message: string
}

class ApiClient {
  // ❌ any 사용 (이전 방식)
  async fetchBad(url: string): Promise<any> {
    const response = await fetch(url)
    return response.json()
  }

  // ✅ 제네릭 + 타입 가드 (개선)
  async fetch<T>(
    url: string,
    validator: (data: unknown) => data is T
  ): Promise<ApiResponse<T>> {
    const response = await fetch(url)
    const data: unknown = await response.json()

    if (!validator(data)) {
      throw new Error('Invalid API response')
    }

    return {
      data,
      status: response.status,
      message: 'Success'
    }
  }
}

// 사용 예시
interface Product {
  id: number
  name: string
  price: number
}

function isProduct(data: unknown): data is Product {
  return (
    typeof data === 'object' &&
    data !== null &&
    'id' in data &&
    'name' in data &&
    'price' in data &&
    typeof (data as Product).id === 'number' &&
    typeof (data as Product).name === 'string' &&
    typeof (data as Product).price === 'number'
  )
}

const apiClient = new ApiClient()

async function loadProduct(id: number) {
  const response = await apiClient.fetch<Product>(
    `/api/products/${id}`,
    isProduct
  )

  console.log(response.data.name) // 타입 안전!
  console.log(response.data.price.toFixed(2)) // 타입 안전!
}

// 제네릭 제약으로 더 정교한 타입 제어

// ❌ any로 객체 복사 (위험)
function cloneBad(obj: any): any {
  return { ...obj }
}

// ✅ 제네릭 제약으로 안전한 객체 복사
function clone<T extends object>(obj: T): T {
  return { ...obj }
}

const user = { id: 1, name: 'Alice' }
const clonedUser = clone(user) // { id: number, name: string }

// 원시값은 에러
// const num = clone(123) // ❌ 에러: number는 object가 아님

// 실무 예제: 특정 키를 가진 객체만 허용
interface HasId {
  id: number | string
}

function findById<T extends HasId>(
  items: T[],
  id: number | string
): T | undefined {
  return items.find(item => item.id === id)
}

// 사용 가능
const users = [
  { id: 1, name: 'Alice', email: 'alice@example.com' },
  { id: 2, name: 'Bob', email: 'bob@example.com' }
]

const found = findById(users, 1) // 타입 추론됨

// id가 없는 배열은 에러
const numbers = [1, 2, 3]
// const num = findById(numbers, 1) // ❌ 에러

// 실무에서 강력한 패턴

// ❌ any를 사용한 부분 업데이트
function updateUserBad(user: any, updates: any): any {
  return { ...user, ...updates }
}

// ✅ Partial과 제네릭 활용
function updateUser<T extends object>(
  user: T,
  updates: Partial<T>
): T {
  return { ...user, ...updates }
}

interface User {
  id: number
  name: string
  email: string
  age: number
}

const user: User = {
  id: 1,
  name: 'Alice',
  email: 'alice@example.com',
  age: 30
}

// 일부 필드만 업데이트
const updated = updateUser(user, { age: 31 }) // User 타입 유지

// 존재하지 않는 필드는 에러
// const bad = updateUser(user, { unknown: 'field' }) // ❌ 에러

// 고급 패턴: Pick과 제네릭
function selectFields<T, K extends keyof T>(
  obj: T,
  keys: K[]
): Pick<T, K> {
  const result = {} as Pick<T, K>

  keys.forEach(key => {
    result[key] = obj[key]
  })

  return result
}

// 사용 예시
const userBasicInfo = selectFields(user, ['id', 'name'])
// { id: number, name: string } 타입

console.log(userBasicInfo.id) // ✅ 안전
console.log(userBasicInfo.name) // ✅ 안전
// console.log(userBasicInfo.email) // ❌ 에러: email은 없음

// typeof 타입 가드
function processValue(value: unknown) {
  if (typeof value === 'string') {
    console.log(value.toUpperCase()) // string으로 추론
  } else if (typeof value === 'number') {
    console.log(value.toFixed(2)) // number로 추론
  } else if (typeof value === 'boolean') {
    console.log(value ? 'true' : 'false') // boolean으로 추론
  }
}

// instanceof 타입 가드
class CustomError extends Error {
  constructor(
    message: string,
    public code: number
  ) {
    super(message)
  }
}

function handleError(error: unknown) {
  if (error instanceof CustomError) {
    console.log(`Error code: ${error.code}`) // CustomError로 추론
    console.log(`Message: ${error.message}`)
  } else if (error instanceof Error) {
    console.log(`Error: ${error.message}`) // Error로 추론
  } else {
    console.log('Unknown error')
  }
}

// in 연산자 타입 가드
interface Dog {
  bark(): void
}

interface Cat {
  meow(): void
}

function makeSound(animal: Dog | Cat) {
  if ('bark' in animal) {
    animal.bark() // Dog로 추론
  } else {
    animal.meow() // Cat으로 추론
  }
}

// 실무에서 가장 강력한 패턴

// ✅ 복잡한 객체 검증
interface ApiUser {
  id: number
  username: string
  email: string
  profile: {
    age: number
    bio: string
  }
}

function isApiUser(data: unknown): data is ApiUser {
  if (typeof data !== 'object' || data === null) {
    return false
  }

  const obj = data as Record<string, unknown>

  return (
    typeof obj.id === 'number' &&
    typeof obj.username === 'string' &&
    typeof obj.email === 'string' &&
    typeof obj.profile === 'object' &&
    obj.profile !== null &&
    typeof (obj.profile as Record<string, unknown>).age === 'number' &&
    typeof (obj.profile as Record<string, unknown>).bio === 'string'
  )
}

// 사용 예시
async function fetchUser(id: number): Promise<ApiUser> {
  const response = await fetch(`/api/users/${id}`)
  const data: unknown = await response.json()

  if (!isApiUser(data)) {
    throw new Error('Invalid user data from API')
  }

  return data // ApiUser 타입으로 안전하게 반환
}

// ✅ 배열 타입 가드
function isStringArray(value: unknown): value is string[] {
  return (
    Array.isArray(value) &&
    value.every(item => typeof item === 'string')
  )
}

function processArray(data: unknown) {
  if (isStringArray(data)) {
    data.forEach(str => console.log(str.toUpperCase())) // string[] 타입
  }
}

import { z } from 'zod'

// ✅ Zod 스키마로 런타임 검증 + 타입 추론
const UserSchema = z.object({
  id: z.number(),
  username: z.string().min(3).max(20),
  email: z.string().email(),
  age: z.number().min(0).max(150).optional(),
  profile: z.object({
    bio: z.string().max(500),
    avatarUrl: z.string().url()
  })
})

type User = z.infer<typeof UserSchema>

// API 응답 검증
async function fetchUserWithZod(id: number): Promise<User> {
  const response = await fetch(`/api/users/${id}`)
  const data: unknown = await response.json()

  // Zod로 검증 (에러 발생 시 자동으로 throw)
  const user = UserSchema.parse(data)

  return user // User 타입으로 안전하게 반환
}

// 안전한 검증 (에러를 반환값으로 처리)
function safeParseUser(data: unknown): User | null {
  const result = UserSchema.safeParse(data)

  if (result.success) {
    return result.data
  } else {
    console.error('Validation errors:', result.error.errors)
    return null
  }
}

// 실무 예제: 폼 데이터 검증
const LoginFormSchema = z.object({
  email: z.string().email('유효한 이메일을 입력하세요'),
  password: z.string().min(8, '비밀번호는 8자 이상이어야 합니다')
})

type LoginForm = z.infer<typeof LoginFormSchema>

function validateLoginForm(formData: unknown): LoginForm {
  return LoginFormSchema.parse(formData)
}

// ❌ Before: any 남발 (위험한 코드)
class ProductService {
  async getProducts(): Promise<any> {
    const response = await fetch('/api/products')
    return response.json()
  }

  async getProduct(id: number): Promise<any> {
    const response = await fetch(`/api/products/${id}`)
    return response.json()
  }

  async createProduct(data: any): Promise<any> {
    const response = await fetch('/api/products', {
      method: 'POST',
      body: JSON.stringify(data)
    })
    return response.json()
  }
}

// ✅ After: 타입 안전성 확보
import { z } from 'zod'

// Zod 스키마 정의
const ProductSchema = z.object({
  id: z.number(),
  name: z.string().min(1).max(100),
  price: z.number().positive(),
  category: z.enum(['electronics', 'clothing', 'food', 'other']),
  inStock: z.boolean(),
  createdAt: z.string().datetime()
})

const ProductsResponseSchema = z.object({
  products: z.array(ProductSchema),
  total: z.number(),
  page: z.number()
})

const CreateProductSchema = ProductSchema.omit({
  id: true,
  createdAt: true
})

type Product = z.infer<typeof ProductSchema>
type ProductsResponse = z.infer<typeof ProductsResponseSchema>
type CreateProductData = z.infer<typeof CreateProductSchema>

class ProductServiceTyped {
  private async fetchJSON<T>(
    url: string,
    schema: z.ZodType<T>,
    options?: RequestInit
  ): Promise<T> {
    const response = await fetch(url, options)

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`)
    }

    const data: unknown = await response.json()

    // Zod로 검증
    return schema.parse(data)
  }

  async getProducts(page: number = 1): Promise<ProductsResponse> {
    return this.fetchJSON(
      `/api/products?page=${page}`,
      ProductsResponseSchema
    )
  }

  async getProduct(id: number): Promise<Product> {
    return this.fetchJSON(
      `/api/products/${id}`,
      ProductSchema
    )
  }

  async createProduct(data: CreateProductData): Promise<Product> {
    // 입력 데이터 검증
    const validatedData = CreateProductSchema.parse(data)

    return this.fetchJSON(
      '/api/products',
      ProductSchema,
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(validatedData)
      }
    )
  }
}

// 리팩토링 결과 비교
const results = {
  before: {
    typeErrors: 0, // any라서 컴파일 에러 없음
    runtimeErrors: 15, // 런타임에서 발견된 에러
    developmentTime: '3일'
  },
  after: {
    typeErrors: 12, // 컴파일 타임에 발견
    runtimeErrors: 0, // 런타임 에러 0개
    developmentTime: '1.5일' // 개발 시간 50% 감소
  }
}

// ❌ Before: any 이벤트 타입
function setupEventListeners() {
  document.getElementById('submit')?.addEventListener('click', (e: any) => {
    e.preventDefault()
    const form = e.target.form // any 타입
    const data = new FormData(form)
    // 타입 안정성 없음
  })

  document.getElementById('input')?.addEventListener('change', (e: any) => {
    const value = e.target.value // any 타입
    console.log(value.toUpperCase()) // 런타임 에러 가능
  })
}

// ✅ After: 정확한 이벤트 타입
function setupTypedEventListeners() {
  const submitButton = document.getElementById('submit')

  if (submitButton) {
    submitButton.addEventListener('click', (e: MouseEvent) => {
      e.preventDefault()

      const target = e.currentTarget as HTMLButtonElement
      const form = target.form

      if (form instanceof HTMLFormElement) {
        const formData = new FormData(form)
        handleFormSubmit(formData)
      }
    })
  }

  const inputElement = document.getElementById('input')

  if (inputElement instanceof HTMLInputElement) {
    inputElement.addEventListener('change', (e: Event) => {
      const target = e.target

      if (target instanceof HTMLInputElement) {
        const value = target.value // string 타입
        console.log(value.toUpperCase()) // 안전!
      }
    })
  }
}

// 타입 안전한 폼 핸들러
interface FormValues {
  username: string
  email: string
  age: number
}

function handleFormSubmit(formData: FormData): void {
  const values: Partial<FormValues> = {}

  const username = formData.get('username')
  if (typeof username === 'string') {
    values.username = username
  }

  const email = formData.get('email')
  if (typeof email === 'string') {
    values.email = email
  }

  const ageStr = formData.get('age')
  if (typeof ageStr === 'string') {
    const age = parseInt(ageStr, 10)
    if (!isNaN(age)) {
      values.age = age
    }
  }

  // 모든 필드가 있는지 확인
  if (isFormValues(values)) {
    submitForm(values)
  } else {
    console.error('Invalid form data')
  }
}

function isFormValues(obj: Partial<FormValues>): obj is FormValues {
  return (
    typeof obj.username === 'string' &&
    typeof obj.email === 'string' &&
    typeof obj.age === 'number'
  )
}

function submitForm(values: FormValues): void {
  console.log('Submitting:', values)
  // API 호출 등
}

// .eslintrc.json - 엄격한 any 금지 설정

{
  "parser": "@typescript-eslint/parser",
  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended",
    "plugin:@typescript-eslint/recommended-requiring-type-checking"
  ],
  "parserOptions": {
    "project": "./tsconfig.json"
  },
  "rules": {
    // any 관련 규칙 (모두 error로 설정)
    "@typescript-eslint/no-explicit-any": "error",
    "@typescript-eslint/no-unsafe-assignment": "error",
    "@typescript-eslint/no-unsafe-member-access": "error",
    "@typescript-eslint/no-unsafe-call": "error",
    "@typescript-eslint/no-unsafe-return": "error",
    "@typescript-eslint/no-unsafe-argument": "error",

    // 암묵적 any 방지
    "@typescript-eslint/no-implicit-any-catch": "error",

    // unknown 사용 권장
    "@typescript-eslint/prefer-unknown-over-any": "warn"
  }
}

// tsconfig.json - 엄격한 컴파일러 옵션
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": true,
    "noImplicitThis": true,
    "alwaysStrict": true
  }
}

# .husky/pre-commit

#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

# TypeScript 타입 체크
npm run type-check

# ESLint로 any 검사
npm run lint

# any 개수 확인 스크립트 실행
node scripts/check-any-usage.js

// scripts/check-any-usage.js

const { execSync } = require('child_process')

try {
  const output = execSync(
    'grep -r ":\\s*any" src/ --include="*.ts" --include="*.tsx" | wc -l',
    { encoding: 'utf-8' }
  )

  const anyCount = parseInt(output.trim(), 10)

  if (anyCount > 0) {
    console.error(`❌ ${anyCount}개의 any 타입이 발견되었습니다!`)
    console.error('any 타입을 제거한 후 커밋하세요.')
    process.exit(1)
  }

  console.log('✅ any 타입이 없습니다!')
  process.exit(0)
} catch (error) {
  console.error('any 검사 중 오류 발생:', error)
  process.exit(1)
}

# .github/workflows/type-check.yml

name: TypeScript Type Check

on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main, develop]

jobs:
  type-check:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install dependencies
        run: npm ci

      - name: TypeScript 타입 체크
        run: npm run type-check

      - name: ESLint 검사 (any 금지)
        run: npm run lint

      - name: any 사용 검증
        run: |
          ANY_COUNT=$(grep -r ": any" src/ --include="*.ts" --include="*.tsx" | wc -l)
          if [ $ANY_COUNT -gt 0 ]; then
            echo "❌ $ANY_COUNT개의 any 타입 발견!"
            exit 1
          fi
          echo "✅ any 타입 없음"