realm-swift: "Cannot register notification blocks from within write transactions." when making changes in quick succession

We usually encounter this when trying to start change observation as a result of a write, but it does seem to be limited to situations where the presentation mode is changing. The most common occurrence for us is when a button is clicked that:

• dismisses a sheet
• writes some data to realm

We are also encountering this issue. When asnyWrite (or normal writes, issue happens either way) are triggered in rapid succession (in our case caused by quick server requests) and there is a notification block observing this collection (no writes in the notification block). This happens even with everything realm on the @MainActor.

I tried asyncWrite based on this comment, but it didn’t make a difference.

struct ContentView2: View {
    
    @ObservedResults(Item.self) var items
    @Environment(\.realm) var realm

    @FocusState var focusedId: ObjectId?

    var body: some View {
        NavigationStack {
            List {
                // Items
                ForEach(items) { item in
                    ItemView(item: item, focusedId: $focusedId)
                        .onSubmit {
                            addItem()
                        }
                }
            }
            .navigationTitle("Items")
            .toolbar {
                // Add
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button {
                        addItem()
                    } label: {
                        Label("Add item", systemImage: "plus")
                    }
                }
                
                // Delete
                ToolbarItem(placement: .navigationBarLeading) {
                    Button(role: .destructive){
                        deleteAll()
                    } label: {
                        Label("Delete all", systemImage: "trash")
                    }
                }
            }
        }
    }
    
    func addItem(){
        Task {
            try await realm.asyncWrite {
                let item = Item()
                realm.add(item)
                focusedId = item._id
            }
        }
    }
    
    func deleteAll(){
        $items.remove(atOffsets: IndexSet(integersIn: items.indices))
    }
}

Affirm. We only use asyncWrite actually, and still see this bug. All of our realms are used with actor isolation.

This no longer happens for us when performing all writes on a (single) background actor. We use a global actor for this like so:

@globalActor
actor RealmBackgroundActor {
    static var shared = RealmBackgroundActor()
}

We also observe on this actor only, and use exclusively asyncWrite though I believe we have also tested with normal write and it did also work.

So we observe using:

@RealmBackgroundActor
func observeCollections() async throws {
        let realm = try await Realm(actor: RealmBackgroundActor.shared)
        let results = realm.objects(SomeProtocol.self)
        resultNotificationToken = results.observe { [weak self] (changes: RealmCollectionChange) in
            self?.objects = Array(results.sorted(by: \.createdAt).freeze())
        }
}

and write using:

@RealmBackgroundActor
func write(object: SomeProtocol) async throws {
        let realm = try await Realm(actor: RealmBackgroundActor.shared)
        try await realm.asyncWrite {
            realm.create(type(of: object), value: object, update: .modified)
        }
    }

Hope this helps someone:)

There’s currently no debouncing. We looked into adding it and concluded that it was going to be sufficiently complicated that we might as well put the effort into making small writes work better instead.

Write transactions can’t happen “at the same time” as they involve a global (per-Realm) lock. However, in that code you’re checking for the max outside of a write transaction, and so may be reading a stale value and end up with a duplicate. Wrapping the whole thing in an explicit write transaction is required for correct results:

realm.write {
    let order = (items.max(of: \Item.order) ?? 0) + 1
    let item = Item(name: name, order: order, userId: app.currentUser?.id)
    $items.append(item)
}

Async writes are the mechanism to queue writes. If you call asyncWrite from within a write transaction the block will be invoked after the current write transaction completes.

@bogdan-pechounov I was able to reproduce your issue. The error mentioned on this issue can be a little bit misgiving, this is not happening because you are registering a notification in a write transaction, is because your write is happening while the realm is in a transaction, which we verify later during the write commit and throw an exception. @jeffypooo do you have the same use case as the one described above, do you get this error while on SwiftUI View while using ObservedResults and ObservedRealmObject