Cloudkit

import CloudKit
let container = CKContainer.default()// Or named: CKContainer(identifier: "iCloud.com.example.app")
let publicDB  = container.publicCloudDatabaselet privateDB = container.privateCloudDatabaselet sharedDB  = container.sharedCloudDatabase

// CREATElet record = CKRecord(recordType: "Note")record["title"] = "Meeting Notes" as CKRecordValuerecord["body"] = "Discussed Q3 roadmap" as CKRecordValuerecord["createdAt"] = Date() as CKRecordValuerecord["tags"] = ["work", "planning"] as CKRecordValuelet saved = try await privateDB.save(record)
// FETCH by IDlet recordID = CKRecord.ID(recordName: "unique-id-123")let fetched = try await privateDB.record(for: recordID)
// UPDATE -- fetch first, modify, then savefetched["title"] = "Updated Title" as CKRecordValuelet updated = try await privateDB.save(fetched)
// DELETEtry await privateDB.deleteRecord(withID: recordID)

let zoneID = CKRecordZone.ID(zoneName: "NotesZone")let zone = CKRecordZone(zoneID: zoneID)try await privateDB.save(zone)
let recordID = CKRecord.ID(recordName: UUID().uuidString, zoneID: zoneID)let record = CKRecord(recordType: "Note", recordID: recordID)

let predicate = NSPredicate(format: "title BEGINSWITH %@", "Meeting")let query = CKQuery(recordType: "Note", predicate: predicate)query.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
let (results, _) = try await privateDB.records(matching: query)for (_, result) in results {    let record = try result.get()    print(record["title"] as? String ?? "")}
// Fetch all records of a typelet allQuery = CKQuery(recordType: "Note", predicate: NSPredicate(value: true))
// Full-text search across string fieldslet searchQuery = CKQuery(    recordType: "Note",    predicate: NSPredicate(format: "self CONTAINS %@", "roadmap"))
// Compound predicatelet compound = NSCompoundPredicate(andPredicateWithSubpredicates: [    NSPredicate(format: "createdAt > %@", cutoffDate as NSDate),    NSPredicate(format: "tags CONTAINS %@", "work")])

// Query subscription -- fires when matching records changelet subscription = CKQuerySubscription(    recordType: "Note",    predicate: NSPredicate(format: "tags CONTAINS %@", "urgent"),    subscriptionID: "urgent-notes",    options: [.firesOnRecordCreation, .firesOnRecordUpdate])let notifInfo = CKSubscription.NotificationInfo()notifInfo.shouldSendContentAvailable = true  // silent pushsubscription.notificationInfo = notifInfotry await privateDB.save(subscription)
// Database subscription -- fires on any database changelet dbSub = CKDatabaseSubscription(subscriptionID: "private-db-changes")dbSub.notificationInfo = notifInfotry await privateDB.save(dbSub)
// Record zone subscription -- fires on changes within a zonelet zoneSub = CKRecordZoneSubscription(    zoneID: CKRecordZone.ID(zoneName: "NotesZone"),    subscriptionID: "notes-zone-changes")zoneSub.notificationInfo = notifInfotry await privateDB.save(zoneSub)

func application(    _ application: UIApplication,    didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async -> UIBackgroundFetchResult {    let notification = CKNotification(fromRemoteNotificationDictionary: userInfo)    guard notification?.subscriptionID == "private-db-changes" else { return .noData }    // Fetch changes using CKSyncEngine or CKFetchRecordZoneChangesOperation    return .newData}

import CloudKit
final class SyncManager: CKSyncEngineDelegate {    let syncEngine: CKSyncEngine
    init(container: CKContainer = .default()) {        let config = CKSyncEngine.Configuration(            database: container.privateCloudDatabase,            stateSerialization: Self.loadState(),            delegate: self        )        self.syncEngine = CKSyncEngine(config)    }
    func handleEvent(_ event: CKSyncEngine.Event, syncEngine: CKSyncEngine) async {        switch event {        case .stateUpdate(let update):            Self.saveState(update.stateSerialization)        case .accountChange(let change):            handleAccountChange(change)        case .fetchedRecordZoneChanges(let changes):            for mod in changes.modifications { processRemoteRecord(mod.record) }            for del in changes.deletions { processRemoteDeletion(del.recordID) }        case .sentRecordZoneChanges(let sent):            for saved in sent.savedRecords { markSynced(saved) }            for fail in sent.failedRecordSaves { handleSaveFailure(fail) }        default: break        }    }
    func nextRecordZoneChangeBatch(        _ context: CKSyncEngine.SendChangesContext,        syncEngine: CKSyncEngine    ) async -> CKSyncEngine.RecordZoneChangeBatch? {        let pending = syncEngine.state.pendingRecordZoneChanges            .filter { context.options.zoneIDs.contains($0) }        return await CKSyncEngine.RecordZoneChangeBatch(            pendingChanges: pending        ) { recordID in self.recordToSend(for: recordID) }    }}
// Schedule changeslet zoneID = CKRecordZone.ID(zoneName: "NotesZone")let recordID = CKRecord.ID(recordName: noteID, zoneID: zoneID)syncEngine.state.add(pendingRecordZoneChanges: [.saveRecord(recordID)])
// Trigger immediate sync (pull-to-refresh)try await syncEngine.fetchChanges()try await syncEngine.sendChanges()

import SwiftData
@Modelclass Note {    var title: String    var body: String?    var createdAt: Date?    @Attribute(.externalStorage) var imageData: Data?
    init(title: String, body: String? = nil) {        self.title = title        self.body = body        self.createdAt = Date()    }}
let config = ModelConfiguration(    "Notes",    cloudKitDatabase: .private("iCloud.com.example.app"))let container = try ModelContainer(for: Note.self, configurations: config)

let kvStore = NSUbiquitousKeyValueStore.default
// WritekvStore.set("dark", forKey: "theme")kvStore.set(14.0, forKey: "fontSize")kvStore.set(true, forKey: "notificationsEnabled")kvStore.synchronize()
// Readlet theme = kvStore.string(forKey: "theme") ?? "system"
// Observe external changesNotificationCenter.default.addObserver(    forName: NSUbiquitousKeyValueStore.didChangeExternallyNotification,    object: kvStore, queue: .main) { notification in    guard let userInfo = notification.userInfo,          let reason = userInfo[NSUbiquitousKeyValueStoreChangeReasonKey] as? Int,          let keys = userInfo[NSUbiquitousKeyValueStoreChangedKeysKey] as? [String]    else { return }
    switch reason {    case NSUbiquitousKeyValueStoreServerChange:        for key in keys { applyRemoteChange(key: key) }    case NSUbiquitousKeyValueStoreInitialSyncChange:        reloadAllSettings()    case NSUbiquitousKeyValueStoreQuotaViolationChange:        handleQuotaExceeded()    default: break    }}

Task.detached {    guard let ubiquityURL = FileManager.default.url(        forUbiquityContainerIdentifier: "iCloud.com.example.app"    ) else { return }  // iCloud not available
    let docsURL = ubiquityURL.appendingPathComponent("Documents")    try FileManager.default.createDirectory(at: docsURL, withIntermediateDirectories: true)    let cloudURL = docsURL.appendingPathComponent("report.pdf")    try FileManager.default.setUbiquitous(true, itemAt: localURL, destinationURL: cloudURL)}

func checkiCloudStatus() async throws -> CKAccountStatus {    let status = try await CKContainer.default().accountStatus()    switch status {    case .available: return status    case .noAccount: throw SyncError.noiCloudAccount    case .restricted: throw SyncError.restricted    case .temporarilyUnavailable: throw SyncError.temporarilyUnavailable    case .couldNotDetermine: throw SyncError.unknown    @unknown default: throw SyncError.unknown    }}

func handleCloudKitError(_ error: Error) {    guard let ckError = error as? CKError else { return }    switch ckError.code {    case .networkFailure, .networkUnavailable:        scheduleRetryWhenOnline()    case .serverRecordChanged:        resolveConflict(ckError)    case .requestRateLimited, .zoneBusy, .serviceUnavailable:        let delay = ckError.retryAfterSeconds ?? 3.0        scheduleRetry(after: delay)    case .quotaExceeded:        notifyUserStorageFull()    case .partialFailure:        if let partial = ckError.partialErrorsByItemID {            for (_, itemError) in partial { handleCloudKitError(itemError) }        }    case .changeTokenExpired:        resetChangeToken()    case .userDeletedZone:        recreateZoneAndResync()    default: logError(ckError)    }}

func resolveConflict(_ error: CKError) {    guard error.code == .serverRecordChanged,          let ancestor = error.ancestorRecord,          let client = error.clientRecord,          let server = error.serverRecord    else { return }
    // Merge client changes into server record    for key in client.changedKeys() {        if server[key] == ancestor[key] {            server[key] = client[key]           // Server unchanged, use client        } else if client[key] == ancestor[key] {            // Client unchanged, keep server (already there)        } else {            server[key] = mergeValues(          // Both changed, custom merge                ancestor: ancestor[key], client: client[key], server: server[key])        }    }
    Task { try await CKContainer.default().privateCloudDatabase.save(server) }}