Trait SaveRepositoryTransaction

pub trait SaveRepositoryTransaction<M>: SaveRepository<M> + TransactionRepository<M>
where
    M: Model + Send + Sync,
{
    // Provided method
    fn save_in_transaction<'a>(
        &'a self,
        model: M,
    ) -> impl Future<Output = Result<M, Error>> + Send + 'a
       where M: 'a { ... }
}

Extension trait for Save operations with transactions.

This trait provides convenience methods for using transactions with repositories that implement SaveRepository. It’s automatically implemented for any type that implements both SaveRepository<M> and TransactionRepository<M>.

Provided Methods

fn save_in_transaction<'a>( &'a self, model: M, ) -> impl Future<Output = Result<M, Error>> + Send + 'a

where M: 'a,

Saves a model in a transactions, ensuring atomicity.

This method:

1. Creates a transactions using with_transaction
2. Calls save_with_executor with the transactions
3. Returns the model on successful save

Parameters

• model: The model to save

Returns

A future that resolves to:

• Ok(M): The saved model on success
• Err(crate::Error): The error if saving failed

Example

let saved_model = repo.save_in_transaction(model).await?;

Examples found in repository

examples/basic_repo.rs (line 200)

async fn main() {
    install_default_drivers();

    initialize_db_pool(
        PoolOptions::new()
            .max_connections(21)
            .min_connections(5)
            .idle_timeout(Duration::from_secs(60 * 10))
            .max_lifetime(Duration::from_secs(60 * 60 * 24))
            .acquire_timeout(Duration::from_secs(20))
            .connect(&DATABASE_URL)
            .await
            .expect("Failed to connect to database"),
    );

    let user = User {
        id: 1,
        name: String::new(),
    };

    USER_REPO.save_ref(&user).await.unwrap();

    USER_REPO.save_in_transaction(user.clone()).await.unwrap();

    USER_REPO
        .save_with_context(user.clone(), UserContext::System)
        .await
        .unwrap();

    USER_REPO.with_transaction(action).await.unwrap();

    USER_REPO
        .delete_by_values_in_transaction("id", [1, 2, 3, 11, 22])
        .await
        .unwrap();

    USER_REPO
        .get_one_by_filter(UserFilter::new("name").id(1))
        .await
        .unwrap();
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, M> SaveRepositoryTransaction<M> for T

where T: SaveRepository<M> + TransactionRepository<M>, M: Model + Send + Sync,