Fix numerous concurrency warnings in CloudKit code.

Account/Sources/Account/CloudKit/CloudKitAccountZone.swift

@@ -24,9 +24,9 @@ enum CloudKitAccountZoneError: LocalizedError {
 
 @MainActor final class CloudKitAccountZone: CloudKitZone {
 
-	var zoneID: CKRecordZone.ID
+	let zoneID: CKRecordZone.ID
 
-	var log = OSLog(subsystem: Bundle.main.bundleIdentifier!, category: "CloudKit")
+	let log = OSLog(subsystem: Bundle.main.bundleIdentifier!, category: "CloudKit")
 
     weak var container: CKContainer?
     weak var database: CKDatabase?
@@ -240,7 +240,7 @@ enum CloudKitAccountZoneError: LocalizedError {
 				return try await findOrCreateAccount()
 
 			case .zoneNotFound, .userDeletedZone:
-				try await createZoneRecord()
+				_ = try await createZoneRecord()
 				return try await findOrCreateAccount()
 
 			default:

Account/Sources/Account/CloudKit/CloudKitArticlesZone.swift

@@ -59,7 +59,7 @@ final class CloudKitArticlesZone: CloudKitZone {
 		}
 	}
 
-	init(container: CKContainer) {
+	@MainActor init(container: CKContainer) {
 		self.container = container
 		self.database = container.privateCloudDatabase
 		self.zoneID = CKRecordZone.ID(zoneName: "Articles", ownerName: CKCurrentUserDefaultName)
@@ -73,16 +73,16 @@ final class CloudKitArticlesZone: CloudKitZone {
 				completion(.success(()))
 			case .failure(let error):
 				if case CloudKitZoneError.userDeletedZone = error {
-					self.createZoneRecord() { result in
+
-						switch result {
-						case .success:
 					Task { @MainActor in
+						do {
+							_ = try await self.createZoneRecord()
 							self.refreshArticles(completion: completion)
-							}
+						} catch {
-						case .failure(let error):
 							completion(.failure(error))
 						}
 					}
+
 				} else {
 					completion(.failure(error))
 				}
@@ -174,16 +174,16 @@ private extension CloudKitArticlesZone {
 
 	@MainActor func handleModifyArticlesError(_ error: Error, statusUpdates: [CloudKitArticleStatusUpdate], completion: @escaping ((Result<Void, Error>) -> Void)) {
 		if case CloudKitZoneError.userDeletedZone = error {
-			self.createZoneRecord() { result in
+
-				switch result {
+			Task { @MainActor in
-				case .success:
+				do {
-					MainActor.assumeIsolated {
+					_ = try await self.createZoneRecord()
 					self.modifyArticles(statusUpdates, completion: completion)
-					}
+				} catch {
-				case .failure(let error):
 					completion(.failure(error))
 				}
 			}
+
 		} else {
 			completion(.failure(error))
 		}

CloudKitExtras/Sources/CloudKitExtras/CloudKitError.swift

@@ -94,5 +94,4 @@ public final class CloudKitError: LocalizedError {
 			return NSLocalizedString("Unhandled Error.", comment: "Unknown iCloud Error")
 		}
 	}
-	
 }

CloudKitExtras/Sources/CloudKitExtras/CloudKitZone.swift

@@ -42,9 +42,9 @@ public protocol CloudKitZone: AnyObject {
 
 	var log: OSLog { get }
 
-	var container: CKContainer? { get }
+	@MainActor var container: CKContainer? { get }
-	var database: CKDatabase? { get }
+	@MainActor var database: CKDatabase? { get }
-	var delegate: CloudKitZoneDelegate? { get set }
+	@MainActor var delegate: CloudKitZoneDelegate? { get set }
 
 	/// Reset the change token used to determine what point in time we are doing changes fetches
 	func resetChangeToken()
@@ -59,7 +59,7 @@ public protocol CloudKitZone: AnyObject {
 	func receiveRemoteNotification(userInfo: [AnyHashable : Any]) async
 }
 
-public extension CloudKitZone {
+@MainActor public extension CloudKitZone {
 	
 	// My observation has been that QoS is treated differently for CloudKit operations on macOS vs iOS.
 	// .userInitiated is too aggressive on iOS and can lead the UI slowing down and appearing to block.
@@ -172,7 +172,7 @@ public extension CloudKitZone {
 	}
 
 	/// Retrieves the zone record for this zone only. If the record isn't found it will be created.
-	func fetchZoneRecord(completion: @escaping @Sendable (Result<CKRecordZone?, Error>) -> Void) {
+	@MainActor func fetchZoneRecord(completion: @escaping @Sendable (Result<CKRecordZone?, Error>) -> Void) {
 
 		let op = CKFetchRecordZonesOperation(recordZoneIDs: [zoneID])
 		op.qualityOfService = Self.qualityOfService
@@ -193,6 +193,8 @@ public extension CloudKitZone {
 
 		op.fetchRecordZonesResultBlock = { [weak self] result in
 
+			Task { @MainActor in
+
 				guard let self else {
 					completion(.failure(CloudKitZoneError.unknown))
 					return
@@ -207,21 +209,18 @@ public extension CloudKitZone {
 
 					switch CloudKitZoneResult.resolve(error) {
 					case .zoneNotFound, .userDeletedZone:
-					self.createZoneRecord() { result in
+
-						switch result {
+						do {
-						case .success:
+							let recordZone = try await self.createZoneRecord()
-							self.fetchZoneRecord(completion: completion)
+							completion(.success(recordZone))
-						case .failure(let error):
+						} catch {
-							DispatchQueue.main.async {
 							completion(.failure(error))
 						}
-						}
+
-					}
 					case .retry(let timeToWait):
 						os_log(.error, log: self.log, "%@ zone fetch changes retry in %f seconds.", self.zoneID.zoneName, timeToWait)
-					self.retryIfPossible(after: timeToWait) {
+						await self.delay(for: timeToWait)
 						self.fetchZoneRecord(completion: completion)
-					}
 					default:
 						DispatchQueue.main.async {
 							completion(.failure(CloudKitError(error)))
@@ -229,55 +228,36 @@ public extension CloudKitZone {
 					}
 				}
 			}
+		}
 
 		database?.add(op)
 	}
 
 	/// Creates the zone record
-	func createZoneRecord() async throws {
+	func createZoneRecord() async throws -> CKRecordZone {
 
-		try await withCheckedThrowingContinuation { continuation in
+		guard let database else { throw CloudKitZoneError.unknown }
-			self.createZoneRecord { result in
-				switch result {
-				case .success:
-					continuation.resume()
-				case .failure(let error):
-					continuation.resume(throwing: error)
-				}
-			}
-		}
-	}
 
-	/// Creates the zone record
+		do {
-	func createZoneRecord(completion: @escaping @Sendable (Result<Void, Error>) -> Void) {
+			return try await database.save(CKRecordZone(zoneID: zoneID))
-		guard let database = database else {
+		} catch {
-			completion(.failure(CloudKitZoneError.unknown))
+			throw CloudKitError(error)
-			return
-		}
-
-		database.save(CKRecordZone(zoneID: zoneID)) { (recordZone, error) in
-			if let error = error {
-				DispatchQueue.main.async {
-					completion(.failure(CloudKitError(error)))
-				}
-			} else {
-				DispatchQueue.main.async {
-					completion(.success(()))
-				}
-			}
 		}
 	}
 
 	/// Subscribes to zone changes
 	func subscribeToZoneChanges() {
+
+		Task { @MainActor in
 			let subscription = CKRecordZoneSubscription(zoneID: zoneID, subscriptionID: zoneID.zoneName)
 
 			let info = CKSubscription.NotificationInfo()
 			info.shouldSendContentAvailable = true
 			subscription.notificationInfo = info
 
-		save(subscription) { result in
+			do {
-			if case .failure(let error) = result {
+				_ = try await save(subscription)
+			} catch {
 				os_log(.error, log: self.log, "%@ zone subscribe to changes error: %@", self.zoneID.zoneName, error.localizedDescription)
 			}
 		}
@@ -322,6 +302,8 @@ public extension CloudKitZone {
 		
 		op.queryResultBlock = { [weak self] result in
 
+			Task { @MainActor in
+
 				guard let self else {
 					completion(.failure(CloudKitZoneError.unknown))
 					return
@@ -331,9 +313,7 @@ public extension CloudKitZone {
 
 				case .success(let cursor):
 					if let cursor {
-					Task { @MainActor in
 						self.query(cursor: cursor, desiredKeys: desiredKeys, carriedRecords: records, completion: completion)
-					}
 					} else {
 						completion(.success(records))
 					}
@@ -343,34 +323,22 @@ public extension CloudKitZone {
 					switch CloudKitZoneResult.resolve(error) {
 
 					case .zoneNotFound:
-					self.createZoneRecord() { result in
+						do {
-						switch result {
+							_ = try await self.createZoneRecord()
-						case .success:
-							Task { @MainActor in
 							self.query(ckQuery, desiredKeys: desiredKeys, completion: completion)
-							}
+						} catch {
-						case .failure(let error):
-							DispatchQueue.main.async {
 							completion(.failure(error))
 						}
-						}
-					}
 
 					case .retry(let timeToWait):
 						os_log(.error, log: self.log, "%@ zone query retry in %f seconds.", self.zoneID.zoneName, timeToWait)
-					self.retryIfPossible(after: timeToWait) {
+						await self.delay(for: timeToWait)
-						Task { @MainActor in
 						self.query(ckQuery, desiredKeys: desiredKeys, completion: completion)
-						}
-					}
 
 					case .userDeletedZone:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitZoneError.userDeletedZone))
-					}
 
 					default:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitError(error)))
 					}
 				}
@@ -419,6 +387,8 @@ public extension CloudKitZone {
 
 		op.queryResultBlock = { [weak self] result in
 
+			Task { @MainActor in
+
 				guard let self else {
 					completion(.failure(CloudKitZoneError.unknown))
 					return
@@ -427,43 +397,34 @@ public extension CloudKitZone {
 				switch result {
 
 				case .success(let newCursor):
-				Task { @MainActor in
 					if let newCursor = newCursor {
 						self.query(cursor: newCursor, desiredKeys: desiredKeys, carriedRecords: records, completion: completion)
 					} else {
 						completion(.success(records))
 					}
-				}
 
 				case .failure(let error):
 
 					switch CloudKitZoneResult.resolve(error) {
+
 					case .zoneNotFound:
-					self.createZoneRecord() { result in
+
-						switch result {
+						do {
-						case .success:
+							_ = try await self.createZoneRecord()
-							Task { @MainActor in
 							self.query(cursor: cursor, desiredKeys: desiredKeys, carriedRecords: records, completion: completion)
-							}
+						} catch {
-						case .failure(let error):
-							DispatchQueue.main.async {
 							completion(.failure(error))
 						}
-						}
+
-					}
 					case .retry(let timeToWait):
 						os_log(.error, log: self.log, "%@ zone query retry in %f seconds.", self.zoneID.zoneName, timeToWait)
-					self.retryIfPossible(after: timeToWait) {
+						await self.delay(for: timeToWait)
-						Task { @MainActor in
 						self.query(cursor: cursor, desiredKeys: desiredKeys, carriedRecords: records, completion: completion)
-						}
+
-					}
 					case .userDeletedZone:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitZoneError.userDeletedZone))
-					}
+
 					default:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitError(error)))
 					}
 				}
@@ -498,42 +459,41 @@ public extension CloudKitZone {
 		let recordID = CKRecord.ID(recordName: externalID, zoneID: zoneID)
 		
 		database?.fetch(withRecordID: recordID) { [weak self] record, error in
-			guard let self = self else {
+
+			guard let self else {
 				completion(.failure(CloudKitZoneError.unknown))
 				return
 			}
 
+			Task { @MainActor in
+
 				switch CloudKitZoneResult.resolve(error) {
+
 				case .success:
-				DispatchQueue.main.async {
+					if let record {
-					if let record = record {
 						completion(.success(record))
 					} else {
 						completion(.failure(CloudKitZoneError.unknown))
 					}
-				}
+
 				case .zoneNotFound:
-				self.createZoneRecord() { result in
+
-					switch result {
+					do {
-					case .success:
+						_ = try await self.createZoneRecord()
 						self.fetch(externalID: externalID, completion: completion)
-					case .failure(let error):
+					} catch {
-						DispatchQueue.main.async {
 						completion(.failure(error))
 					}
-					}
+
-				}
 				case .retry(let timeToWait):
 					os_log(.error, log: self.log, "%@ zone fetch retry in %f seconds.", self.zoneID.zoneName, timeToWait)
 					self.retryIfPossible(after: timeToWait) {
 						self.fetch(externalID: externalID, completion: completion)
 					}
 				case .userDeletedZone:
-				DispatchQueue.main.async {
 					completion(.failure(CloudKitZoneError.userDeletedZone))
-				}
+
 				default:
-				DispatchQueue.main.async {
 					completion(.failure(CloudKitError(error!)))
 				}
 			}
@@ -610,6 +570,8 @@ public extension CloudKitZone {
 				return
 			}
 
+			Task { @MainActor in
+
 				switch result {
 
 				case .success:
@@ -619,26 +581,19 @@ public extension CloudKitZone {
 
 					switch CloudKitZoneResult.resolve(error) {
 					case .success, .partialFailure:
-					DispatchQueue.main.async {
 						completion(.success(()))
-					}
 
 					case .zoneNotFound:
-					self.createZoneRecord() { result in
+
-						switch result {
+						do {
-						case .success:
+							_ = try await self.createZoneRecord()
 							self.saveIfNew(records, completion: completion)
-						case .failure(let error):
+						} catch {
-							DispatchQueue.main.async {
 							completion(.failure(error))
 						}
-						}
-					}
 
 					case .userDeletedZone:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitZoneError.userDeletedZone))
-					}
 
 					case .retry(let timeToWait):
 						self.retryIfPossible(after: timeToWait) {
@@ -649,7 +604,7 @@ public extension CloudKitZone {
 
 						var chunkedRecords = records.chunked(into: 200)
 
-					func saveChunksIfNew() {
+						@MainActor func saveChunksIfNew() {
 							if let records = chunkedRecords.popLast() {
 								self.saveIfNew(records) { result in
 									switch result {
@@ -668,7 +623,6 @@ public extension CloudKitZone {
 						saveChunksIfNew()
 
 					default:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitError(error)))
 					}
 				}
@@ -681,52 +635,26 @@ public extension CloudKitZone {
 	/// Save the CKSubscription
 	func save(_ subscription: CKSubscription) async throws -> CKSubscription {
 
-		try await withCheckedThrowingContinuation { continuation in
+		guard let database else { throw CloudKitZoneError.unknown }
-			self.save(subscription) { result in
-				switch result {
-				case .success(let subscription):
-					continuation.resume(returning: subscription)
-				case .failure(let error):
-					continuation.resume(throwing: error)
-				}
-			}
-		}
-	}
 
-	/// Save the CKSubscription
+		do {
-	func save(_ subscription: CKSubscription, completion: @escaping @Sendable (Result<CKSubscription, Error>) -> Void) {
+			return try await database.save(subscription)
-		database?.save(subscription) { [weak self] savedSubscription, error in
 
-			guard let self else {
+		} catch {
-				completion(.failure(CloudKitZoneError.unknown))
-				return
-			}
 
 			switch CloudKitZoneResult.resolve(error) {
-			case .success:
+
-				DispatchQueue.main.async {
-					completion(.success((savedSubscription!)))
-				}
 			case .zoneNotFound:
-				self.createZoneRecord() { result in
+				_ = try await createZoneRecord()
-					switch result {
+				return try await save(subscription)
-					case .success:
+
-						self.save(subscription, completion: completion)
-					case .failure(let error):
-						DispatchQueue.main.async {
-							completion(.failure(error))
-						}
-					}
-				}
 			case .retry(let timeToWait):
 				os_log(.error, log: self.log, "%@ zone save subscription retry in %f seconds.", self.zoneID.zoneName, timeToWait)
-				self.retryIfPossible(after: timeToWait) {
+				await delay(for: timeToWait)
-					self.save(subscription, completion: completion)
+				return try await save(subscription)
-				}
+
 			default:
-				DispatchQueue.main.async {
+				throw CloudKitError(error)
-					completion(.failure(CloudKitError(error!)))
-				}
 			}
 		}
 	}
@@ -938,24 +866,32 @@ public extension CloudKitZone {
 
 	/// Delete a CKSubscription
 	func delete(subscriptionID: String, completion: @escaping @Sendable (Result<Void, Error>) -> Void) {
-		database?.delete(withSubscriptionID: subscriptionID) { [weak self] _, error in
+
-			guard let self = self else {
+		guard let database else {
 			completion(.failure(CloudKitZoneError.unknown))
 			return
 		}
 
-			switch CloudKitZoneResult.resolve(error) {
+		database.delete(withSubscriptionID: subscriptionID) { [weak self] _, error in
-			case .success:
+
-				DispatchQueue.main.async {
+			guard let self else {
-					completion(.success(()))
+				completion(.failure(CloudKitZoneError.unknown))
+				return
 			}
+
+			Task { @MainActor in
+
+				switch CloudKitZoneResult.resolve(error) {
+
+				case .success:
+					completion(.success(()))
+
 				case .retry(let timeToWait):
 					os_log(.error, log: self.log, "%@ zone delete subscription retry in %f seconds.", self.zoneID.zoneName, timeToWait)
-				self.retryIfPossible(after: timeToWait) {
+					await self.delay(for: timeToWait)
 					self.delete(subscriptionID: subscriptionID, completion: completion)
-				}
+
 				default:
-				DispatchQueue.main.async {
 					completion(.failure(CloudKitError(error!)))
 				}
 			}
@@ -1014,16 +950,16 @@ public extension CloudKitZone {
 						completion(.success(()))
 					}
 				case .zoneNotFound:
-					self.createZoneRecord() { result in
+
-						switch result {
+					Task { @MainActor in
-						case .success:
+						do {
+							_ = try await self.createZoneRecord()
 							self.modify(recordsToSave: recordsToSave, recordIDsToDelete: recordIDsToDelete, completion: completion)
-						case .failure(let error):
+						} catch {
-							DispatchQueue.main.async {
 							completion(.failure(error))
 						}
 					}
-					}
+
 				case .userDeletedZone:
 					DispatchQueue.main.async {
 						completion(.failure(CloudKitZoneError.userDeletedZone))
@@ -1040,12 +976,13 @@ public extension CloudKitZone {
 					func saveChunks(completion: @escaping (Result<Void, Error>) -> Void) {
 						if !recordToSaveChunks.isEmpty {
 							let records = recordToSaveChunks.removeFirst()
-							self.modify(recordsToSave: records, recordIDsToDelete: []) { result in
+
-								switch result {
+							Task { @MainActor in
-								case .success:
+								do {
+									try await self.modify(recordsToSave: records, recordIDsToDelete: [])
 									os_log(.info, log: self.log, "Saved %d chunked records.", records.count)
 									saveChunks(completion: completion)
-								case .failure(let error):
+								} catch {
 									completion(.failure(error))
 								}
 							}
@@ -1057,17 +994,18 @@ public extension CloudKitZone {
 					func deleteChunks() {
 						if !recordIDsToDeleteChunks.isEmpty {
 							let records = recordIDsToDeleteChunks.removeFirst()
-							self.modify(recordsToSave: [], recordIDsToDelete: records) { result in
+
-								switch result {
+							Task { @MainActor in
-								case .success:
+
+								do {
+									try await self.modify(recordsToSave: [], recordIDsToDelete: records)
 									os_log(.info, log: self.log, "Deleted %d chunked records.", records.count)
 									deleteChunks()
-								case .failure(let error):
+								} catch {
-									DispatchQueue.main.async {
 									completion(.failure(error))
 								}
 							}
-							}
+
 						} else {
 							DispatchQueue.main.async {
 								completion(.success(()))
@@ -1115,6 +1053,11 @@ public extension CloudKitZone {
 	/// Fetch all the changes in the CKZone since the last time we checked
 	@MainActor func fetchChangesInZone(completion: @escaping (Result<Void, Error>) -> Void) {
 
+		guard let database else {
+			completion(.failure(CloudKitZoneError.unknown))
+			return
+		}
+
 		var changedRecords = [CKRecord]()
 		var deletedRecordKeys = [CloudKitRecordKey]()
 		
@@ -1154,58 +1097,49 @@ public extension CloudKitZone {
 				return
 			}
 
+			Task { @MainActor in
+
 				switch result {
 
 				case .success:
-				Task { @MainActor in
 					do {
 						try await self.delegate?.cloudKitDidModify(changed: changedRecords, deleted: deletedRecordKeys)
 						completion(.success(()))
 					} catch {
 						completion(.failure(error))
 					}
-				}
 
 				case .failure(let error):
 
 					switch CloudKitZoneResult.resolve(error) {
 					case .zoneNotFound:
-					self.createZoneRecord() { result in
+
-						switch result {
+						do {
-						case .success:
+							_ = try await self.createZoneRecord()
-							Task { @MainActor in
 							self.fetchChangesInZone(completion: completion)
-							}
+						} catch {
-						case .failure(let error):
-							DispatchQueue.main.async {
 							completion(.failure(error))
 						}
-						}
+
-					}
 					case .userDeletedZone:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitZoneError.userDeletedZone))
-					}
+
 					case .retry(let timeToWait):
 						os_log(.error, log: self.log, "%@ zone fetch changes retry in %f seconds.", self.zoneID.zoneName, timeToWait)
-					self.retryIfPossible(after: timeToWait) {
+						await self.delay(for: timeToWait)
-						Task { @MainActor in
 						self.fetchChangesInZone(completion: completion)
-						}
+
-					}
 					case .changeTokenExpired:
-					DispatchQueue.main.async {
 						self.changeToken = nil
 						self.fetchChangesInZone(completion: completion)
-					}
+
 					default:
-					DispatchQueue.main.async {
 						completion(.failure(CloudKitError(error)))
 					}
 				}
 			}
         }
 
-        database?.add(op)
+        database.add(op)
     }
 }