Struct Transaction 

pub struct Transaction;

Typed transactions over the explicit &Db — SeaORM and SQLx paths.

This is a namespace for the two transaction entry points; it holds no state. Construct nothing — call Transaction::orm or Transaction::sqlx with an explicit &Db.

Implementations

impl Transaction

pub async fn orm<F, T>(db: &Db, f: F) -> Result<T, DataError>

where F: for<'c> FnOnce(&'c DatabaseTransaction) -> Pin<Box<dyn Future<Output = Result<T, DbErr>> + Send + 'c>> + Send, T: Send,

Run a closure inside a SeaORM transaction over db.orm().

The closure receives a &sea_orm::DatabaseTransaction to pass to SeaORM operations (e.g. active.insert(txn)). SeaORM commits when the closure returns Ok and rolls back when it returns Err — that is SeaORM’s transaction semantics, surfaced without additional magic.

use arcature_data::Transaction;
Transaction::orm(db, |txn| Box::pin(async move {
    // SeaORM operations against `txn`…
    Ok::<_, arcature_db::sea_orm::DbErr>(())
}))
.await?;

Errors

Returns DataError::Database if the transaction fails (the closure returned Err, or the commit/rollback itself errored).

pub async fn sqlx<F, T>(db: &Db, f: F) -> Result<T, DataError>

where F: for<'c> FnOnce(&'c mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<T, Error>> + Send + 'c>>, T: Send,

Run a closure inside a raw SQLx transaction over db.sqlx().

The closure receives a &mut sqlx::Transaction for raw SQLx operations (sqlx::query!(...).execute(&mut **txn)). The wrapper commits when the closure returns Ok; on Err it rolls back (SQLx rolls back an uncommitted transaction) and returns the error.

This preserves the raw SQLx escape hatch with explicit ownership and no Arcature-added transaction semantics.

Errors

Returns DataError::Sqlx if BEGIN, the closure’s query, or COMMIT fails.