Fix the issue that the list element is not in local database when recovering the value of parent’s list property

Author: caiyue1993

IceCream/Classes/CKRecordRecoverable.swift

@@ -13,7 +13,14 @@ public protocol CKRecordRecoverable {
 }
 
 extension CKRecordRecoverable where Self: Object {
-    static func parseFromRecord<U: Object, V: Object, W: Object>(record: CKRecord, realm: Realm, notificationToken: NotificationToken?, uListType: U.Type, vListType: V.Type, wListType: W.Type) -> Self? {
+    static func parseFromRecord<U: Object, V: Object, W: Object>(
+        record: CKRecord,
+        realm: Realm,
+        notificationToken: NotificationToken?,
+        pendingUTypeRelationshipsWorker: PendingRelationshipsWorker<U>,
+        pendingVTypeRelationshipsWorker: PendingRelationshipsWorker<V>,
+        pendingWTypeRelationshipsWorker: PendingRelationshipsWorker<W>
+    ) -> Self? {
         let o = Self()
         for prop in o.objectSchema.properties {
             var recordValue: Any?
@@ -57,66 +64,51 @@ extension CKRecordRecoverable where Self: Object {
                     recordValue = list
                 case .object:
                     guard let value = record.value(forKey: prop.name) as? [CKRecord.Reference] else { break }
-                    // 这里应该根据 List 去创建一个 unmanaged 版本的 List，而不是使用 dynamicList 获取 managed 版本的 list
-                    // 另外需要考虑的就是类型问题
+                    
                     let uList = List<U>()
                     let vList = List<V>()
                     let wList = List<W>()
 
-//                    guard let list = o.value(forKey: prop.name) as? List<Object> else { break }
-//                    let list = o.dynamicList(prop.name)
                     for reference in value {
                         if let objectClassName = prop.objectClassName,
                            let schema = realm.schema.objectSchema.first(where: { $0.className == objectClassName }),
                            let primaryKeyValue = primaryKeyForRecordID(recordID: reference.recordID, schema: schema) {
-                            
-                            // 其实在这里一个数组里所有的 className 都只会是一种
-                            
-                            if schema.className == uListType.className() {
-                                if let existObject = realm.object(ofType: uListType, forPrimaryKey: primaryKeyValue) {
+                            if schema.className == U.className() {
+                                if let existObject = realm.object(ofType: U.self, forPrimaryKey: primaryKeyValue) {
                                     uList.append(existObject)
                                 } else {
-                                    try! realm.write {
-                                        let object = realm.create(uListType)
-                                        uList.append(object)
-                                    }
+                                    pendingUTypeRelationshipsWorker.addToPendingListElement(propertyName: prop.name, primaryKeyValue: primaryKeyValue)
                                 }
                             }
 
-                            if schema.className == vListType.className() {
-                                if let existObject = realm.object(ofType: vListType, forPrimaryKey: primaryKeyValue) {
+                            if schema.className == V.className() {
+                                if let existObject = realm.object(ofType: V.self, forPrimaryKey: primaryKeyValue) {
                                     vList.append(existObject)
                                 } else {
-                                    try! realm.write {
-                                        let object = realm.create(vListType)
-                                        vList.append(object)
-                                    }
+                                    pendingVTypeRelationshipsWorker.addToPendingListElement(propertyName: prop.name, primaryKeyValue: primaryKeyValue)
                                 }
                             }
 
-                            if schema.className == wListType.className() {
-                                if let existObject = realm.object(ofType: wListType, forPrimaryKey: primaryKeyValue) {
+                            if schema.className == W.className() {
+                                if let existObject = realm.object(ofType: W.self, forPrimaryKey: primaryKeyValue) {
                                     wList.append(existObject)
                                 } else {
-                                    try! realm.write {
-                                        let object = realm.create(wListType)
-                                        wList.append(object)                                        
-                                    }
+                                    pendingWTypeRelationshipsWorker.addToPendingListElement(propertyName: prop.name, primaryKeyValue: primaryKeyValue)
                                 }
                             }
 
                         }
                     }
 
-                    if prop.objectClassName == uListType.className() {
+                    if prop.objectClassName == U.className() {
                         recordValue = uList
                     }
 
-                    if prop.objectClassName == vListType.className() {
+                    if prop.objectClassName == V.className() {
                         recordValue = vList
                     }
 
-                    if prop.objectClassName == wListType.className() {
+                    if prop.objectClassName == W.className() {
                         recordValue = wList
                     }
 

IceCream/Classes/PendingRelationshipsWorker.swift

@@ -0,0 +1,43 @@
+//
+//  File.swift
+//  
+//
+//  Created by Soledad on 2021/2/7.
+//
+
+import Foundation
+import RealmSwift
+
+final class PendingRelationshipsWorker<ListElement: Object> {
+    
+    private let listElementType: ListElement.Type
+    
+    var realm: Realm?
+    var owner: Object?
+    
+    private var pendingListElementPrimaryKeyValue: [String: Any] = [:]
+    
+    init(listElementType: ListElement.Type) {
+        self.listElementType = listElementType
+    }
+    
+    func addToPendingListElement(propertyName: String, primaryKeyValue: Any) {
+        pendingListElementPrimaryKeyValue[propertyName] = primaryKeyValue
+    }
+    
+    func resolvePendingListElements() {
+        guard let owner = owner, let realm = realm, pendingListElementPrimaryKeyValue.count > 0 else { return }
+        BackgroundWorker.shared.start {
+            for (propName, primaryKeyValue) in self.pendingListElementPrimaryKeyValue {
+                guard let list = owner.value(forKey: propName) as? List<ListElement> else { return }
+                if let existListElementObject = realm.object(ofType: self.listElementType, forPrimaryKey: primaryKeyValue) {
+                    try! realm.write {
+                        list.append(existListElementObject)
+                    }
+                    self.pendingListElementPrimaryKeyValue[propName] = nil
+                }
+            }
+        }
+    }
+    
+}

IceCream/Classes/PrivateDatabaseManager.swift

@@ -183,7 +183,11 @@ final class PrivateDatabaseManager: DatabaseManager {
             }
         }
 
-        changesOp.fetchRecordZoneChangesCompletionBlock = { error in
+        changesOp.fetchRecordZoneChangesCompletionBlock = { [weak self] error in
+            guard let self = self else { return }
+            self.syncObjects.forEach {
+                $0.resolvePendingRelationships()
+            }
             callback?(error)
         }
 

IceCream/Classes/SyncObject.swift

@@ -22,10 +22,13 @@ public final class SyncObject<T, U, V, W> where T: Object & CKRecordConvertible
     private var notificationToken: NotificationToken?
 
     public var pipeToEngine: ((_ recordsToStore: [CKRecord], _ recordIDsToDelete: [CKRecord.ID]) -> ())?
-//    let listNameTypePairStore = ListNameTypePairStore(className: T.className())
 
     public let realmConfiguration: Realm.Configuration
 
+    private let pendingUTypeRelationshipsWorker = PendingRelationshipsWorker(listElementType: U.self)
+    private let pendingVTypeRelationshipsWorker = PendingRelationshipsWorker(listElementType: V.self)
+    private let pendingWTypeRelationshipsWorker = PendingRelationshipsWorker(listElementType: W.self)
+    
     public init(
         realmConfiguration: Realm.Configuration = .defaultConfiguration,
         type: T.Type,
@@ -80,11 +83,27 @@ extension SyncObject: Syncable {
     public func add(record: CKRecord) {
         BackgroundWorker.shared.start {
             let realm = try! Realm(configuration: self.realmConfiguration)
-            guard let object = T.parseFromRecord(record: record, realm: realm, notificationToken: self.notificationToken, uListType: U.self, vListType: V.self, wListType: W.self) else {
+            guard let object = T.parseFromRecord(
+                record: record,
+                realm: realm,
+                notificationToken: self.notificationToken,
+                pendingUTypeRelationshipsWorker: self.pendingUTypeRelationshipsWorker,
+                pendingVTypeRelationshipsWorker: self.pendingVTypeRelationshipsWorker,
+                pendingWTypeRelationshipsWorker: self.pendingWTypeRelationshipsWorker
+            ) else {
                 print("There is something wrong with the converson from cloud record to local object")
                 return
             }
 
+            self.pendingUTypeRelationshipsWorker.owner = object
+            self.pendingUTypeRelationshipsWorker.realm = realm
+            
+            self.pendingVTypeRelationshipsWorker.owner = object
+            self.pendingVTypeRelationshipsWorker.realm = realm
+            
+            self.pendingWTypeRelationshipsWorker.owner = object
+            self.pendingWTypeRelationshipsWorker.realm = realm
+            
             /// If your model class includes a primary key, you can have Realm intelligently update or add objects based off of their primary key values using Realm().add(_:update:).
             /// https://realm.io/docs/swift/latest/#objects-with-primary-keys
             realm.beginWrite()
@@ -138,6 +157,12 @@ extension SyncObject: Syncable {
         }
     }
 
+    public func resolvePendingRelationships() {
+        pendingUTypeRelationshipsWorker.resolvePendingListElements()
+        pendingVTypeRelationshipsWorker.resolvePendingListElements()
+        pendingWTypeRelationshipsWorker.resolvePendingListElements()
+    }
+    
     public func cleanUp() {
         BackgroundWorker.shared.start {
             let realm = try! Realm(configuration: self.realmConfiguration)

IceCream/Classes/Syncable.swift

@@ -27,6 +27,8 @@ public protocol Syncable: class {
     func add(record: CKRecord)
     func delete(recordID: CKRecord.ID)
 
+    func resolvePendingRelationships()
+    
     /// CloudKit related
     func pushLocalObjectsToCloudKit()