CloudKit 参考指南：SwiftData、CKSyncEngine 与原始 API 结构化数据同步

axiom-cloudkit-ref by charleswiltgen/axiom

172 周安装量

716 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/charleswiltgen/axiom --skill axiom-cloudkit-ref

iOS 云服务 Swift

🇨🇳中文介绍

CloudKit 参考

用途：基于数据库的 iCloud 存储和同步的全面 CloudKit 参考 可用性：iOS 10.0+（基础功能），iOS 17.0+（CKSyncEngine），iOS 17.0+（SwiftData 集成）背景：通过 CKSyncEngine（WWDC 2023）或 SwiftData 集成的现代 CloudKit 同步

何时使用此技能

在以下情况时使用此技能：

实现结构化数据同步到 iCloud
在 SwiftData+CloudKit、CKSyncEngine 或原始 CloudKit API 之间进行选择
设置公共/私有/共享数据库
实现冲突解决
调试 CloudKit 同步问题
监控 CloudKit 性能

不适用于：简单文件同步（请改用 axiom-icloud-drive-ref）

概述

CloudKit 用于结构化数据同步（具有关联关系的记录），而非简单文件同步。

三种现代方法：

SwiftData + CloudKit（最简单，iOS 17+）
CKSyncEngine（自定义持久化，iOS 17+，WWDC 2023）
原始 CloudKit API（最大控制权，更复杂）

方法一：SwiftData + CloudKit（推荐）

何时使用：使用 SwiftData 模型的 iOS 17+ 应用

限制：

仅限私有数据库（无公共/共享数据库）

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

相关 Skills

Azure RBAC 权限管理工具：查找最小角色、创建自定义角色与自动化分配

131,500 周安装

Azure Data Explorer (Kusto) 查询技能：KQL数据分析、日志遥测与时间序列处理

130,600 周安装

Azure 配额管理指南：服务限制、容量验证与配额增加方法

107,600 周安装

Azure 升级评估与自动化工具 - 轻松迁移 Functions 计划、托管层级和 SKU

96,200 周安装

适用 SwiftData 约束

// ✅ 正确：启用 CloudKit 同步的 SwiftData import SwiftData

@Model class Task { var title: String var isCompleted: Bool var dueDate: Date

init(title: String, isCompleted: Bool = false, dueDate: Date) {
    self.title = title
    self.isCompleted = isCompleted
    self.dueDate = dueDate
}

}

// 配置 CloudKit 容器 let container = try ModelContainer( for: Task.self, configurations: ModelConfiguration( cloudKitDatabase: .private("iCloud.com.example.app") ) )

// 完成！同步自动进行

自动管理获取/上传周期
处理冲突
管理账户变更

推荐使用，而非手动 CKDatabase 操作

// ✅ 正确：CKSyncEngine 设置 import CloudKit

class SyncManager { let syncEngine: CKSyncEngine

init() throws {
    let config = CKSyncEngine.Configuration(
        database: CKContainer.default().privateCloudDatabase,
        stateSerialization: loadSyncState(),
        delegate: self
    )

    syncEngine = try CKSyncEngine(config)
}

// 实现委托方法

}

extension SyncManager: CKSyncEngineDelegate { // 处理事件 func handleEvent(_ event: CKSyncEngine.Event, syncEngine: CKSyncEngine) async { switch event { case .stateUpdate(let stateUpdate): saveSyncState(stateUpdate.stateSerialization)

    case .accountChange(let change):
        handleAccountChange(change)

    case .fetchedDatabaseChanges(let changes):
        applyDatabaseChanges(changes)

    case .fetchedRecordZoneChanges(let changes):
        applyRecordChanges(changes)

    case .sentRecordZoneChanges(let changes):
        handleSentChanges(changes)

    case .willFetchChanges, .didFetchChanges,
         .willSendChanges, .didSendChanges:
        // 可选的生命周期事件
        break

    @unknown default:
        break
    }
}

// 要发送的下一批更改
func nextRecordZoneChangeBatch(
    _ context: CKSyncEngine.SendChangesContext,
    syncEngine: CKSyncEngine
) async -> CKSyncEngine.RecordZoneChangeBatch? {
    // 返回待处理的本地更改
    let pendingChanges = getPendingLocalChanges()
    return CKSyncEngine.RecordZoneChangeBatch(
        pendingSaves: pendingChanges,
        recordIDsToDelete: []
    )
}

}

CKContainer — 入口点
CKDatabase — 公共/私有/共享范围
CKRecord — 单个数据记录
CKRecordZone — 逻辑分组
CKAsset — 二进制文件存储

// ✅ 容器和数据库
let container = CKContainer.default()
let privateDatabase = container.privateCloudDatabase
let publicDatabase = container.publicCloudDatabase

// ✅ 创建记录
let record = CKRecord(recordType: "Task")
record["title"] = "Buy groceries"
record["isCompleted"] = false
record["dueDate"] = Date()

// ✅ 保存记录
try await privateDatabase.save(record)

// ✅ 获取记录
let recordID = CKRecord.ID(recordName: "task-123")
let fetchedRecord = try await privateDatabase.record(for: recordID)

// ✅ 查询记录
let predicate = NSPredicate(format: "isCompleted == NO")
let query = CKQuery(recordType: "Task", predicate: predicate)
let (matchResults, _) = try await privateDatabase.records(matching: query)

for result in matchResults {
    if case .success(let record) = result.1 {
        print("Task: \(record["title"] as? String ?? "")")
    }
}

// ✅ 删除记录
try await privateDatabase.deleteRecord(withID: recordID)

// ✅ 获取-然后修改-然后保存（防止 serverRecordChanged 错误）
let record = try await privateDatabase.record(for: recordID)
record["title"] = "Updated title"
record["isCompleted"] = true
try await privateDatabase.save(record)

// ✅ 批量修改（在一个操作中保存 + 删除）
let operation = CKModifyRecordsOperation(
    recordsToSave: [updatedRecord1, updatedRecord2],
    recordIDsToDelete: [deletedID]
)
operation.perRecordSaveBlock = { recordID, result in
    switch result {
    case .success: print("Saved: \(recordID)")
    case .failure(let error): print("Failed: \(recordID) — \(error)")
    }
}
try await privateDatabase.add(operation)

// ✅ 使用 savePolicy 处理冲突
let operation = CKModifyRecordsOperation(
    recordsToSave: [record],
    recordIDsToDelete: nil
)

// 仅当服务器版本未更改时保存
operation.savePolicy = .ifServerRecordUnchanged

// 或者：始终覆盖服务器
operation.savePolicy = .changedKeys  // 仅更改的字段

operation.modifyRecordsResultBlock = { result in
    switch result {
    case .success:
        print("Saved")
    case .failure(let error as CKError):
        if error.code == .serverRecordChanged {
            // 冲突 - 手动合并
            let serverRecord = error.serverRecord
            let clientRecord = error.clientRecord
            let merged = mergeRecords(server: serverRecord, client: clientRecord)
            // 使用合并后的记录重试
        }
    }
}

privateDatabase.add(operation)

范围	可访问性	SwiftData 支持	使用场景
私有	仅限用户	✅ 是	个人用户数据
公共	所有用户	❌ 否	共享/公共内容
共享	受邀用户	❌ 否	协作

// ✅ 将文件存储为 CKAsset
let imageURL = saveImageToTempFile(image)  // 必须是文件 URL
let asset = CKAsset(fileURL: imageURL)

let record = CKRecord(recordType: "Photo")
record["image"] = asset
record["caption"] = "Sunset"

try await privateDatabase.save(record)

// ✅ 检索资源
let fetchedRecord = try await privateDatabase.record(for: recordID)
if let asset = fetchedRecord["image"] as? CKAsset,
   let fileURL = asset.fileURL {
    let imageData = try Data(contentsOf: fileURL)
    let image = UIImage(data: imageData)
}

// ✅ 使用 CKServerChangeToken 进行增量获取
func fetchChanges(since token: CKServerChangeToken?) async throws {
    let zoneID = CKRecordZone.ID(zoneName: "Tasks")

    let config = CKFetchRecordZoneChangesOperation.ZoneConfiguration(
        previousServerChangeToken: token
    )

    let operation = CKFetchRecordZoneChangesOperation(
        recordZoneIDs: [zoneID],
        configurationsByRecordZoneID: [zoneID: config]
    )

    operation.recordWasChangedBlock = { recordID, result in
        if case .success(let record) = result {
            updateLocalDatabase(with: record)
        }
    }

    operation.recordWithIDWasDeletedBlock = { recordID, _ in
        deleteFromLocalDatabase(recordID)
    }

    operation.recordZoneFetchResultBlock = { zoneID, result in
        if case .success(let (token, _, _)) = result {
            saveChangeToken(token)  // 用于下次获取
        }
    }

    try await privateDatabase.add(operation)
}

// ✅ 当匹配查询的记录变更时获取通知
let predicate = NSPredicate(format: "priority > 3")
let subscription = CKQuerySubscription(
    recordType: "Task",
    predicate: predicate,
    subscriptionID: "high-priority-tasks",
    options: [.firesOnRecordCreation, .firesOnRecordUpdate, .firesOnRecordDeletion]
)

let notificationInfo = CKSubscription.NotificationInfo()
notificationInfo.alertBody = "High priority task changed"
notificationInfo.shouldBadge = true
subscription.notificationInfo = notificationInfo

try await privateDatabase.save(subscription)

// ✅ 与其他用户共享记录
let record = try await privateDatabase.record(for: recordID)

// 记录必须在自定义区域中（非默认区域）
let share = CKShare(rootRecord: record)
share[CKShare.SystemFieldKey.title] = "Shared Task List"
share.publicPermission = .none  // 仅限邀请

// 同时保存记录和共享
let operation = CKModifyRecordsOperation(
    recordsToSave: [record, share],
    recordIDsToDelete: nil
)
try await privateDatabase.add(operation)

import CloudKit
import UIKit

// ✅ UIKit 共享控制器
let sharingController = UICloudSharingController(share: share, container: container)
sharingController.delegate = self
present(sharingController, animated: true)

// 委托方法
extension ViewController: UICloudSharingControllerDelegate {
    func cloudSharingController(_ csc: UICloudSharingController,
                                failedToSaveShareWithError error: Error) {
        print("Share failed: \(error)")
    }

    func itemTitle(for csc: UICloudSharingController) -> String? {
        return "My Shared List"
    }
}

// 在 SceneDelegate 或 AppDelegate 中
func userDidAcceptCloudKitShareWith(_ cloudKitShareMetadata: CKShare.Metadata) {
    let operation = CKAcceptSharesOperation(shareMetadatas: [cloudKitShareMetadata])
    operation.acceptSharesResultBlock = { result in
        switch result {
        case .success: print("Share accepted")
        case .failure(let error): print("Accept failed: \(error)")
        }
    }
    CKContainer(identifier: cloudKitShareMetadata.containerIdentifier)
        .add(operation)
}

任务	现代 API (iOS 17+)	旧版 API
结构化数据同步	SwiftData + CloudKit	CKSyncEngine 或 CKDatabase
自定义持久化同步	CKSyncEngine	CKDatabase
冲突解决	自动（SwiftData/CKSyncEngine）	手动（savePolicy）
账户变更	自动处理	手动检测
监控	CloudKit 控制台遥测	手动日志记录

🇺🇸English

CloudKit Reference

Purpose : Comprehensive CloudKit reference for database-based iCloud storage and sync Availability : iOS 10.0+ (basic), iOS 17.0+ (CKSyncEngine), iOS 17.0+ (SwiftData integration) Context : Modern CloudKit sync via CKSyncEngine (WWDC 2023) or SwiftData integration

When to Use This Skill

Use this skill when:

Implementing structured data sync to iCloud
Choosing between SwiftData+CloudKit, CKSyncEngine, or raw CloudKit APIs
Setting up public/private/shared databases
Implementing conflict resolution
Debugging CloudKit sync issues
Monitoring CloudKit performance

NOT for : Simple file sync (use axiom-icloud-drive-ref instead)

Overview

CloudKit is for STRUCTURED DATA sync (records with relationships), not simple file sync.

Three modern approaches:

SwiftData + CloudKit (Easiest, iOS 17+)
CKSyncEngine (Custom persistence, iOS 17+, WWDC 2023)
Raw CloudKit APIs (Maximum control, more complexity)

Approach 1: SwiftData + CloudKit (Recommended)

When to use : iOS 17+ apps with SwiftData models

Limitations :

Private database only (no public/shared)
Automatic sync (less control)
SwiftData constraints apply

// ✅ CORRECT: SwiftData with CloudKit sync import SwiftData

@Model class Task { var title: String var isCompleted: Bool var dueDate: Date
```
init(title: String, isCompleted: Bool = false, dueDate: Date) {
    self.title = title
    self.isCompleted = isCompleted
    self.dueDate = dueDate
}
```
}

// Configure CloudKit container let container = try ModelContainer( for: Task.self, configurations: ModelConfiguration( cloudKitDatabase: .private("iCloud.com.example.app") ) )

// That's it! Sync happens automatically

Entitlements required :

iCloud capability
CloudKit container

Useaxiom-swiftdata skill for SwiftData details

Approach 2: CKSyncEngine (Modern, WWDC 2023)

When to use : Custom persistence (SQLite, GRDB, JSON) with cloud sync

Advantages over raw CloudKit :

Manages fetch/upload cycles automatically
Handles conflicts
Manages account changes

Recommended over manual CKDatabase operations

// ✅ CORRECT: CKSyncEngine setup import CloudKit

class SyncManager { let syncEngine: CKSyncEngine

init() throws {
    let config = CKSyncEngine.Configuration(
        database: CKContainer.default().privateCloudDatabase,
        stateSerialization: loadSyncState(),
        delegate: self
    )

    syncEngine = try CKSyncEngine(config)
}

// Implement delegate methods

}

extension SyncManager: CKSyncEngineDelegate { // Handle events func handleEvent(_ event: CKSyncEngine.Event, syncEngine: CKSyncEngine) async { switch event { case .stateUpdate(let stateUpdate): saveSyncState(stateUpdate.stateSerialization)

    case .accountChange(let change):
        handleAccountChange(change)

    case .fetchedDatabaseChanges(let changes):
        applyDatabaseChanges(changes)

    case .fetchedRecordZoneChanges(let changes):
        applyRecordChanges(changes)

    case .sentRecordZoneChanges(let changes):
        handleSentChanges(changes)

    case .willFetchChanges, .didFetchChanges,
         .willSendChanges, .didSendChanges:
        // Optional lifecycle events
        break

    @unknown default:
        break
    }
}

// Next batch of changes to send
func nextRecordZoneChangeBatch(
    _ context: CKSyncEngine.SendChangesContext,
    syncEngine: CKSyncEngine
) async -> CKSyncEngine.RecordZoneChangeBatch? {
    // Return pending local changes
    let pendingChanges = getPendingLocalChanges()
    return CKSyncEngine.RecordZoneChangeBatch(
        pendingSaves: pendingChanges,
        recordIDsToDelete: []
    )
}

Key concepts :

State serialization : Persist sync state between app launches
Events : Delegate receives events for changes
Batches : You provide pending changes, engine uploads them
Automatic conflict resolution : Engine handles basic conflicts

Approach 3: Raw CloudKit APIs (Legacy)

When to use : Only if CKSyncEngine doesn't fit (rare)

Core types :

CKContainer — Entry point
CKDatabase — Public/private/shared scope
CKRecord — Individual data record
CKRecordZone — Logical grouping
CKAsset — Binary file storage

Basic Operations

// ✅ Container and database
let container = CKContainer.default()
let privateDatabase = container.privateCloudDatabase
let publicDatabase = container.publicCloudDatabase

// ✅ Create record
let record = CKRecord(recordType: "Task")
record["title"] = "Buy groceries"
record["isCompleted"] = false
record["dueDate"] = Date()

// ✅ Save record
try await privateDatabase.save(record)

// ✅ Fetch record
let recordID = CKRecord.ID(recordName: "task-123")
let fetchedRecord = try await privateDatabase.record(for: recordID)

// ✅ Query records
let predicate = NSPredicate(format: "isCompleted == NO")
let query = CKQuery(recordType: "Task", predicate: predicate)
let (matchResults, _) = try await privateDatabase.records(matching: query)

for result in matchResults {
    if case .success(let record) = result.1 {
        print("Task: \(record["title"] as? String ?? "")")
    }
}

// ✅ Delete record
try await privateDatabase.deleteRecord(withID: recordID)

Update Record

// ✅ Fetch-then-modify-then-save (prevents serverRecordChanged errors)
let record = try await privateDatabase.record(for: recordID)
record["title"] = "Updated title"
record["isCompleted"] = true
try await privateDatabase.save(record)

// ✅ Batch modify (save + delete in one operation)
let operation = CKModifyRecordsOperation(
    recordsToSave: [updatedRecord1, updatedRecord2],
    recordIDsToDelete: [deletedID]
)
operation.perRecordSaveBlock = { recordID, result in
    switch result {
    case .success: print("Saved: \(recordID)")
    case .failure(let error): print("Failed: \(recordID) — \(error)")
    }
}
try await privateDatabase.add(operation)

Conflict Resolution

// ✅ Handle conflicts with savePolicy
let operation = CKModifyRecordsOperation(
    recordsToSave: [record],
    recordIDsToDelete: nil
)

// Save only if server version unchanged
operation.savePolicy = .ifServerRecordUnchanged

// OR: Always overwrite server
operation.savePolicy = .changedKeys  // Only changed fields

operation.modifyRecordsResultBlock = { result in
    switch result {
    case .success:
        print("Saved")
    case .failure(let error as CKError):
        if error.code == .serverRecordChanged {
            // Conflict - merge manually
            let serverRecord = error.serverRecord
            let clientRecord = error.clientRecord
            let merged = mergeRecords(server: serverRecord, client: clientRecord)
            // Retry with merged record
        }
    }
}

privateDatabase.add(operation)

Database Scopes

Scope	Accessibility	SwiftData Support	Use Case
Private	User only	✅ Yes	Personal user data
Public	All users	❌ No	Shared/public content
Shared	Invited users	❌ No	Collaboration

Private Database

// ✅ Private database (most common)
let privateDB = CKContainer.default().privateCloudDatabase

// User must be signed into iCloud
// Data syncs across user's devices
// Not visible to other users

Public Database

// ✅ Public database (for shared content)
let publicDB = CKContainer.default().publicCloudDatabase

// Accessible to all app users
// Even unauthenticated users can read
// Writes require authentication
// Use for: Leaderboards, public content, discovery

Shared Database

// ✅ Shared database (collaboration)
let sharedDB = CKContainer.default().sharedCloudDatabase

// For CKShare-based collaboration
// Users invited to specific record zones
// Use for: Shared documents, team data

CloudKit Assets (Files)

// ✅ Store files as CKAsset
let imageURL = saveImageToTempFile(image)  // Must be file URL
let asset = CKAsset(fileURL: imageURL)

let record = CKRecord(recordType: "Photo")
record["image"] = asset
record["caption"] = "Sunset"

try await privateDatabase.save(record)

// ✅ Retrieve asset
let fetchedRecord = try await privateDatabase.record(for: recordID)
if let asset = fetchedRecord["image"] as? CKAsset,
   let fileURL = asset.fileURL {
    let imageData = try Data(contentsOf: fileURL)
    let image = UIImage(data: imageData)
}

Important : CKAsset requires a file URL , not Data. Write data to temp file first.

CloudKit Console (Monitoring - WWDC 2024)

Developer Notifications

Set up alerts for:

Schema changes
Quota exceeded
High error rates
Custom thresholds

Telemetry

Monitor:

Request count
Error rate
Latency (p50, p95, p99)
Bandwidth usage

Logs

View:

Individual requests
Error details
Performance bottlenecks

Access : https://icloud.developer.apple.com/dashboard

Common Patterns

Pattern 1: Initial Sync

// ✅ Fetch all records on first launch
func performInitialSync() async throws {
    let predicate = NSPredicate(value: true)  // All records
    let query = CKQuery(recordType: "Task", predicate: predicate)

    let (results, _) = try await privateDatabase.records(matching: query)

    for result in results {
        if case .success(let record) = result.1 {
            saveToLocalDatabase(record)
        }
    }
}

Pattern 2: Incremental Sync

// ✅ Use CKServerChangeToken for incremental fetches
func fetchChanges(since token: CKServerChangeToken?) async throws {
    let zoneID = CKRecordZone.ID(zoneName: "Tasks")

    let config = CKFetchRecordZoneChangesOperation.ZoneConfiguration(
        previousServerChangeToken: token
    )

    let operation = CKFetchRecordZoneChangesOperation(
        recordZoneIDs: [zoneID],
        configurationsByRecordZoneID: [zoneID: config]
    )

    operation.recordWasChangedBlock = { recordID, result in
        if case .success(let record) = result {
            updateLocalDatabase(with: record)
        }
    }

    operation.recordWithIDWasDeletedBlock = { recordID, _ in
        deleteFromLocalDatabase(recordID)
    }

    operation.recordZoneFetchResultBlock = { zoneID, result in
        if case .success(let (token, _, _)) = result {
            saveChangeToken(token)  // For next fetch
        }
    }

    try await privateDatabase.add(operation)
}

Entitlements

Required entitlements in Xcode:

<!-- iCloud capability -->
<key>com.apple.developer.icloud-services</key>
<array>
    <string>CloudKit</string>
</array>

<!-- CloudKit container -->
<key>com.apple.developer.icloud-container-identifiers</key>
<array>
    <string>iCloud.com.example.app</string>
</array>

Setup :

Xcode → Target → Signing & Capabilities
"+ Capability" → iCloud
Check "CloudKit"
Select or create container

Subscriptions (Push Notifications)

Database Subscription

// ✅ Get notified of ANY change in private database
let subscription = CKDatabaseSubscription(subscriptionID: "all-changes")

let notificationInfo = CKSubscription.NotificationInfo()
notificationInfo.shouldSendContentAvailable = true  // Silent push
subscription.notificationInfo = notificationInfo

try await privateDatabase.save(subscription)

Query Subscription

// ✅ Get notified when records matching a query change
let predicate = NSPredicate(format: "priority > 3")
let subscription = CKQuerySubscription(
    recordType: "Task",
    predicate: predicate,
    subscriptionID: "high-priority-tasks",
    options: [.firesOnRecordCreation, .firesOnRecordUpdate, .firesOnRecordDeletion]
)

let notificationInfo = CKSubscription.NotificationInfo()
notificationInfo.alertBody = "High priority task changed"
notificationInfo.shouldBadge = true
subscription.notificationInfo = notificationInfo

try await privateDatabase.save(subscription)

Zone Subscription

// ✅ Get notified of any change in a specific zone
let zoneID = CKRecordZone.ID(zoneName: "Tasks")
let subscription = CKRecordZoneSubscription(
    zoneID: zoneID,
    subscriptionID: "tasks-zone"
)

let notificationInfo = CKSubscription.NotificationInfo()
notificationInfo.shouldSendContentAvailable = true
subscription.notificationInfo = notificationInfo

try await privateDatabase.save(subscription)

Handling Push Notifications

// In AppDelegate
func application(_ application: UIApplication,
                 didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async -> UIBackgroundFetchResult {
    let notification = CKNotification(fromRemoteNotificationDictionary: userInfo)

    if notification.subscriptionID == "all-changes" {
        try? await fetchChanges(since: savedChangeToken)
        return .newData
    }
    return .noData
}

Sharing Records

Create a Share

// ✅ Share a record with other users
let record = try await privateDatabase.record(for: recordID)

// Record must be in a custom zone (not default zone)
let share = CKShare(rootRecord: record)
share[CKShare.SystemFieldKey.title] = "Shared Task List"
share.publicPermission = .none  // Invite-only

// Save both the record and share together
let operation = CKModifyRecordsOperation(
    recordsToSave: [record, share],
    recordIDsToDelete: nil
)
try await privateDatabase.add(operation)

Present Sharing UI

import CloudKit
import UIKit

// ✅ UIKit sharing controller
let sharingController = UICloudSharingController(share: share, container: container)
sharingController.delegate = self
present(sharingController, animated: true)

// Delegate methods
extension ViewController: UICloudSharingControllerDelegate {
    func cloudSharingController(_ csc: UICloudSharingController,
                                failedToSaveShareWithError error: Error) {
        print("Share failed: \(error)")
    }

    func itemTitle(for csc: UICloudSharingController) -> String? {
        return "My Shared List"
    }
}

Manage Participants

// ✅ Check participants
for participant in share.participants {
    print("\(participant.userIdentity.nameComponents?.givenName ?? "Unknown")")
    print("  Acceptance: \(participant.acceptanceStatus)")
    print("  Permission: \(participant.permission)")
    // .readOnly, .readWrite, .none
}

// ✅ Remove participant
share.removeParticipant(participant)
try await privateDatabase.save(share)

Accept a Share

// In SceneDelegate or AppDelegate
func userDidAcceptCloudKitShareWith(_ cloudKitShareMetadata: CKShare.Metadata) {
    let operation = CKAcceptSharesOperation(shareMetadatas: [cloudKitShareMetadata])
    operation.acceptSharesResultBlock = { result in
        switch result {
        case .success: print("Share accepted")
        case .failure(let error): print("Accept failed: \(error)")
        }
    }
    CKContainer(identifier: cloudKitShareMetadata.containerIdentifier)
        .add(operation)
}

Quick Reference

Task	Modern API (iOS 17+)	Legacy API
Structured data sync	SwiftData + CloudKit	CKSyncEngine or CKDatabase
Custom persistence sync	CKSyncEngine	CKDatabase
Conflict resolution	Automatic (SwiftData/CKSyncEngine)	Manual (savePolicy)
Account changes	Handled automatically	Manual detection
Monitoring	CloudKit Console telemetry	Manual logging

Related Skills

axiom-swiftdata — SwiftData implementation details
axiom-storage — Choose CloudKit vs iCloud Drive
axiom-icloud-drive-ref — File-based iCloud sync
axiom-cloud-sync-diag — Debug CloudKit sync issues

Last Updated : 2025-12-12 Skill Type : Reference Minimum iOS : 10.0 (basic), 17.0 (CKSyncEngine, SwiftData integration) WWDC Sessions : 2023-10188 (CKSyncEngine), 2024-10122 (CloudKit Console)

Weekly Installs

109

Repository

charleswiltgen/axiom

GitHub Stars

601

First Seen

Jan 21, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

Installed on

opencode93

codex89

claude-code85

gemini-cli85

cursor82

github-copilot80

CloudKit 参考指南：SwiftData、CKSyncEngine 与原始 API 结构化数据同步

🇨🇳中文介绍

CloudKit 参考

何时使用此技能

概述

方法一：SwiftData + CloudKit（推荐）

相关 Skills

方法二：CKSyncEngine（现代，WWDC 2023）

方法三：原始 CloudKit API（旧版）

基本操作

更新记录

冲突解决

数据库范围

私有数据库

公共数据库

共享数据库

CloudKit 资源（文件）

CloudKit 控制台（监控 - WWDC 2024）

开发者通知

遥测

日志

常用模式

模式一：初始同步

模式二：增量同步

权限

订阅（推送通知）

数据库订阅

查询订阅

区域订阅

处理推送通知

共享记录

创建共享

呈现共享界面

管理参与者

接受共享

快速参考

相关技能