fix: solved the update entity bug

Author: TheRustifyer

canyon_macros/src/canyon_mapper_macro.rs

@@ -288,7 +288,7 @@ mod __details {
             let set_pk_val_method = if let Some(pk_ident) = pk_ident_ts {
                 quote! {
                     self.#pk_ident = value.into();
-                       Ok(())
+                    Ok(())
                 }
             } else {
                 quote! {

canyon_macros/src/query_operations/update.rs

@@ -192,20 +192,26 @@ mod __details {
 
     fn generate_update_entity_pk_body_logic(table_schema_data: &str) -> TokenStream {
         quote! {
-            let pk_actual_value = &entity.primary_key_actual_value();
+            let pk_actual_value = entity.primary_key_actual_value();
             let update_columns = entity.fields_names();
-            let update_values = entity.fields_actual_values();
+            let update_values_pk_parsed = entity.fields_actual_values();
 
             let mut vec_columns_values: Vec<String> = Vec::new();
             for (i, column_name) in update_columns.to_vec().iter().enumerate() {
                 let column_equal_value = format!("{} = ${}", column_name, i + 2);
                 vec_columns_values.push(column_equal_value)
             }
-            let str_columns_values = vec_columns_values.join(", ");
+            let col_vals_placeholders = vec_columns_values.join(", ");
+
+            // Efficiently build argument list: pk first, then values
+            let mut update_values: Vec<&dyn canyon_sql::query::QueryParameter> =
+                Vec::with_capacity(1 + update_values_pk_parsed.len());
+            update_values.push(pk_actual_value);
+            update_values.extend(update_values_pk_parsed);
 
             let stmt = format!(
-                "UPDATE {} SET {} WHERE {} = ${:?}",
-                #table_schema_data, str_columns_values, primary_key, pk_actual_value
+                "UPDATE {} SET {} WHERE {:?} = $1",
+                #table_schema_data, col_vals_placeholders, primary_key
             );
         }
     }

tests/crud/hex_arch_example.rs

@@ -33,15 +33,42 @@ fn test_hex_arch_ops() {
             .unwrap() as usize,
         find_all_result.len()
     );
-    // assert_eq!(LeagueHexRepositoryAdapter::<DatabaseConnection>::count_with(binding.deref_mut()).await.unwrap() as usize, find_all_result.len());
-    // The line above works, because we're using binding, but in a better ideal world, our repository would hold an Arc<Mutex<...>> with the connection,
-    // so the user acquire the lock on every query, just cloning the Arc, which if you remember, just increases in one unit the number of active
-    // references pointing to the resource behind the atomic smart pointer
 }
 
 #[cfg(feature = "postgres")]
 #[canyon_sql::macros::canyon_tokio_test]
-fn test_hex_arch_find_insert_ops() {
+fn test_hex_arch_insert_entity_ops() {
+    let default_db_conn = Canyon::instance()
+        .unwrap()
+        .get_default_connection()
+        .unwrap();
+    let league_service = LeagueHexServiceAdapter {
+        league_repository: LeagueHexRepositoryAdapter {
+            db_conn: default_db_conn,
+        },
+    };
+
+    let mut other_league: LeagueHex = LeagueHex {
+        id: Default::default(),
+        ext_id: Default::default(),
+        slug: "leaguehex-slug".to_string(),
+        name: "Test LeagueHex on layered".to_string(),
+        region: "LeagueHex Region".to_string(),
+        image_url: "http://example.com/image.png".to_string(),
+    };
+    league_service.create(&mut other_league).await.unwrap();
+
+    let find_new_league = league_service.get(&other_league.id).await.unwrap();
+    assert!(find_new_league.is_some());
+    assert_eq!(
+        find_new_league.as_ref().unwrap().name,
+        String::from("Test LeagueHex on layered")
+    );
+}
+
+#[cfg(feature = "postgres")]
+#[canyon_sql::macros::canyon_tokio_test]
+fn test_hex_arch_update_entity_ops() {
     let default_db_conn = Canyon::instance()
         .unwrap()
         .get_default_connection()
@@ -61,7 +88,6 @@ fn test_hex_arch_find_insert_ops() {
         image_url: "http://example.com/image.png".to_string(),
     };
     league_service.create(&mut other_league).await.unwrap();
-    println!("New league inserted with: {:#?}", other_league.id);
 
     let find_new_league = league_service.get(&other_league.id).await.unwrap();
     assert!(find_new_league.is_some());
@@ -76,7 +102,7 @@ fn test_hex_arch_find_insert_ops() {
     assert!(r.is_ok());
 
     let updated = league_service.get(&other_league.id).await.unwrap();
-    assert_eq!(updated.unwrap().ext_id, 5)
+    assert_eq!(updated.unwrap().ext_id, 5);
 }
 
 #[derive(CanyonMapper, Debug)]
@@ -167,8 +193,6 @@ impl<T: DbConnection + Send + Sync> LeagueHexRepository for LeagueHexRepositoryA
         &self,
         id: &'a Pk,
     ) -> Result<Option<LeagueHex>, Box<dyn Error + Send + Sync + 'a>> {
-        let r = Self::find_by_pk(id).await;
-        println!("FIND BY PK ON GET err: {:?}", r);
-        r
+        Self::find_by_pk(id).await
     }
 }

tests/crud/querybuilder_operations.rs

@@ -4,8 +4,6 @@ use crate::constants::MYSQL_DS;
 use crate::constants::SQL_SERVER_DS;
 use canyon_sql::connection::DatabaseType;
 
-use canyon_sql::query::querybuilder::DeleteQueryBuilder;
-
 /// Tests for the QueryBuilder available operations within Canyon.
 ///
 /// QueryBuilder are the way of obtain more flexibility that with