실시간 협업 앱의 동시 편집 충돌, CRDT와 LWW로 자동 병합하는 법

// State-based CRDT (CvRDT) — 전체 상태를 전송하고 merge()로 합침
class GCounter {
  private counts: Map<string, number> = new Map();
 
  increment(nodeId: string): void {
    this.counts.set(nodeId, (this.counts.get(nodeId) ?? 0) + 1);
  }
 
  value(): number {
    return [...this.counts.values()].reduce((sum, v) => sum + v, 0);
  }
 
  merge(other: GCounter): GCounter {
    const merged = new GCounter();
    const allKeys = new Set([...this.counts.keys(), ...other.counts.keys()]);
    for (const key of allKeys) {
      merged.counts.set(key, Math.max(
        this.counts.get(key) ?? 0,
        other.counts.get(key) ?? 0
      ));
    }
    return merged;
  }
}
 
// 노드 A와 B가 각자 카운터를 올리고 나중에 병합
const nodeA = new GCounter();
nodeA.increment('nodeA');
nodeA.increment('nodeA'); // nodeA: 2
 
const nodeB = new GCounter();
nodeB.increment('nodeB'); // nodeB: 1
 
const merged = nodeA.merge(nodeB);
console.log(merged.value()); // 3 — 도착 순서와 무관하게 항상 올바른 결과

interface LWWValue<T> {
  value: T;
  timestamp: number;
  nodeId: string; // 동일 타임스탬프 tie-breaking용
}
 
class LWWRegister<T> {
  private nodeId: string;
  private state: LWWValue<T>;
 
  constructor(initialValue: T, nodeId: string) {
    this.nodeId = nodeId;
    this.state = { value: initialValue, timestamp: 0, nodeId };
  }
 
  write(value: T): void {
    const timestamp = Date.now();
    // write()와 merge() 모두 동일한 tie-breaking 기준을 써야 일관성이 생긴다
    if (
      timestamp > this.state.timestamp ||
      (timestamp === this.state.timestamp && this.nodeId > this.state.nodeId)
    ) {
      this.state = { value, timestamp, nodeId: this.nodeId };
    }
  }
 
  read(): T {
    return this.state.value;
  }
 
  merge(other: LWWRegister<T>): LWWRegister<T> {
    const winner =
      other.state.timestamp > this.state.timestamp
        ? other.state
        : other.state.timestamp === this.state.timestamp && other.state.nodeId > this.state.nodeId
          ? other.state
          : this.state;
 
    const result = new LWWRegister<T>(winner.value, winner.nodeId);
    result.state = winner;
    return result;
  }
}

class LWWElementSet<T> {
  private addSet: Map<T, number> = new Map();
  private removeSet: Map<T, number> = new Map();
 
  add(element: T, timestamp: number): void {
    const existing = this.addSet.get(element) ?? -Infinity;
    if (timestamp > existing) {
      this.addSet.set(element, timestamp);
    }
  }
 
  remove(element: T, timestamp: number): void {
    const existing = this.removeSet.get(element) ?? -Infinity;
    if (timestamp > existing) {
      this.removeSet.set(element, timestamp);
    }
  }
 
  has(element: T): boolean {
    const addTime = this.addSet.get(element) ?? -Infinity;
    const removeTime = this.removeSet.get(element) ?? -Infinity;
    return addTime >= removeTime;
  }
 
  merge(other: LWWElementSet<T>): void {
    for (const [elem, ts] of other.addSet) this.add(elem, ts);
    for (const [elem, ts] of other.removeSet) this.remove(elem, ts);
  }
}

import * as Y from 'yjs'
import { WebsocketProvider } from 'y-websocket'
 
// 공유 문서 생성
const ydoc = new Y.Doc()
 
// WebSocket으로 다른 클라이언트와 동기화
const provider = new WebsocketProvider('wss://your-server.com', 'room-name', ydoc)
 
// 공유 텍스트 타입 — 여러 사람이 동시에 수정해도 CRDT가 병합 처리
const ytext = ydoc.getText('content')
 
// 사용자 A가 "Hello"를 입력
ytext.insert(0, 'Hello')
 
// 사용자 B가 오프라인 상태에서 동시에 " World"를 뒤에 추가한 후 재연결
// → Yjs가 YATA 알고리즘으로 자동 병합: "Hello World"
 
// 협업 카운터 (좋아요 수 등) — Y.Map은 LWW 방식으로 충돌 해결
const ymap = ydoc.getMap('metadata')
ymap.set('likes', (ymap.get('likes') as number ?? 0) + 1)
 
// 변경 감지
ytext.observe(() => {
  console.log('텍스트 변경됨:', ytext.toString())
})

import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'
 
class OfflineShoppingCart {
  private ydoc: Y.Doc
  private items: Y.Map<number> // itemId -> quantity
 
  constructor(userId: string) {
    this.ydoc = new Y.Doc()
    this.items = this.ydoc.getMap('cart')
 
    // 로컬 IndexedDB에 자동 저장 — 앱을 닫아도 데이터 유지
    new IndexeddbPersistence(`cart-${userId}`, this.ydoc)
  }
 
  addItem(itemId: string, quantity: number): void {
    const current = this.items.get(itemId) ?? 0
    this.items.set(itemId, current + quantity)
  }
 
  removeItem(itemId: string): void {
    this.items.delete(itemId)
  }
 
  getItems(): Record<string, number> {
    return Object.fromEntries(this.items.entries())
  }
 
  // 서버에서 받은 상태와 병합 (재연결 시)
  mergeWithServer(serverUpdate: Uint8Array): void {
    Y.applyUpdate(this.ydoc, serverUpdate)
    // CRDT 보장: 어떤 순서로 병합해도 최종 결과는 동일
  }
}

interface UserSession {
  userId: string;
  lastLoginAt: number; // Unix timestamp (ms)
  deviceInfo: string;
}
 
class UserSessionStore {
  private sessions: Map<string, UserSession> = new Map();
 
  upsert(session: UserSession): void {
    const existing = this.sessions.get(session.userId);
    // LWW: 더 최근 타임스탬프가 승리
    if (!existing || session.lastLoginAt > existing.lastLoginAt) {
      this.sessions.set(session.userId, session);
    }
  }
 
  // 두 노드의 상태를 병합 (예: 리전 간 복제)
  merge(other: UserSessionStore): void {
    for (const [, session] of other.sessions) {
      this.upsert(session);
    }
  }
}
 
// 이 TypeScript 클래스가 수동으로 하는 일을, Cassandra는 스키마 수준에서 자동으로 처리합니다.
// CREATE TABLE user_sessions (
//   user_id uuid PRIMARY KEY,
//   last_login_at timestamp,
//   device_info text
// );
// -- 동일 파티션 키에 대한 쓰기는 자동으로 LWW 적용 (쓰기 시각 기준)