저장 데이터 마이그레이션: 이전 앱의 JSON을 새 앱은 어떻게 읽는가

raw 문자열 읽기
→ JSON 파싱
→ 출발 버전 구조 검사
→ 한 단계 변환
→ 현재 버전 구조 재검사
→ 현재 형식 저장

{
  "version": 1,
  "note": "현관 앞에 놓아주세요",
  "total": 12900
}

import { useState } from 'react'
import { Pressable, Text, View } from 'react-native'
import { createAsyncStorage } from '@react-native-async-storage/async-storage'
 
type DraftV2 = {
  version: 2
  deliveryNote: string
  total: {
    amount: number
    currency: 'KRW'
  }
}
 
const draftStorage = createAsyncStorage('delivery-draft')
const DRAFT_KEY = 'delivery-note'
const V1_RAW = JSON.stringify({
  version: 1,
  note: '현관 앞에 놓아주세요',
  total: 12900,
})
 
async function loadDraftBad() {
  const raw = await draftStorage.getItem(DRAFT_KEY)
  if (raw === null) return '저장된 초안 없음'
 
  const draft = JSON.parse(raw) as DraftV2
  return `${draft.deliveryNote} / ${draft.total.amount.toLocaleString()}원`
}
 
export default function App() {
  const [result, setResult] = useState('실패 재현을 실행하세요')
 
  async function reproduceFailure() {
    setResult('실행 중')
 
    try {
      await draftStorage.setItem(DRAFT_KEY, V1_RAW)
      setResult(await loadDraftBad())
    } catch (error) {
      setResult(error instanceof Error ? error.name : '알 수 없는 오류')
    }
  }
 
  return (
    <View style={{ padding: 24, gap: 12 }}>
      <Pressable onPress={() => void reproduceFailure()}>
        <Text>V1 초안 읽기</Text>
      </Pressable>
      <Text>결과: {result}</Text>
    </View>
  )
}

type DraftV1 = {
  version: 1
  note: string
  total: number
}
 
type DraftV2 = {
  version: 2
  deliveryNote: string
  total: {
    amount: number
    currency: 'KRW'
  }
}

export type DraftV1 = {
  version: 1
  note: string
  total: number
}
 
export type DraftV2 = {
  version: 2
  deliveryNote: string
  total: {
    amount: number
    currency: 'KRW'
  }
}
 
type MigrationErrorCode =
  | 'INVALID_JSON'
  | 'INVALID_V1'
  | 'INVALID_V2'
  | 'UNSUPPORTED_VERSION'
  | 'MISSING_VERSION'
 
export class DraftMigrationError extends Error {
  constructor(readonly code: MigrationErrorCode) {
    super(code)
    this.name = 'DraftMigrationError'
  }
}
 
function isObject(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value)
}
 
function isDraftV1(value: unknown): value is DraftV1 {
  return (
    isObject(value) &&
    value.version === 1 &&
    typeof value.note === 'string' &&
    typeof value.total === 'number' &&
    Number.isFinite(value.total)
  )
}
 
function isDraftV2(value: unknown): value is DraftV2 {
  return (
    isObject(value) &&
    value.version === 2 &&
    typeof value.deliveryNote === 'string' &&
    isObject(value.total) &&
    typeof value.total.amount === 'number' &&
    Number.isFinite(value.total.amount) &&
    value.total.currency === 'KRW'
  )
}
 
function migrateV1ToV2(source: DraftV1): DraftV2 {
  return {
    version: 2,
    deliveryNote: source.note,
    total: {
      amount: source.total,
      currency: 'KRW',
    },
  }
}
 
export function readCurrentDraft(raw: string): {
  draft: DraftV2
  migratedFrom: 1 | null
} {
  let parsed: unknown
 
  try {
    parsed = JSON.parse(raw)
  } catch {
    throw new DraftMigrationError('INVALID_JSON')
  }
 
  if (!isObject(parsed) || typeof parsed.version !== 'number') {
    throw new DraftMigrationError('MISSING_VERSION')
  }
 
  if (parsed.version === 1) {
    if (!isDraftV1(parsed)) throw new DraftMigrationError('INVALID_V1')
    const migrated = migrateV1ToV2(parsed)
    if (!isDraftV2(migrated)) throw new DraftMigrationError('INVALID_V2')
    return { draft: migrated, migratedFrom: 1 }
  }
 
  if (parsed.version === 2) {
    if (!isDraftV2(parsed)) throw new DraftMigrationError('INVALID_V2')
    return { draft: parsed, migratedFrom: null }
  }
 
  throw new DraftMigrationError('UNSUPPORTED_VERSION')
}

import { createAsyncStorage } from '@react-native-async-storage/async-storage'
import { readCurrentDraft, type DraftV2 } from './draft-record'
 
const draftStorage = createAsyncStorage('delivery-draft')
const DRAFT_KEY = 'delivery-note'
 
type DraftStorage = {
  getItem(key: string): Promise<string | null>
  setItem(key: string, value: string): Promise<void>
}
 
export async function loadAndMigrateDraft(
  storage: DraftStorage = draftStorage,
): Promise<DraftV2 | null> {
  const raw = await storage.getItem(DRAFT_KEY)
  if (raw === null) return null
 
  const result = readCurrentDraft(raw)
 
  if (result.migratedFrom !== null) {
    await storage.setItem(DRAFT_KEY, JSON.stringify(result.draft))
  }
 
  return result.draft
}

import { useState } from 'react'
import { Pressable, Text, View } from 'react-native'
import { createAsyncStorage } from '@react-native-async-storage/async-storage'
import { DraftMigrationError } from './draft-record'
import { loadAndMigrateDraft } from './draft-storage'
 
const draftStorage = createAsyncStorage('delivery-draft')
const DRAFT_KEY = 'delivery-note'
 
type FixtureName =
  | 'V1'
  | 'V2'
  | 'INVALID_JSON'
  | 'INVALID_V1'
  | 'FUTURE_V99'
 
const fixtures: Record<FixtureName, string> = {
  V1: JSON.stringify({
    version: 1,
    note: '현관 앞에 놓아주세요',
    total: 12900,
  }),
  V2: JSON.stringify({
    version: 2,
    deliveryNote: '현관 앞에 놓아주세요',
    total: { amount: 12900, currency: 'KRW' },
  }),
  INVALID_JSON: '{"version": 1',
  INVALID_V1: JSON.stringify({ version: 1, note: '현관 앞에 놓아주세요' }),
  FUTURE_V99: JSON.stringify({ version: 99, payload: 'future' }),
}
 
const fixtureNames: FixtureName[] = [
  'V1',
  'V2',
  'INVALID_JSON',
  'INVALID_V1',
  'FUTURE_V99',
]
 
export default function App() {
  const [running, setRunning] = useState(false)
  const [result, setResult] = useState('fixture를 선택하세요')
 
  async function runFixture(name: FixtureName) {
    setRunning(true)
    const original = fixtures[name]
    let writeCount = 0
    const observedStorage = {
      getItem: (key: string) => draftStorage.getItem(key),
      async setItem(key: string, value: string) {
        writeCount += 1
        await draftStorage.setItem(key, value)
      },
    }
 
    try {
      await draftStorage.setItem(DRAFT_KEY, original)
 
      const draft = await loadAndMigrateDraft(observedStorage)
      const stored = await draftStorage.getItem(DRAFT_KEY)
 
      setResult(
        `${name}: version=${draft?.version ?? 'none'}, ` +
          `amount=${draft?.total.amount ?? 'none'}, ` +
          `writeCount=${writeCount}, stored=${stored}`,
      )
    } catch (error) {
      const stored = await draftStorage.getItem(DRAFT_KEY)
      const code =
        error instanceof DraftMigrationError ? error.code : 'STORAGE_ERROR'
 
      setResult(
        `${name}: error=${code}, writeCount=${writeCount}, ` +
          `originalPreserved=${stored === original}`,
      )
    } finally {
      setRunning(false)
    }
  }
 
  return (
    <View style={{ padding: 24, gap: 12 }}>
      {fixtureNames.map(name => (
        <Pressable
          disabled={running}
          key={name}
          onPress={() => void runFixture(name)}
        >
          <Text>{name} 실행</Text>
        </Pressable>
      ))}
      <Text selectable>{result}</Text>
    </View>
  )
}

V1            → DraftV2(12900, KRW) → writeCount=1, 저장소 version 2
V2            → 같은 DraftV2        → writeCount=0, 원본 유지
손상 JSON      → INVALID_JSON         → writeCount=0, 원본 유지
필드 누락 V1   → INVALID_V1           → writeCount=0, 원본 유지
version 99     → UNSUPPORTED_VERSION  → writeCount=0, 원본 유지

문제       업데이트 뒤 V1 배송 초안을 V2 화면에서 읽을 때 실행 오류
잘못된 판단 JSON.parse(raw) as DraftV2면 실제 데이터도 V2가 됨
관찰       저장 원본은 version 1, note 문자열, total 숫자
원인       출발 형식 검사와 V1→V2 변환 경로가 없음
행동       version 분기에서 V1 검사→V2 변환→V2 재검사 후 저장
검증       V1·V2·손상·필드 누락·미지원 버전 fixture와 원본 보존 확인