feat(orm)!: transactions support

cot-macros/src/model.rs

@@ -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/src/auth/db.rs

@@ -97,14 +97,16 @@ 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> {
         let username = Self::convert_username(username)?;
 
         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)
     }
@@ -248,9 +250,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)?;
 
@@ -294,14 +296,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)?;
 
@@ -314,7 +316,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();
@@ -323,7 +325,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)?;
 
@@ -333,7 +335,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),
@@ -715,7 +717,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);
@@ -735,7 +737,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");
     }
@@ -756,7 +758,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());
@@ -774,7 +776,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());
@@ -796,7 +798,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());