fix: Avoid data race in query subscription by making mutation creation synchronous in use_mutation

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "dioxus-query"
 description = "Fully-typed, async, reusable cached state management for Dioxus 🧬"
-version = "0.9.1"
+version = "0.9.2"
 edition = "2021"
 license = "MIT"
 authors = ["Marc Espín <[email protected]>"]

src/mutation.rs

@@ -1,9 +1,6 @@
 use core::fmt;
 use dioxus::prelude::*;
-use dioxus::{
-    hooks::{use_memo, use_reactive},
-    signals::CopyValue,
-};
+use dioxus::signals::CopyValue;
 use dioxus_core::{provide_root_context, spawn_forever, use_drop, ReactiveContext, Task};
 use std::{
     cell::{Ref, RefCell},
@@ -262,7 +259,7 @@ impl<Q: MutationCapability> MutationReader<Q> {
 }
 
 pub struct UseMutation<Q: MutationCapability> {
-    mutation: Memo<Mutation<Q>>,
+    mutation: Signal<Mutation<Q>>,
 }
 
 impl<Q: MutationCapability> Clone for UseMutation<Q> {
@@ -370,29 +367,33 @@ pub fn use_mutation<Q: MutationCapability>(mutation: Mutation<Q>) -> UseMutation
         None => provide_root_context(MutationsStorage::<Q>::new_in_root()),
     };
 
-    let current_mutation = use_hook(|| Rc::new(RefCell::new(None)));
-
-    // Create or update mutation subscription on changes
-    let mutation = use_memo(use_reactive!(|mutation| {
+    let mut make_mutation = |mutation: &Mutation<Q>, mut prev_mutation: Option<Mutation<Q>>| {
         let _data = storage.insert_or_get_mutation(mutation.clone());
 
         // Update the mutation tasks if there has been a change in the mutation
-        if let Some(prev_mutation) = current_mutation.borrow_mut().take() {
+        if let Some(prev_mutation) = prev_mutation.take() {
             storage.update_tasks(prev_mutation);
         }
+    };
 
-        // Store this new mutation
-        current_mutation.borrow_mut().replace(mutation.clone());
+    let mut current_mutation = use_hook(|| {
+        make_mutation(&mutation, None);
+        Signal::new(mutation.clone())
+    });
 
-        mutation
-    }));
+    if *current_mutation.read() != mutation {
+        let prev = mem::replace(&mut *current_mutation.write(), mutation.clone());
+        make_mutation(&mutation, Some(prev));
+    }
 
-    // Update the query tasks when the scope is dropped
+    // Update the mutation tasks when the scope is dropped
     use_drop({
         move || {
-            storage.update_tasks(mutation.peek().clone());
+            storage.update_tasks(current_mutation.peek().clone());
         }
     });
 
-    UseMutation { mutation }
+    UseMutation {
+        mutation: current_mutation,
+    }
 }

src/query.rs

@@ -713,19 +713,14 @@ pub fn use_query<Q: QueryCapability>(query: Query<Q>) -> UseQuery<Q> {
         None => provide_root_context(QueriesStorage::<Q>::new_in_root()),
     };
 
-    let current_query = use_hook(|| Rc::new(RefCell::new(None)));
-
-    let mut make_query = |query: &Query<Q>| {
+    let mut make_query = |query: &Query<Q>, mut prev_query: Option<Query<Q>>| {
         let query_data = storage.insert_or_get_query(query.clone());
 
         // Update the query tasks if there has been a change in the query
-        if let Some(prev_query) = current_query.borrow_mut().take() {
+        if let Some(prev_query) = prev_query.take() {
             storage.update_tasks(prev_query);
         }
 
-        // Store this new query
-        current_query.borrow_mut().replace(query.clone());
-
         // Immediately run the query if enabled and the value is stale
         if query.enabled && query_data.state.borrow().is_stale(query) {
             let query = query.clone();
@@ -735,22 +730,24 @@ pub fn use_query<Q: QueryCapability>(query: Query<Q>) -> UseQuery<Q> {
         }
     };
 
-    let mut curr_query = use_hook(|| {
-        make_query(&query);
+    let mut current_query = use_hook(|| {
+        make_query(&query, None);
         Signal::new(query.clone())
     });
 
-    if *curr_query.read() != query {
-        curr_query.set(query);
-        make_query(&*curr_query.read());
+    if *current_query.read() != query {
+        let prev = mem::replace(&mut *current_query.write(), query.clone());
+        make_query(&query, Some(prev));
     }
 
     // Update the query tasks when the scope is dropped
     use_drop({
         move || {
-            storage.update_tasks(curr_query.peek().clone());
+            storage.update_tasks(current_query.peek().clone());
         }
     });
 
-    UseQuery { query: curr_query }
+    UseQuery {
+        query: current_query,
+    }
 }