How can I migrate from 10.40.1 to 10.47.0?

[OmarJalil]

First of all, we have a custom wrapper around Realm, for us to be able to manage entities and everything related with our database.
Seems like version 10.40.2 introduced Actor.preconditionIsolated() for runtime actor checking which causes the following error:

RealmSwift/Realm.swift:1468: Precondition failed: Incorrect actor executor assumption; Expected 'UnownedSerialExecutor(executor: (Opaque Value))' executor.

This is the wrapper I talked about.

import RealmSwift
import Realm

public final actor DatabaseManager: ObservableObject {

    public static func start() {
        // code
        let schemeVersionBasedOnAppVersion = versionToId(major: major, minor: minor, patch: patch, extra: extra)
        var config = Realm.Configuration(schemaVersion: UInt64(schemeVersionBasedOnAppVersion))
        Realm.Configuration.defaultConfiguration = config
    }

    @discardableResult
    public func saveOrUpdate<Entity: DecodableObject>(_ value: Entity.Model, entityType: Entity.Type) async throws -> Entity {

        let entity = Entity()
        entity.decode(from: value)

        let realm = try await Realm(actor: self)

        try await realm.asyncWrite {
            realm.add(entity, update: .modified)
        }

        return entity
    }

    public func update<Result>(entity: Object, _ block: (() throws -> Result)) async throws {
        let realm = try await Realm(actor: self)

        try await realm.asyncWrite {
            _ = try block()
            realm.add(entity, update: .modified)
        }
    }

    public func delete<T: Object>(_ value: T, cascading: Bool = false) async throws {
        let realm = try await Realm(actor: self)

        try await realm.asyncWrite {
            realm.delete(value, cascading: cascading)
        }
    }

    public func deleteAll<T: Object>(of type: T.Type, cascading: Bool) async throws {
        let realm = try await Realm(actor: self)
        try await realm.asyncWrite {
            let allObjects = realm.objects(type)
            realm.delete(allObjects, cascading: cascading)
        }
    }

    public func fetch<Element: RealmSwiftObject>(_ objectType: Element.Type, query: ((Query<Element>) -> Query<Bool>)? = nil, sorted: String? = nil) async throws -> Results<Element> {
        let realm = try await Realm(actor: self)

        var list = realm.objects(objectType)

        if !list.isEmpty, let query {
            list = list.where(query)
        }

        if !list.isEmpty, let sorted {
            list = list.sorted(byKeyPath: sorted)
        }

        return list
    }

    public func fetchOne<Element: Object>(_ objectType: Element.Type, primaryKey id: Int) async throws -> Element? {
        let realm = try await Realm(actor: self)
        return realm.object(ofType: objectType, forPrimaryKey: id)
    }

    public func fetchOne<Element: Object>(_ objectType: Element.Type, primaryKey id: String) async throws -> Element? {
        let realm = try await Realm(actor: self)
        return realm.object(ofType: objectType, forPrimaryKey: id)
    }

    public func clearDatabase() async throws {
        let realm = try await Realm(actor: self)

        try await realm.asyncWrite {
            realm.deleteAll()
        }
    }
}

internal extension DatabaseManager {
    /**
     Converts a semantic version to a unique integer identifier.
    **/
    static func versionToId(major: Int, minor: Int, patch: Int, extra: Int) -> Int {
        // code
    }
}

private extension Realm {

    func delete<S: Sequence>(_ objects: S, cascading: Bool) where S.Iterator.Element: Object {
        for obj in objects {
            delete(obj, cascading: cascading)
        }
    }

    func delete<Entity: Object>(_ entity: Entity, cascading: Bool) {
        if cascading {
            cascadeDelete(entity)
        } else {
            delete(entity)
        }
    }
}

private extension Realm {

    func cascadeDelete(_ entity: RLMObjectBase) {
        guard let entity = entity as? Object else { return }
        var toBeDeleted = Set<RLMObjectBase>()
        toBeDeleted.insert(entity)

        while !toBeDeleted.isEmpty {
            guard let element = toBeDeleted.removeFirst() as? Object, !element.isInvalidated else { continue }
            resolve(element: element, toBeDeleted: &toBeDeleted)
        }
    }

    func resolve(element: Object, toBeDeleted: inout Set<RLMObjectBase>) {
        element.objectSchema.properties.forEach {
            guard let value = element.value(forKey: $0.name) else { return }

            if let entity = value as? RLMObjectBase {
                toBeDeleted.insert(entity)
            } else if let list = value as? RLMSwiftCollectionBase {
                for index in 0..<list._rlmCollection.count {
                    if let object = list._rlmCollection.object(at: index) as? RLMObjectBase {
                        toBeDeleted.insert(object)
                    }
                }
            }
        }

        delete(element)
    }
}

Here are my fails to migrate it.

• I tried to change all instances to use MainActor.shared
• I tried to use ThreadSafeReference(to: entity) and realm.resolve()
• I tried to add @mainactor to all functions
• I tried to create a single instance of the database manager to be able to have a single actor across the entire application

I really want to understand how can I migrate this wrapper to be able to keep track of all Realm updates

[nirinchev]

This appears to be related to #8419

[OmarJalil]

It might be, but it doesn't seem like it. Mine crashes inside the verifier method.

[nirinchev]

The fundamental issue seems to be the same though - you're trying to use a Realm on the wrong thread/actor. It implies that the methods you're calling on your database manager are not executing on the correct actor (which appears to be the database manager itself).

[OmarJalil]

@nirinchev Have you found any solution to this?

[nirinchev]

What do you mean? I haven't audited the code you posted, but as I said, the fundamental problem is that you're accessing the same realm from multiple actors, which is not allowed.

[OmarJalil]

I ended up using a DispatchQueue instead of actors, but thanks, If you want to see the final implementation please let me know, if not just close the discussion