(Please Review Before 2.0 releases!) Remove need to use Box::pin for transactions.

src/database/connection.rs

@@ -165,7 +165,7 @@ pub struct TransactionOptions {
 }
 
 /// Spawn database transaction
-#[async_trait::async_trait]
+#[allow(async_fn_in_trait)]
 pub trait TransactionTrait {
     /// The concrete type for the transaction
     type Transaction: ConnectionTrait + TransactionTrait + TransactionSession;
@@ -193,10 +193,7 @@ pub trait TransactionTrait {
     /// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
     async fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c Self::Transaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c Self::Transaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send;
 
@@ -209,10 +206,7 @@ pub trait TransactionTrait {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c Self::Transaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c Self::Transaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send;
 }

src/database/db_connection.rs

@@ -343,7 +343,6 @@ impl StreamTrait for DatabaseConnection {
     }
 }
 
-#[async_trait::async_trait]
 impl TransactionTrait for DatabaseConnection {
     type Transaction = DatabaseTransaction;
 
@@ -453,10 +452,7 @@ impl TransactionTrait for DatabaseConnection {
     #[instrument(level = "trace", skip(_callback))]
     async fn transaction<F, T, E>(&self, _callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -505,10 +501,7 @@ impl TransactionTrait for DatabaseConnection {
         _access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {

src/database/executor.rs

@@ -4,8 +4,6 @@ use crate::{
     TransactionTrait,
 };
 use crate::{Schema, SchemaBuilder};
-use std::future::Future;
-use std::pin::Pin;
 
 /// A wrapper that holds either a reference to a [`DatabaseConnection`] or [`DatabaseTransaction`],
 /// or an owned [`DatabaseTransaction`].
@@ -74,7 +72,6 @@ impl ConnectionTrait for DatabaseExecutor<'_> {
     }
 }
 
-#[async_trait::async_trait]
 impl TransactionTrait for DatabaseExecutor<'_> {
     type Transaction = DatabaseTransaction;
 
@@ -117,10 +114,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
 
     async fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -138,10 +132,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {

src/database/mock.rs

@@ -450,13 +450,11 @@ mod tests {
     async fn test_transaction_1() {
         let db = MockDatabase::new(DbBackend::Postgres).into_connection();
 
-        db.transaction::<_, (), DbErr>(|txn| {
-            Box::pin(async move {
-                let _1 = cake::Entity::find().one(txn).await;
-                let _2 = fruit::Entity::find().all(txn).await;
+        db.transaction::<_, (), DbErr>(async |txn| {
+            let _1 = cake::Entity::find().one(txn).await;
+            let _2 = fruit::Entity::find().all(txn).await;
 
-                Ok(())
-            })
+            Ok(())
         })
         .await
         .unwrap();
@@ -494,11 +492,9 @@ mod tests {
         let db = MockDatabase::new(DbBackend::Postgres).into_connection();
 
         let result = db
-            .transaction::<_, (), MyErr>(|txn| {
-                Box::pin(async move {
-                    let _ = cake::Entity::find().one(txn).await;
-                    Err(MyErr("test".to_owned()))
-                })
+            .transaction::<_, (), MyErr>(async |txn| {
+                let _ = cake::Entity::find().one(txn).await;
+                Err(MyErr("test".to_owned()))
             })
             .await;
 
@@ -527,22 +523,18 @@ mod tests {
     async fn test_nested_transaction_1() {
         let db = MockDatabase::new(DbBackend::Postgres).into_connection();
 
-        db.transaction::<_, (), DbErr>(|txn| {
-            Box::pin(async move {
-                let _ = cake::Entity::find().one(txn).await;
+        db.transaction::<_, (), DbErr>(async |txn| {
+            let _ = cake::Entity::find().one(txn).await;
 
-                txn.transaction::<_, (), DbErr>(|txn| {
-                    Box::pin(async move {
-                        let _ = fruit::Entity::find().all(txn).await;
-
-                        Ok(())
-                    })
-                })
-                .await
-                .unwrap();
+            txn.transaction::<_, (), DbErr>(async |txn| {
+                let _ = fruit::Entity::find().all(txn).await;
 
                 Ok(())
             })
+            .await
+            .unwrap();
+
+            Ok(())
         })
         .await
         .unwrap();
@@ -572,32 +564,26 @@ mod tests {
     async fn test_nested_transaction_2() {
         let db = MockDatabase::new(DbBackend::Postgres).into_connection();
 
-        db.transaction::<_, (), DbErr>(|txn| {
-            Box::pin(async move {
-                let _ = cake::Entity::find().one(txn).await;
+        db.transaction::<_, (), DbErr>(async |txn| {
+            let _ = cake::Entity::find().one(txn).await;
 
-                txn.transaction::<_, (), DbErr>(|txn| {
-                    Box::pin(async move {
-                        let _ = fruit::Entity::find().all(txn).await;
+            txn.transaction::<_, (), DbErr>(async |txn| {
+                let _ = fruit::Entity::find().all(txn).await;
 
-                        txn.transaction::<_, (), DbErr>(|txn| {
-                            Box::pin(async move {
-                                let _ = cake::Entity::find().all(txn).await;
+                txn.transaction::<_, (), DbErr>(async |txn| {
+                    let _ = cake::Entity::find().all(txn).await;
 
-                                Ok(())
-                            })
-                        })
-                        .await
-                        .unwrap();
-
-                        Ok(())
-                    })
+                    Ok(())
                 })
                 .await
                 .unwrap();
 
                 Ok(())
             })
+            .await
+            .unwrap();
+
+            Ok(())
         })
         .await
         .unwrap();

src/database/restricted_connection.rs

@@ -210,7 +210,6 @@ impl RestrictedTransaction {
     }
 }
 
-#[async_trait::async_trait]
 impl TransactionTrait for RestrictedConnection {
     type Transaction = RestrictedTransaction;
 
@@ -256,10 +255,7 @@ impl TransactionTrait for RestrictedConnection {
     #[instrument(level = "trace", skip(callback))]
     async fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c RestrictedTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c RestrictedTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -277,10 +273,7 @@ impl TransactionTrait for RestrictedConnection {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c RestrictedTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c RestrictedTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -292,7 +285,6 @@ impl TransactionTrait for RestrictedConnection {
     }
 }
 
-#[async_trait::async_trait]
 impl TransactionTrait for RestrictedTransaction {
     type Transaction = RestrictedTransaction;
 
@@ -338,10 +330,7 @@ impl TransactionTrait for RestrictedTransaction {
     #[instrument(level = "trace", skip(callback))]
     async fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c RestrictedTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c RestrictedTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -359,10 +348,7 @@ impl TransactionTrait for RestrictedTransaction {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c RestrictedTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c RestrictedTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -391,10 +377,7 @@ impl RestrictedTransaction {
     #[instrument(level = "trace", skip(callback))]
     async fn run<F, T, E>(self, callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'b> FnOnce(
-                &'b RestrictedTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'b>>
-            + Send,
+        F: for<'b> AsyncFnOnce(&'b RestrictedTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {

src/database/transaction.rs

@@ -137,10 +137,7 @@ impl DatabaseTransaction {
     #[instrument(level = "trace", skip(callback))]
     pub(crate) async fn run<F, T, E>(self, callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'b> FnOnce(
-                &'b DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'b>>
-            + Send,
+        F: for<'b> AsyncFnOnce(&'b DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -607,7 +604,6 @@ impl StreamTrait for DatabaseTransaction {
     }
 }
 
-#[async_trait::async_trait]
 impl TransactionTrait for DatabaseTransaction {
     type Transaction = DatabaseTransaction;
 
@@ -666,10 +662,7 @@ impl TransactionTrait for DatabaseTransaction {
     #[instrument(level = "trace", skip(_callback))]
     async fn transaction<F, T, E>(&self, _callback: F) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {
@@ -688,10 +681,7 @@ impl TransactionTrait for DatabaseTransaction {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'c> FnOnce(
-                &'c DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>>
-            + Send,
+        F: for<'c> AsyncFnOnce(&'c DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {

src/driver/sqlx_mysql.rs

@@ -229,10 +229,7 @@ impl SqlxMySqlPoolConnection {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'b> FnOnce(
-                &'b DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'b>>
-            + Send,
+        F: for<'b> AsyncFnOnce(&'b DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {

src/driver/sqlx_postgres.rs

@@ -267,10 +267,7 @@ impl SqlxPostgresPoolConnection {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'b> FnOnce(
-                &'b DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'b>>
-            + Send,
+        F: for<'b> AsyncFnOnce(&'b DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {

src/driver/sqlx_sqlite.rs

@@ -249,10 +249,7 @@ impl SqlxSqlitePoolConnection {
         access_mode: Option<AccessMode>,
     ) -> Result<T, TransactionError<E>>
     where
-        F: for<'b> FnOnce(
-                &'b DatabaseTransaction,
-            ) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'b>>
-            + Send,
+        F: for<'b> AsyncFnOnce(&'b DatabaseTransaction) -> Result<T, E> + Send,
         T: Send,
         E: std::fmt::Display + std::fmt::Debug + Send,
     {