feat(orm)!: transactions support

Author: m4tx

cot-macros/src/model.rs

@@ -176,8 +176,8 @@ impl ModelBuilder {
         let fields_as_get_values = &self.fields_as_get_values;
 
         quote! {
-            #[#crate_ident::__private::async_trait]
             #[automatically_derived]
+            #[#orm_ident::async_trait]
             impl #orm_ident::Model for #name {
                 type Fields = #fields_struct_name;
                 type PrimaryKey = #pk_type;
@@ -225,11 +225,11 @@ impl ModelBuilder {
                 }
 
                 async fn get_by_primary_key<DB: #orm_ident::DatabaseBackend>(
-                    db: &DB,
+                    mut db: DB,
                     pk: Self::PrimaryKey,
                 ) -> #orm_ident::Result<Option<Self>> {
                     #orm_ident::query!(Self, $#pk_field_name == pk)
-                        .get(db)
+                        .get(&mut db)
                         .await
                 }
             }

cot/Cargo.toml

@@ -59,7 +59,7 @@ subtle = { workspace = true, features = ["std"] }
 swagger-ui-redist = { workspace = true, optional = true }
 thiserror.workspace = true
 time.workspace = true
-tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "fs", "io-util"] }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "fs", "io-util", "sync"] }
 toml = { workspace = true, features = ["parse", "serde"] }
 tower = { workspace = true, features = ["util"] }
 tower-livereload = { workspace = true, optional = true }

cot/src/auth/db.rs

@@ -97,7 +97,7 @@ impl DatabaseUser {
     /// # }
     /// ```
     pub async fn create_user<DB: DatabaseBackend, T: Into<String>, U: Into<Password>>(
-        db: &DB,
+        mut db: DB,
         username: T,
         password: U,
     ) -> Result<Self> {
@@ -108,7 +108,9 @@ impl DatabaseUser {
         })?;
 
         let mut user = Self::new(Auto::auto(), username, &password.into());
-        user.insert(db).await.map_err(AuthError::backend_error)?;
+        user.insert(&mut db)
+            .await
+            .map_err(AuthError::backend_error)?;
 
         Ok(user)
     }
@@ -153,9 +155,9 @@ impl DatabaseUser {
     /// #     Ok(())
     /// # }
     /// ```
-    pub async fn get_by_id<DB: DatabaseBackend>(db: &DB, id: i64) -> Result<Option<Self>> {
+    pub async fn get_by_id<DB: DatabaseBackend>(mut db: DB, id: i64) -> Result<Option<Self>> {
         let db_user = query!(DatabaseUser, $id == id)
-            .get(db)
+            .get(&mut db)
             .await
             .map_err(AuthError::backend_error)?;
 
@@ -199,14 +201,14 @@ impl DatabaseUser {
     /// # }
     /// ```
     pub async fn get_by_username<DB: DatabaseBackend>(
-        db: &DB,
+        mut db: DB,
         username: &str,
     ) -> Result<Option<Self>> {
         let username = LimitedString::<MAX_USERNAME_LENGTH>::new(username).map_err(|_| {
             AuthError::backend_error(CreateUserError::UsernameTooLong(username.len()))
         })?;
         let db_user = query!(DatabaseUser, $username == username)
-            .get(db)
+            .get(&mut db)
             .await
             .map_err(AuthError::backend_error)?;
 
@@ -219,7 +221,7 @@ impl DatabaseUser {
     ///
     /// Returns an error if there was an error querying the database.
     pub async fn authenticate<DB: DatabaseBackend>(
-        db: &DB,
+        mut db: DB,
         credentials: &DatabaseUserCredentials,
     ) -> Result<Option<Self>> {
         let username = credentials.username();
@@ -228,7 +230,7 @@ impl DatabaseUser {
                 AuthError::backend_error(CreateUserError::UsernameTooLong(username.len()))
             })?;
         let user = query!(DatabaseUser, $username == username_limited)
-            .get(db)
+            .get(&mut db)
             .await
             .map_err(AuthError::backend_error)?;
 
@@ -238,7 +240,7 @@ impl DatabaseUser {
                 PasswordVerificationResult::Ok => Ok(Some(user)),
                 PasswordVerificationResult::OkObsolete(new_hash) => {
                     user.password = new_hash;
-                    user.save(db).await.map_err(AuthError::backend_error)?;
+                    user.save(&mut db).await.map_err(AuthError::backend_error)?;
                     Ok(Some(user))
                 }
                 PasswordVerificationResult::Invalid => Ok(None),
@@ -620,7 +622,7 @@ mod tests {
         let username = "testuser".to_string();
         let password = Password::new("password123");
 
-        let user = DatabaseUser::create_user(&mock_db, username.clone(), &password)
+        let user = DatabaseUser::create_user(&mut mock_db, username.clone(), &password)
             .await
             .unwrap();
         assert_eq!(user.username(), username);
@@ -640,7 +642,7 @@ mod tests {
             .expect_get::<DatabaseUser>()
             .returning(move |_| Ok(Some(user.clone())));
 
-        let result = DatabaseUser::get_by_id(&mock_db, 1).await.unwrap();
+        let result = DatabaseUser::get_by_id(&mut mock_db, 1).await.unwrap();
         assert!(result.is_some());
         assert_eq!(result.unwrap().username(), "testuser");
     }
@@ -661,7 +663,7 @@ mod tests {
 
         let credentials =
             DatabaseUserCredentials::new("testuser".to_string(), Password::new("password123"));
-        let result = DatabaseUser::authenticate(&mock_db, &credentials)
+        let result = DatabaseUser::authenticate(&mut mock_db, &credentials)
             .await
             .unwrap();
         assert!(result.is_some());
@@ -679,7 +681,7 @@ mod tests {
 
         let credentials =
             DatabaseUserCredentials::new("testuser".to_string(), Password::new("password123"));
-        let result = DatabaseUser::authenticate(&mock_db, &credentials)
+        let result = DatabaseUser::authenticate(&mut mock_db, &credentials)
             .await
             .unwrap();
         assert!(result.is_none());
@@ -701,7 +703,7 @@ mod tests {
 
         let credentials =
             DatabaseUserCredentials::new("testuser".to_string(), Password::new("invalid"));
-        let result = DatabaseUser::authenticate(&mock_db, &credentials)
+        let result = DatabaseUser::authenticate(&mut mock_db, &credentials)
             .await
             .unwrap();
         assert!(result.is_none());