Building Production iCloud Sync Apps with SwiftUI and CloudKit in Antigravity

import CloudKit
import Observation
 
// CloudKit container identifier (customize per project)
private let containerIdentifier = "iCloud.com.example.myapp.cloudkit"
 
// CloudKit Record Type constants
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
    }
 
    // --- Fetch all tasks ---
    func fetchTasks() async {
        isLoading = true
        defer { isLoading = false }
 
        do {
            let query = CKQuery(
                recordType: RecordType.task,
                predicate: NSPredicate(value: true)
            )
            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
            }
        }
    }
 
    // --- Save a task (create or update) ---
    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 model ---
struct TaskItem: Identifiable, Hashable {
    let id: CKRecord.ID
    var title: String
    var isCompleted: Bool
    var dueDate: Date?
    var priority: Int
 
    // Initialize from 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)
    }
 
    // Convert to 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
    }
}
// Expected: tasks array auto-updates in SwiftUI views via @Observable

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("Loading...")
                } else {
                    List {
                        ForEach(store.tasks) { task in
                            TaskRowView(task: task) { updated in
                                Task { try? await store.saveTask(updated) }
                            }
                        }
                    }
                }
            }
            .navigationTitle("Tasks")
            .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()
                await store.subscribeToChanges()
            }
            .onReceive(NotificationCenter.default.publisher(
                for: .CKAccountChanged
            )) { _ in
                Task { await store.fetchTasks() }
            }
        }
    }
}
 
extension TaskStore {
    func subscribeToChanges() async {
        let subscriptionID = "task-changes"
 
        // Check for existing subscription to avoid duplicates
        do {
            _ = try await privateDB.subscription(for: subscriptionID)
        } catch {
            // Not yet registered — create it
            let subscription = CKQuerySubscription(
                recordType: RecordType.task,
                predicate: NSPredicate(value: true),
                subscriptionID: subscriptionID,
                options: [
                    .firesOnRecordCreation,
                    .firesOnRecordUpdate,
                    .firesOnRecordDeletion
                ]
            )
 
            // Silent push: wakes app in background to refresh data
            let info = CKSubscription.NotificationInfo()
            info.shouldSendContentAvailable = true
            subscription.notificationInfo = info
 
            try? await privateDB.save(subscription)
        }
    }
}

extension TaskStore {
    // Save with conflict resolution
    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 }
 
            // Merge strategy:
            // - Title: client wins (user is actively typing)
            // - isCompleted: server wins (respect completion from other devices)
            let merged = serverRecord
            merged["title"] = clientRecord["title"]
 
            let saved = try await privateDB.save(merged)
            await MainActor.run {
                if let i = tasks.firstIndex(where: { $0.id == item.id }) {
                    tasks[i] = TaskItem(record: saved)!
                }
            }
        }
    }
 
    // Queue writes when offline
    func saveOfflineIfNeeded(_ item: TaskItem) async {
        do {
            try await saveWithConflictResolution(item)
        } catch let err as CKError
            where err.code == .networkUnavailable || err.code == .networkFailure
        {
            PendingChangesQueue.shared.enqueue(item)
            print("Queued offline change: \(item.title)")
        } catch {
            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) {
        // Deduplicate: keep only the latest change per ID
        queue.removeAll { $0.id == item.id }
        queue.append(item)
    }
 
    // Flush on network reconnection
    func flushAll(to store: TaskStore) async {
        let pending = queue
        queue.removeAll()
        for item in pending {
            try? await store.saveWithConflictResolution(item)
        }
        print("Flushed \(pending.count) pending changes")
    }
}
// Expected: Conflicting edits are merged rather than rejected; offline changes
// persist in the queue and sync automatically on reconnection.

// Check iCloud status at app launch
let status = try await CKContainer.default().accountStatus()
guard status == .available else {
    showICloudSignInPrompt = true
    return
}

func fetchAllTasks() async throws -> [CKRecord] {
    var all: [CKRecord] = []
    let query = CKQuery(
        recordType: RecordType.task,
        predicate: NSPredicate(value: true)
    )
    var cursor: CKQueryOperation.Cursor? = nil
 
    repeat {
        let (results, next) = try await privateDB.records(
            matching: query,
            resultsLimit: 200
        )
        all += try results.matchResults.map { _, r in try r.get() }
        cursor = next
    } while cursor != nil
 
    return all
    // Expected: returns all records regardless of total count
}

// Surfaces mainly in production
// CKError.invalidArguments
// "Field 'createdAt' is not marked queryable"
//
// Fix: CloudKit Dashboard -> Schema -> Indexes, set
// createdAt to Sortable / Queryable, then Deploy the
// Development schema to Production.
query.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]