Antigravity で SwiftUI × CloudKit の iCloud 同期アプリを本番実装する

import CloudKit
import Observation
 
// CloudKit コンテナ識別子（プロジェクトに合わせて変更）
private let containerIdentifier = "iCloud.com.example.myapp.cloudkit"
 
// Task の CloudKit Record Type 定数
enum RecordType {
    static let task = "Task"
    static let tag  = "Tag"
}
 
@Observable
final class TaskStore {
    var tasks: [TaskItem] = []
    var isLoading = false
    var errorMessage: String?
 
    private let container: CKContainer
    private let privateDB: CKDatabase
 
    init() {
        self.container = CKContainer(identifier: containerIdentifier)
        self.privateDB = container.privateCloudDatabase
    }
 
    // --- データ取得（一覧） ---
    func fetchTasks() async {
        isLoading = true
        defer { isLoading = false }
 
        do {
            let predicate = NSPredicate(value: true)
            let query = CKQuery(recordType: RecordType.task, predicate: predicate)
            query.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
 
            let results = try await privateDB.records(matching: query)
            let records = try results.matchResults.compactMap { _, result in
                try result.get()
            }
 
            await MainActor.run {
                self.tasks = records.compactMap(TaskItem.init)
            }
        } catch {
            await MainActor.run {
                self.errorMessage = error.localizedDescription
            }
        }
    }
 
    // --- 新規タスクの保存 ---
    func saveTask(_ item: TaskItem) async throws {
        let record = item.toCKRecord()
        let savedRecord = try await privateDB.save(record)
        let savedItem = TaskItem(record: savedRecord)!
 
        await MainActor.run {
            if let index = self.tasks.firstIndex(where: { $0.id == item.id }) {
                self.tasks[index] = savedItem
            } else {
                self.tasks.insert(savedItem, at: 0)
            }
        }
    }
}
 
// --- TaskItem モデル ---
struct TaskItem: Identifiable, Hashable {
    let id: CKRecord.ID
    var title: String
    var isCompleted: Bool
    var dueDate: Date?
    var priority: Int
 
    // CKRecord から初期化
    init?(record: CKRecord) {
        guard let title = record["title"] as? String else { return nil }
        self.id = record.recordID
        self.title = title
        self.isCompleted = (record["isCompleted"] as? Int64 ?? 0) == 1
        self.dueDate = record["dueDate"] as? Date
        self.priority = Int(record["priority"] as? Int64 ?? 0)
    }
 
    // CKRecord へ変換
    func toCKRecord() -> CKRecord {
        let record = CKRecord(recordType: RecordType.task, recordID: id)
        record["title"] = title
        record["isCompleted"] = isCompleted ? 1 : 0
        record["dueDate"] = dueDate
        record["priority"] = Int64(priority)
        return record
    }
}

import SwiftUI
import CloudKit
 
// --- タスク一覧ビュー ---
struct TaskListView: View {
    @State private var store = TaskStore()
    @State private var showAddTask = false
 
    var body: some View {
        NavigationStack {
            Group {
                if store.isLoading && store.tasks.isEmpty {
                    ProgressView("読み込み中...")
                } else {
                    List {
                        ForEach(store.tasks) { task in
                            TaskRowView(task: task) { updated in
                                Task { try? await store.saveTask(updated) }
                            }
                        }
                    }
                }
            }
            .navigationTitle("タスク")
            .toolbar {
                ToolbarItem(placement: .primaryAction) {
                    Button { showAddTask = true } label: {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $showAddTask) {
                AddTaskView { newTask in
                    Task { try? await store.saveTask(newTask) }
                }
            }
            .task {
                // 初回データ取得
                await store.fetchTasks()
                // CKSubscription でリアルタイム変更を購読
                await store.subscribeToChanges()
            }
            .onReceive(NotificationCenter.default.publisher(
                for: .CKAccountChanged
            )) { _ in
                // iCloud アカウント変更時に再取得
                Task { await store.fetchTasks() }
            }
        }
    }
}
 
// --- TaskStore に購読機能を追加 ---
extension TaskStore {
    func subscribeToChanges() async {
        let subscriptionID = "task-changes"
 
        // 既存の購読を確認（重複登録防止）
        do {
            _ = try await privateDB.subscription(for: subscriptionID)
            print("✅ 既存の CKSubscription を確認")
        } catch {
            // 未登録の場合は新規作成
            let subscription = CKQuerySubscription(
                recordType: RecordType.task,
                predicate: NSPredicate(value: true),
                subscriptionID: subscriptionID,
                options: [
                    .firesOnRecordCreation,
                    .firesOnRecordUpdate,
                    .firesOnRecordDeletion
                ]
            )
 
            // サイレントプッシュ設定（バックグラウンドでデータ取得）
            let notificationInfo = CKSubscription.NotificationInfo()
            notificationInfo.shouldSendContentAvailable = true
            subscription.notificationInfo = notificationInfo
 
            do {
                try await privateDB.save(subscription)
                print("✅ CKSubscription 登録完了")
            } catch {
                print("⚠️ CKSubscription 登録エラー: \(error.localizedDescription)")
            }
        }
    }
}

extension TaskStore {
    // --- コンフリクト対応付きの保存 ---
    func saveWithConflictResolution(_ item: TaskItem) async throws {
        do {
            try await saveTask(item)
        } catch let error as CKError where error.code == .serverRecordChanged {
            // サーバー側の最新レコードを取得
            guard
                let serverRecord = error.userInfo[CKRecordChangedErrorServerRecordKey] as? CKRecord,
                let clientRecord = error.userInfo[CKRecordChangedErrorClientRecordKey] as? CKRecord
            else { throw error }
 
            // マージ戦略:
            // - タイトルはクライアント（ユーザーが今編集中）を優先
            // - 完了状態はサーバー最新値を維持（他デバイスでの完了を尊重）
            let mergedRecord = serverRecord
            mergedRecord["title"] = clientRecord["title"]
            // isCompleted はサーバー値をそのまま使用
 
            let savedRecord = try await privateDB.save(mergedRecord)
            let savedItem = TaskItem(record: savedRecord)!
 
            await MainActor.run {
                if let index = self.tasks.firstIndex(where: { $0.id == item.id }) {
                    self.tasks[index] = savedItem
                }
            }
        }
    }
 
    // --- ネットワーク不通時のオフライン待機 ---
    func saveOfflineIfNeeded(_ item: TaskItem) async {
        do {
            try await saveWithConflictResolution(item)
        } catch let error as CKError
            where error.code == .networkUnavailable || error.code == .networkFailure
        {
            // オフライン時はローカルキューに追加
            PendingChangesQueue.shared.enqueue(item)
            print("⚡ オフラインキューに追加: \(item.title)（待機件数: \(PendingChangesQueue.shared.count)）")
        } catch {
            // その他のエラーは UI に表示
            await MainActor.run {
                self.errorMessage = error.localizedDescription
            }
        }
    }
}
 
// --- オフライン待機キュー ---
final class PendingChangesQueue {
    static let shared = PendingChangesQueue()
 
    private var queue: [TaskItem] = []
    var count: Int { queue.count }
 
    func enqueue(_ item: TaskItem) {
        // 同一 ID の既存エントリを上書き（最新変更のみ保持）
        queue.removeAll { $0.id == item.id }
        queue.append(item)
    }
 
    // ネットワーク復帰時に一括フラッシュ
    func flushAll(to store: TaskStore) async {
        let pending = queue
        queue.removeAll()
 
        for item in pending {
            try? await store.saveWithConflictResolution(item)
        }
        print("✅ オフラインキューをフラッシュ完了（\(pending.count) 件）")
    }
}

// CloudKitSchema.swift — 全エージェントが参照する唯一の契約
enum TaskSchema {
    static let recordType = "Task"
 
    enum Field {
        static let title       = "title"
        static let isCompleted = "isCompleted"
        static let dueDate     = "dueDate"
        static let modifiedAt  = "modifiedAt"
    }
 
    /// CloudKit ダッシュボードで queryable インデックスが必要なフィールド
    static let queryableFields = [Field.isCompleted, Field.dueDate, Field.modifiedAt]
}

### CloudKit 契約
 
- コンテナ: `iCloud.net.example.tasks`（変更禁止）
- Database: Private のみ。Public / Shared は現時点で使用しない
- Record Type: `Task`（フィールド定義は `CloudKitSchema.swift` が正本）
- フィールド名は文字列リテラルで書かない。`TaskSchema.Field` を経由する
- 保存は `modifyRecords(saving:deleting:savePolicy:atomically:)` を使う
  （`CKModifyRecordsOperation` の completion block 版は使わない）
- 競合解決は `modifiedAt` の後勝ち。楽観ロックは導入しない
- 新規フィールドは必ず Optional。既存レコードは値を持たない前提で読む

grep -rn --include='*.swift' \
  -e 'recordFetchedBlock' -e 'queryCompletionBlock' \
  -e 'perRecordCompletionBlock' -e 'modifyRecordsCompletionBlock' \
  -e 'recordChangedBlock' \
  Sources/

// アプリ起動時に iCloud ログイン状態を確認
let status = try await CKContainer.default().accountStatus()
if status != .available {
    // ユーザーに iCloud サインインを促すアラートを表示
    showICloudSignInAlert = true
}

// ページング対応クエリ（1 周目と 2 周目以降で呼ぶメソッドが違う）
func fetchTasksPaged() async throws -> [CKRecord] {
    var allRecords: [CKRecord] = []
 
    let query = CKQuery(
        recordType: RecordType.task,
        predicate: NSPredicate(value: true)
    )
 
    // 1 周目: クエリそのものを渡す
    let (firstPage, firstCursor) = try await privateDB.records(
        matching: query,
        resultsLimit: 200
    )
    allRecords += try firstPage.map { _, result in try result.get() }
 
    // 2 周目以降: 直前のカーソルを渡して続きから取る
    var cursor = firstCursor
    while let current = cursor {
        let (page, nextCursor) = try await privateDB.records(
            continuingMatchFrom: current,
            resultsLimit: 200
        )
        allRecords += try page.map { _, result in try result.get() }
        cursor = nextCursor
    }
 
    return allRecords
}
// 期待する出力: allRecords に全タスクが入り、cursor が nil になってループが終わる

// retryAfterSeconds を尊重するリトライ。上限回数だけこちらで持つ
func withCloudKitRetry<T>(
    maxAttempts: Int = 3,
    _ body: () async throws -> T
) async throws -> T {
    var attempt = 0
    while true {
        do {
            return try await body()
        } catch let error as CKError {
            attempt += 1
            // 秒数が返らないエラーは、待っても状況が変わらない
            guard let wait = error.retryAfterSeconds, attempt < maxAttempts else {
                throw error
            }
            try await Task.sleep(for: .seconds(wait))
        }
    }
}
 
// 呼び出し側
let saved = try await withCloudKitRetry {
    try await privateDB.save(record)
}
// 期待する出力: レート制限時はサーバ指定の秒数だけ待って再送し、
// 上限回数で成功しなければ CKError をそのまま上位へ投げる

// 本番でだけ発生しやすいエラー
// CKError.invalidArguments
// "Field 'createdAt' is not marked queryable"
//
// 対処: CloudKit Dashboard → Schema → Indexes で
// createdAt を Sortable / Queryable に設定してから
// Development スキーマを Production へ Deploy する
query.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]