How to setup the completion handler for fetch(withQuery: , inZoneWith: ) cloudKit func

Question

I'm working on a store management system that uses cloudKit to store the users data. I have custom zones set up within the private database with some pre populated data.

I have the func loadCustomerArray() which should retrieve all records within the "Customers" zone and then create a Customer object from each CKRecord returned. I'm using the fetch(withQuery: , inZoneWith: ) func but since there is no documentation on this func and most answer online for this issue are using now deprecated methods I'm having trouble setting up the completion handler for this func.

Here is my code:

func loadCustomerArray() async throws -> [Customer] {
    //set the cloud database to the users private database
    let cloudDB = CKContainer.default().privateCloudDatabase
    let custZone = CKRecordZone(zoneName: "Customers")
    
    let pred = NSPredicate(value: true) //true -> return all records
    let query = CKQuery(recordType: "Customer", predicate: pred)
    
    var customerRecords: [Customer] = []
    
    //Get the records matching these criteria
    cloudDB.fetch(withQuery: query, inZoneWith: custZone.zoneID, resultsLimit: 100) { result, error in
        
    }

    return customerRecords
}

I'm currently getting an error Contextual closure type '(Result<(matchResults: [(CKRecord.ID, Result<CKRecord, Error>)], queryCursor: CKQueryOperation.Cursor?), Error>) -> Void' expects 1 argument, but 2 were used in closure body but am unsure of what to replace result, error in with in order to iterate over the results.

EDIT

per Jessy's instruction I ditched that idea.

Here is my understanding of how to implement his solution:

I added the func records and a queryRecords func form that same post like so:

public func queryRecords(recordType: CKRecord.RecordType, predicate: NSPredicate, database: CKDatabase, Zone: CKRecordZone) async throws -> [CKRecord] {
    return try await database.records(type: recordType, predicate: predicate, zoneID: Zone.zoneID)
}

public extension CKDatabase {
/// Request `CKRecord`s that correspond to a Swift type.
///
/// - Parameters:
///   - recordType: Its name has to be the same in your code, and in CloudKit.
///   - predicate: for the `CKQuery`
func records(type: CKRecord.RecordType,predicate: NSPredicate = .init(value: true),zoneID: CKRecordZone.ID) async throws -> [CKRecord] {
try await withThrowingTaskGroup(of: [CKRecord].self) { group in
  func process(
    _ records: (
      matchResults: [(CKRecord.ID, Result<CKRecord, Error>)],
      queryCursor: CKQueryOperation.Cursor?
    )
  ) async throws {
    group.addTask {
      try records.matchResults.map { try $1.get() }
    }
    if let cursor = records.queryCursor {
      try await process(self.records(continuingMatchFrom: cursor))
    }
  }
  try await process(
    records(
      matching: .init(
        recordType: type,
        predicate: predicate
      ),
      inZoneWith: zoneID
    )
  )
    
    return try await group.reduce(into: [], +=)
  }
}
}

and added an initializer to my Customer class like this:

//Initializer with CKRecord
init (record: CKRecord) {
    self.ID = record["customerID"] as! Int
    self.CustomerName = record["customerName"] as! String
    self.ContactName = record["contactName"] as! String
    self.Address = record["Address"] as! String
    self.City = record["City"] as! String
    self.PostalCode = record["postCode"] as! String
    self.Country = record["Country"] as! String
}

---

So now my loadCustomerArray() func looks like this:

func loadCustomerArray() async throws -> [Customer] {
    //array to be returned
    var customers: [Customer] = []

    //set the cloud database to the users private database
    let cloudDB = CKContainer.default().privateCloudDatabase
    let custZone = CKRecordZone(zoneName: "Customers")
    
    let pred = NSPredicate(value: true) //true -> return all records
    
    //Get the records matching these criteria
    let customerRecords = try await queryRecords(recordType: "Customer", predicate: pred, database: cloudDB, Zone: custZone)
    
    for record in customerRecords {
        //create customer object from the records
        let customer = Customer(record: record)
        //add customer obj to the array to be returned
        customers.append(customer)
    }
    
    return customers
}

The above loadCustomerArray()`` func is called like so inside of my customers page viewDidLoad()``` func:

Task {
    do {
       customerArray = try await loadCustomerArray()
       tableView.reloadData()
    }
    catch {
        print(error)
    }
}

But it still isn't working correctly so any explanation on how to properly implement this would be very helpful.

---

Update

I added this code which lets the user know if their iCloud account is able to be used in the app:

 //check iCloud acc. status
 CKContainer.default().accountStatus { (accountStatus, error) in
        //creates an alert popup depending on the iCloud account status
        switch accountStatus {
        case .available:
            let cloudAvailable = UIAlertController(title: "iCloud Account Available",
                                                   message: "your iCloud account will be used to store your stores data",
                                                   preferredStyle: .alert)
            cloudAvailable.addAction(UIAlertAction(title: "Okay", style: .default, handler: { (_) in
                cloudAvailable.dismiss(animated: true)
            }))
            
            DispatchQueue.main.async {
                self.present(cloudAvailable, animated: true)
            }
            
            
        case .noAccount:
            let noCloud = UIAlertController(title: "No iCloud Account Available",
                                            message: "this app requires an iCloud account, please set up an account and then try to sign up again",
                                            preferredStyle: .alert)
            noCloud.addAction(UIAlertAction(title: "Okay", style: .default, handler: { (_) in
                noCloud.dismiss(animated: true)
            }))
            
            DispatchQueue.main.async {
                self.present(noCloud, animated: true)
            }
            
            
        case .restricted:
            let restrictedCloud = UIAlertController(title: "iCloud Account Is Restricted",
                                                    message: "please unrestrict your iCloud account and try to sign up again",
                                                    preferredStyle: .alert)
            restrictedCloud.addAction(UIAlertAction(title: "Okay", style: .default, handler: { (_) in
                restrictedCloud.dismiss(animated: true)
            }))
            
            DispatchQueue.main.async {
                self.present(restrictedCloud, animated: true)
            }
            
            
        //unable to determine iCloud Account status as the defualt case
        default:
            let unableToDetermine = UIAlertController(title: "Unable To Determine iCloud Account Status",
                                                      message: "please make sure you have set up an iCloud account and that it allows this app access",
                                                      preferredStyle: .alert)
            unableToDetermine.addAction(UIAlertAction(title: "Okay", style: .default, handler: { (_) in
                unableToDetermine.dismiss(animated: true)
            }))
            
            DispatchQueue.main.async {
                self.present(unableToDetermine, animated: true)
            }
        }

Which is called inside of my sign up page's viewDidLoad() func. When I tested it on the simulator it returned the noCloud UIAlertController so the problem was that I hadn't signed into my Apple ID in the simulator.

Answer 1

Do not mix that old API with Swift concurrency. Instead, conform Customer to a protocol like this InitializableWithCloudKitRecord.

var customers: [Customer] {
  get async throws {
    try await .init(
      database: CKContainer.default().privateCloudDatabase,
      zoneID: CKRecordZone(zoneName: "Customers").zoneID
    )
  }
}

public protocol InitializableWithCloudKitRecord {
  init(record: CKRecord) throws
}

public extension Array where Element: InitializableWithCloudKitRecord {
  init(
    database: CKDatabase,
    zoneID: CKRecordZone.ID? = nil,
    predicate: NSPredicate = .init(value: true)
  ) async throws {
    self = try await database.records(
      type: Element.self,
      zoneID: zoneID,
      predicate: predicate
    ).map(Element.init)
  }
}

The necessary records overload is here.