Rork Maxで実装するオフライン・ファースト・アーキテクチャ — ローカル・ファースト・データベース、同期エンジン、競合解決

// ローカル・ストレージ抽象化
protocol LocalDataStore {
    func saveChanges(_ changes: [EntityChange]) async throws
    func fetchEntity<T: Identifiable>(_ id: T.ID) -> T?
    func queryEntities<T>(matching predicate: NSPredicate) -> [T]
}
 
// 変更追跡
struct EntityChange: Codable {
    let entityId: String
    let entityType: String
    let operation: Operation // .create, .update, .delete
    let timestamp: Date
    let data: AnyCodable
    let clientId: String // 変更を実行したクライアントを識別
}
 
// 同期エンジン状態
actor SyncEngine {
    private let localStore: LocalDataStore
    private let networkService: NetworkService
    private var pendingChanges: [EntityChange] = []
    private var lastSyncTimestamp: Date?
 
    func recordChange(_ change: EntityChange) async throws {
        pendingChanges.append(change)
        try await localStore.saveChanges([change])
        await triggerSyncIfNeeded()
    }
 
    func sync() async throws {
        guard !pendingChanges.isEmpty else { return }
 
        // 保留中の変更をバッチ処理
        let batch = pendingChanges
 
        // サーバーに送信
        let response = try await networkService.syncChanges(batch)
 
        // サーバー変更を適用し競合を解決
        let resolved = try resolveConflicts(batch, with: response.serverChanges)
 
        // ローカル・ストレージを解決された状態で更新
        try await localStore.saveChanges(resolved)
 
        // 保留中の変更をクリア
        pendingChanges.removeAll()
        lastSyncTimestamp = Date()
    }
}

// オフライン・ファースト向けWCDB設定
import WCDB
 
class WCDBOfflineStore: LocalDataStore {
    let db: Database
 
    init(path: String) throws {
        db = try Database(at: path)
        try setupSchema()
    }
 
    private func setupSchema() throws {
        // 同期追跡用の変更テーブル
        try db.create(table: "entity_changes", of: EntityChange.self)
        try db.create(index: "idx_pending_sync",
                     on: "entity_changes",
                     indexesBy: ["timestamp", "isSynced"])
 
        // 因果関係追跡用バージョン・ベクトル
        try db.create(table: "version_vectors", of: VersionVector.self)
        try db.create(index: "idx_entity_version",
                     on: "version_vectors",
                     indexesBy: ["entityId"])
    }
 
    func saveChanges(_ changes: [EntityChange]) async throws {
        try db.inTransaction {
            for change in changes {
                try db.insert(change, intoTable: "entity_changes")
                try updateVersionVector(for: change)
            }
        }
    }
 
    private func updateVersionVector(for change: EntityChange) throws {
        let vector = try db.selectOne(
            on: VersionVector.self,
            from: "version_vectors",
            where: "entityId" == change.entityId
        ) ?? VersionVector(entityId: change.entityId, clock: [:])
 
        var updatedVector = vector
        updatedVector.clock[change.clientId, default: 0] += 1
 
        try db.update(table: "version_vectors",
                      on: VersionVector.self,
                      with: updatedVector,
                      where: "entityId" == change.entityId)
    }
}

import RealmSwift
 
class Task: Object, ObjectKeyIdentifiable {
    @Persisted(primaryKey: true) var id: ObjectId
    @Persisted var title: String = ""
    @Persisted var description: String = ""
    @Persisted var status: String = "pending"
    @Persisted var assignedUsers: MutableSet<User>
    @Persisted var lastModified: Date = Date()
    @Persisted var clientId: String = ""
    @Persisted var syncedAt: Date?
    @Persisted var isSynced: Bool = false
}
 
class RealmOfflineStore: LocalDataStore {
    let realm: Realm
 
    init() throws {
        // オフライン・ファースト向けRealmを設定
        var config = Realm.Configuration.defaultConfiguration
        config.schemaVersion = 1
 
        // データ喪失なしでスキーマを更新するマイグレーション
        config.migrationBlock = { migration, oldVersion in
            if oldVersion < 1 {
                // オフライン追跡用の新しい列を追加
                migration.renameProperty(onType: "Task", from: "modified", to: "lastModified")
            }
        }
 
        Realm.Configuration.defaultConfiguration = config
        realm = try Realm()
    }
 
    func saveChanges(_ changes: [EntityChange]) async throws {
        try await realm.asyncWrite {
            for change in changes {
                switch change.operation {
                case .create, .update:
                    let task = Task()
                    task.id = ObjectId(timestamp: UInt32(Date().timeIntervalSince1970),
                                      machineIdentifier: [0, 0, 0],
                                      processIdentifier: UInt16.random(in: 0..<65536),
                                      counter: UInt32.random(in: 0..<16777215))
                    task.title = change.data["title"] as? String ?? ""
                    task.lastModified = change.timestamp
                    task.isSynced = false
                    self.realm.add(task, update: .modified)
 
                case .delete:
                    let predicate = NSPredicate(format: "id == %@", change.entityId as CVarArg)
                    let toDelete = self.realm.objects(Task.self).where(predicate)
                    self.realm.delete(toDelete)
                }
            }
        }
    }
 
    func getPendingChanges() throws -> [EntityChange] {
        let unsyncedTasks = realm.objects(Task.self).where { !$0.isSynced }
        return unsyncedTasks.map { task in
            EntityChange(
                entityId: task.id.stringValue,
                entityType: "Task",
                operation: .update,
                timestamp: task.lastModified,
                data: AnyCodable(["title": task.title]),
                clientId: task.clientId
            )
        }
    }
}

struct LastWriteWinsElement<Value: Codable>: Codable {
    let value: Value
    let timestamp: UInt64 // 論理的クロック、または物理時間
    let clientId: String
 
    // 競合解決での比較用
    func isNewerThan(_ other: LastWriteWinsElement<Value>) -> Bool {
        if timestamp != other.timestamp {
            return timestamp > other.timestamp
        }
        return clientId > other.clientId // タイ・ブレーカー：辞書順
    }
}
 
class LWWCRDTSyncEngine {
    func merge<Value: Codable>(
        local: LastWriteWinsElement<Value>,
        remote: LastWriteWinsElement<Value>
    ) -> LastWriteWinsElement<Value> {
        // 常にタイムスタンプが高い方を保持
        remote.isNewerThan(local) ? remote : local
    }
 
    func mergeConflictingChanges(
        localChanges: [EntityChange],
        remoteChanges: [EntityChange]
    ) -> [EntityChange] {
        var merged: [String: EntityChange] = [:]
 
        // 両方の変更セットを処理
        for change in localChanges + remoteChanges {
            let key = change.entityId
 
            if let existing = merged[key] {
                // タイムスタンプが高い方の変更を保持
                let existingTime = UInt64(existing.timestamp.timeIntervalSince1970 * 1000)
                let newTime = UInt64(change.timestamp.timeIntervalSince1970 * 1000)
 
                if newTime > existingTime ||
                   (newTime == existingTime && change.clientId > existing.clientId) {
                    merged[key] = change
                }
            } else {
                merged[key] = change
            }
        }
 
        return Array(merged.values)
    }
}

struct VectorClockElement: Codable, Equatable {
    let value: String
    let vectorClock: [String: UInt64] // clientId -> 論理的クロック
    let clientId: String
 
    func happensBefore(_ other: VectorClockElement) -> Bool {
        var atLeastOneLess = false
 
        for (clientId, time) in vectorClock {
            let otherTime = other.vectorClock[clientId] ?? 0
            if time > otherTime {
                return false // これはその後に発生、前ではない
            }
            if time < otherTime {
                atLeastOneLess = true
            }
        }
 
        return atLeastOneLess
    }
 
    mutating func increment(by clientId: String) {
        vectorClock[clientId, default: 0] += 1
    }
}
 
class VectorClockSyncEngine {
    func detectConcurrentChanges(
        change1: VectorClockElement,
        change2: VectorClockElement
    ) -> Bool {
        // 互いに前後がない場合、変更は並行
        !change1.happensBefore(change2) && !change2.happensBefore(change1)
    }
 
    func mergeConcurrentChanges(
        local: VectorClockElement,
        remote: VectorClockElement
    ) -> VectorClockElement {
        // 並行変更の場合、アプリケーション固有のマージロジックを実装
        // 例：辞書順で最初の値を選択
        let mergedValue = [local.value, remote.value].sorted().first ?? local.value
 
        var mergedClock = local.vectorClock
        for (clientId, time) in remote.vectorClock {
            mergedClock[clientId] = max(mergedClock[clientId] ?? 0, time)
        }
 
        return VectorClockElement(
            value: mergedValue,
            vectorClock: mergedClock,
            clientId: local.clientId
        )
    }
}

class SemanticConflictResolver {
    // ドキュメント風データ（テキスト、リスト）の場合
    func resolveTextConflict(
        local: String,
        remote: String,
        original: String
    ) -> String {
        // 3者マージアプローチ
 
        // 一方だけが変更したか確認
        if local == original {
            return remote // リモート側が勝利
        }
        if remote == original {
            return local // ローカル側が勝利
        }
 
        // 両側が変更 - 運用変換またはCRDTが必要
        // フォールバック：より長いコンテンツを優先（データ喪失が少ない）
        return local.count >= remote.count ? local : remote
    }
 
    // リスト項目の場合
    func resolveListConflict(
        local: [String],
        remote: [String],
        original: [String]
    ) -> [String] {
        // 最長共通部分列を使用して実際に何が変更されたかを検出
        let lcs = longestCommonSubsequence(original, local)
        let remoteChanges = detectChanges(original, remote)
 
        // ローカル結果にリモート変更を適用
        var merged = local
        for change in remoteChanges {
            if !merged.contains(change.newValue) {
                merged.append(change.newValue)
            }
        }
 
        return merged
    }
 
    // 数値フィールドの場合
    func resolveNumericConflict(
        local: Double,
        remote: Double,
        original: Double
    ) -> Double {
        let localChange = local - original
        let remoteChange = remote - original
 
        // 両方の変更を適用（加算は可換）
        return original + localChange + remoteChange
    }
}

class ConflictPrompt {
    struct Conflict {
        let entityId: String
        let fieldName: String
        let localValue: Any
        let remoteValue: Any
        let timestamp: Date
    }
 
    func presentConflictUI(
        conflicts: [Conflict],
        onResolve: @escaping ([String: Any]) -> Void
    ) {
        // 並行比較UIを構築
        // ユーザーはどちらのバージョンを保持するか選択、または手動編集
        var resolutions: [String: Any] = [:]
 
        for conflict in conflicts {
            // ユーザーに選択をプレゼン
            let userChoice = showResolutionDialog(conflict)
            resolutions[conflict.entityId] = userChoice
        }
 
        onResolve(resolutions)
    }
 
    private func showResolutionDialog(_ conflict: Conflict) -> Any {
        // 実装では、SwiftUIモーダルをプレゼン
        // ここでは解決値を返す
        conflict.remoteValue // 例：リモートを優先
    }
}

class ProductionSyncEngine {
    private let localStore: LocalDataStore
    private let networkService: NetworkService
    private let conflictResolver: SemanticConflictResolver
    private var syncState = SyncState()
 
    struct SyncState {
        var lastSyncTime: Date?
        var isSyncing = false
        var pendingChangeCount = 0
        var lastSyncError: Error?
    }
 
    // ネットワーク利用可能性での自動同期
    func setupNetworkObserver() {
        NotificationCenter.default.addObserver(
            forName: NSNotification.Name.reachabilityChanged,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task {
                try? await self?.syncWhenNeeded()
            }
        }
    }
 
    // スマート同期：変更のバッチ処理と重複排除
    func recordChange(_ change: EntityChange) async throws {
        try await localStore.saveChanges([change])
        syncState.pendingChangeCount += 1
 
        // 遅延後に同期をトリガー（デバウンス）
        try await Task.sleep(nanoseconds: 2_000_000_000) // 2秒
        try await syncWhenNeeded()
    }
 
    // メイン同期ループ
    func syncWhenNeeded() async throws {
        guard !syncState.isSyncing else { return }
        guard networkAvailable() else { return }
 
        syncState.isSyncing = true
        defer { syncState.isSyncing = false }
 
        do {
            // ステップ1：ローカル・ストレージから保留中の変更を取得
            let pendingChanges = try await localStore.getPendingChanges()
            guard !pendingChanges.isEmpty else { return }
 
            // ステップ2：バッチ処理と重複排除
            let batchedChanges = batchAndDeduplicate(pendingChanges)
 
            // ステップ3：サーバーに送信
            let response = try await networkService.sync(
                clientChanges: batchedChanges,
                lastSyncTime: syncState.lastSyncTime
            )
 
            // ステップ4：競合を解決
            let resolvedChanges = try resolveConflicts(
                local: batchedChanges,
                remote: response.serverChanges
            )
 
            // ステップ5：リモート変更をマージ
            try await applyRemoteChanges(response.serverChanges)
 
            // ステップ6：変更を同期済みとしてマーク
            try await markAsSynced(batchedChanges)
 
            syncState.lastSyncTime = Date()
            syncState.lastSyncError = nil
 
        } catch {
            syncState.lastSyncError = error
            throw error
        }
    }
 
    private func batchAndDeduplicate(_ changes: [EntityChange]) -> [EntityChange] {
        var batchedMap: [String: EntityChange] = [:]
 
        for change in changes {
            // エンティティごとに最新の変更のみ保持
            batchedMap[change.entityId] = change
        }
 
        return Array(batchedMap.values)
    }
 
    private func resolveConflicts(
        local: [EntityChange],
        remote: [EntityChange]
    ) -> [EntityChange] {
        var resolved: [String: EntityChange] = [:]
 
        // エンティティIDでリモート変更のマップを作成
        let remoteMap = Dictionary(grouping: remote) { $0.entityId }
 
        // すべての変更を処理
        for change in local + remote {
            let key = change.entityId
 
            if let remoteChange = remoteMap[key]?.first {
                // 競合を検出 - 戦略を使用して解決
                let winner = conflictResolver.resolveConflict(
                    local: change,
                    remote: remoteChange
                )
                resolved[key] = winner
            } else {
                resolved[key] = change
            }
        }
 
        return Array(resolved.values)
    }
 
    private func networkAvailable() -> Bool {
        // ネットワーク状態を確認
        true // 簡略化
    }
}

// テスト用モック・ネットワーク・サービス
class MockNetworkService: NetworkService {
    enum NetworkCondition {
        case online
        case offline
        case slowConnection(delaySeconds: Double)
        case flaky(successRate: Double)
    }
 
    var condition: NetworkCondition = .online
    var syncHistory: [SyncRequest] = []
 
    func sync(clientChanges: [EntityChange], lastSyncTime: Date?) async throws -> SyncResponse {
        syncHistory.append(SyncRequest(changes: clientChanges, time: lastSyncTime ?? Date()))
 
        switch condition {
        case .offline:
            throw NetworkError.noConnection
 
        case .slowConnection(let delay):
            try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
            return SyncResponse(serverChanges: [], conflicts: [])
 
        case .flaky(let successRate):
            if Double.random(in: 0...1) > successRate {
                throw NetworkError.timeout
            }
            return SyncResponse(serverChanges: [], conflicts: [])
 
        case .online:
            return SyncResponse(serverChanges: [], conflicts: [])
        }
    }
}
 
// オフライン変更が追跡されることをテスト
func testOfflineChangesArePersisted() async throws {
    let store = try RealmOfflineStore()
    let syncEngine = ProductionSyncEngine(localStore: store, networkService: MockNetworkService())
 
    // オフライン中に変更を記録
    let change = EntityChange(
        entityId: "task-1",
        entityType: "Task",
        operation: .create,
        timestamp: Date(),
        data: AnyCodable(["title": "オフライン・タスク"]),
        clientId: UIDevice.current.identifierForVendor?.uuidString ?? ""
    )
 
    try await syncEngine.recordChange(change)
 
    // 変更がローカル・ストレージにあることを確認
    let pendingChanges = try await store.getPendingChanges()
    XCTAssertEqual(pendingChanges.count, 1)
    XCTAssertEqual(pendingChanges.first?.entityId, "task-1")
}
 
// 競合解決をテスト
func testConflictResolution() async throws {
    let resolver = SemanticConflictResolver()
 
    let local = "ローカルで更新されたテキスト"
    let remote = "リモートで更新されたテキスト"
    let original = "元のテキスト"
 
    let resolved = resolver.resolveTextConflict(
        local: local,
        remote: remote,
        original: original
    )
 
    // 解決が変更の一つを選んだことを確認
    XCTAssertTrue([local, remote].contains(resolved))
}

class OptimizedOfflineStore {
    func setupOptimizedSchema() throws {
        // 頻繁にクエリされるフィールドにインデックスを作成
        try db.create(
            index: "idx_task_status_date",
            on: "tasks",
            indexesBy: ["status", "createdAt"]
        )
 
        // 同期関連クエリ用の個別インデックス
        try db.create(
            index: "idx_pending_sync",
            on: "tasks",
            indexesBy: ["isSynced", "lastModified"]
        )
    }
 
    func queryPendingChanges(limit: Int = 100) async throws -> [EntityChange] {
        // インデックスを使用した高速ルックアップ
        return try db.selectAll(
            from: EntityChange.self,
            where: ("isSynced" == false).order(by: "timestamp".asColumn(), .ascending),
            limit: limit
        )
    }
}

class StreamingOfflineStore {
    // メモリ過負荷を回避するため、大規模結果セットをストリーム
    func streamPendingChanges(
        batchSize: Int = 500,
        onBatch: @escaping ([EntityChange]) -> Void
    ) async throws {
        var offset = 0
        var hasMore = true
 
        while hasMore {
            let batch = try db.selectAll(
                from: EntityChange.self,
                where: "isSynced" == false,
                limit: batchSize,
                offset: offset
            )
 
            hasMore = batch.count == batchSize
            onBatch(batch)
            offset += batchSize
        }
    }
}

class LargeFileSync {
    // 確実な同期のため大規模ファイルをチャンク分割
    func uploadLargeFile(
        fileURL: URL,
        chunkSize: Int = 5_000_000 // 5MBチャンク
    ) async throws {
        let fileSize = try FileManager.default.attributesOfItem(atPath: fileURL.path)[.size] as? Int ?? 0
        let fileId = UUID().uuidString
 
        var offset = 0
        while offset < fileSize {
            let remainingSize = fileSize - offset
            let currentChunkSize = min(chunkSize, remainingSize)
 
            let chunk = try readChunk(fileURL, offset: offset, size: currentChunkSize)
 
            try await networkService.uploadChunk(
                fileId: fileId,
                chunkIndex: offset / chunkSize,
                totalChunks: (fileSize + chunkSize - 1) / chunkSize,
                data: chunk
            )
 
            offset += currentChunkSize
        }
    }
}

class DeletionTracking {
    // 即座の削除ではなく削除対象としてマーク
    func markForDeletion(_ entityId: String) async throws {
        let deleteChange = EntityChange(
            entityId: entityId,
            entityType: "Task",
            operation: .delete,
            timestamp: Date(),
            data: AnyCodable([:]),
            clientId: clientId
        )
 
        try await localStore.saveChanges([deleteChange])
        // 同期が削除を確認するまでローカル・ストレージ内に記録を保持
    }
 
    // 同期成功後のみ真に削除
    func purgeDeletedEntities(afterSyncingAt date: Date) async throws {
        try await localStore.deleteChanges(
            where: NSPredicate(format: "operation == %@ AND syncedAt < %@", "delete", date as NSDate)
        )
    }
}

// 推奨: SQLite WALモード + 明示commit
let connection = try Connection(dbPath)
try connection.execute("PRAGMA journal_mode=WAL;")
try connection.execute("PRAGMA synchronous=NORMAL;")
try connection.transaction {
    try connection.run(favorites.insert(or: .replace, item))
}
// commit はトランザクション終了時に自動だが、明示的に同期させたいときは:
try connection.execute("PRAGMA wal_checkpoint(PASSIVE);")

class AdOfflineFallback {
    private var retryAttempts = 0
    private let maxRetries = 3
 
    func loadAd() {
        guard Reachability.shared.isConnected else {
            bannerView.isHidden = true
            heightConstraint.constant = 0
            return
        }
        bannerView.load(GADRequest())
    }
 
    func handleAdFailedToLoad(_ error: Error) {
        guard retryAttempts < maxRetries else { return }
        let delay = pow(2.0, Double(retryAttempts)) * 5.0
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
            self?.retryAttempts += 1
            self?.loadAd()
        }
    }
}