Add Many.set (#357)

Author: jayvdb

butane/tests/many.rs

@@ -54,14 +54,20 @@ async fn load_sorted_from_many(conn: ConnectionAsync) {
         "This post is about a fast cat.",
         &cats_blog,
     );
+    post.save(&conn).await.unwrap();
+
     let tag_fast = create_tag(&conn, "fast").await;
     let tag_cat = create_tag(&conn, "cat").await;
     let tag_european = create_tag(&conn, "european").await;
+    let tags = vec![tag_fast, tag_cat, tag_european];
 
-    post.tags.add(&tag_fast).unwrap();
-    post.tags.add(&tag_cat).unwrap();
-    post.tags.add(&tag_european).unwrap();
-    post.save(&conn).await.unwrap();
+    post.tags.set(&conn, tags).await.unwrap();
+
+    let saved_tags: Vec<&Tag> = post.tags.get().unwrap().into_iter().collect();
+    assert_eq!(saved_tags.len(), 3);
+    assert_eq!(saved_tags[0].tag, "fast");
+    assert_eq!(saved_tags[1].tag, "cat");
+    assert_eq!(saved_tags[2].tag, "european");
 
     let post2 = Post::get(&conn, post.id).await.unwrap();
     let mut tag_iter = post2
@@ -72,6 +78,7 @@ async fn load_sorted_from_many(conn: ConnectionAsync) {
     assert_eq!(tag_iter.next().unwrap().tag, "cat");
     assert_eq!(tag_iter.next().unwrap().tag, "european");
     assert_eq!(tag_iter.next().unwrap().tag, "fast");
+    assert!(tag_iter.next().is_none());
 
     let post3 = Post::get(&conn, post.id).await.unwrap();
     let mut tag_iter = post3
@@ -82,6 +89,7 @@ async fn load_sorted_from_many(conn: ConnectionAsync) {
     assert_eq!(tag_iter.next().unwrap().tag, "fast");
     assert_eq!(tag_iter.next().unwrap().tag, "european");
     assert_eq!(tag_iter.next().unwrap().tag, "cat");
+    assert!(tag_iter.next().is_none());
 }
 
 #[butane_test]

butane_core/src/many.rs

@@ -198,23 +198,34 @@ where
     async(feature = "async")
 )]
 pub trait ManyOps<T: DataObject> {
+    /// Save all unsaved relation changes to the backend.
+    ///
     /// Used by macro-generated code. You do not need to call this directly.
+    ///
+    /// This will insert added values first, and then remove the removed values.
+    /// Use inside a transaction to provide atomicity.
     async fn save(&mut self, conn: &impl ConnectionMethods) -> Result<()>;
 
-    /// Delete all references from the database, and any unsaved additions.
+    /// Delete all references from the backend, and any unsaved additions.
+    ///
+    /// This operation is atomic.
     async fn delete(&mut self, conn: &impl ConnectionMethods) -> Result<()>;
 
-    /// Loads the values referred to by this many relationship from the
-    /// database if necessary and returns a reference to them.
+    /// Overwrite the references in the backend, and clears unsaved additions.
+    ///
+    /// This will call `delete()` first, and then insert the items scheduled to be added.
+    /// Use inside a transaction to provide atomicity.
+    async fn set(&mut self, conn: &impl ConnectionMethods, values: Vec<T>) -> Result<()>;
+
+    /// Loads the values referred to by this many relationship from the backend if necessary.
     async fn load<'a>(
         &'a self,
         conn: &impl ConnectionMethods,
     ) -> Result<impl Iterator<Item = &'a T>>
     where
         T: 'a;
 
-    /// Loads and orders the values referred to by this many relationship from a
-    /// database if necessary and returns a reference to them.
+    /// Loads and orders the values referred to by this many relationship from the backend if necessary.
     async fn load_ordered<'a>(
         &'a self,
         conn: &impl ConnectionMethods,
@@ -274,6 +285,18 @@ impl<T: DataObject> ManyOps<T> for Many<T> {
         Ok(())
     }
 
+    async fn set(&mut self, conn: &impl ConnectionMethods, values: Vec<T>) -> Result<()> {
+        ManyOps::delete(self, conn).await?;
+
+        for value in &values {
+            self.add(value)?;
+        }
+        ManyOps::save(self, conn).await?;
+
+        self.all_values = OnceLock::from(values);
+        Ok(())
+    }
+
     async fn load<'a>(
         &'a self,
         conn: &impl ConnectionMethods,