问如何为fetch设置完成处理程序(withQuery：，inZoneWith：) cloudKit func

EN

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
}

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: [], +=)
  }
}
}

//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
}

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
}

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

 //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)
            }
        }