How to make repositories accept pool connection or a single transaction as executor?

[Sirneij]

I currently have a setup where I have a store:

#[derive(Clone, Debug)]
pub struct Store {
    pub connection: PgPool,
}

pub struct UserContext {
    pub tenant_id: String,
    pub user_id: String,
}

impl Store {
    pub async fn new(db_url: &str) -> Self {
        match PgPoolOptions::new()
            .max_connections(8)
            .connect(db_url)
            .await
        {
            Ok(pool) => Store { connection: pool },
            Err(e) => {
                panic!("Couldn't establish DB connection! Error: {}", e)
            }
        }
    }
}

And repositories, for instance, AccountsRepo:

pub struct AccountsRepo {
    pub pool: PgPool,
}

impl From<PgPool> for AccountsRepo {
    fn from(pool: PgPool) -> Self {
        Self { pool }
    }
}

impl AccountsRepo {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
    #[tracing::instrument(skip(self))]
    pub async fn get_user_by_id(&self, id: Uuid) -> Result<Option<User>, sqlx::Error> {
        sqlx::query_as::<_, User>(
            r#"
            ...
            "#,
        )
        .bind(id)
        .fetch_optional(&self.pool)
        .await
    }
...
}

And it's used like:

let repo = AccountsRepo::from(state.db_store.connection.clone());

Is there an idiomatic and neat way to make the repositories ALSO accept transactions (or any Executor)? For example, so it can ALSO be used like this:

let pool = state.db_store.connection.clone();
let mut tx = match pool.begin().await {
    Ok(tx) => tx,
    Err(e) => return CustomAppError::from(e).into_response(),
};
let repo = AccountsRepo::from(&mut *tx); // For transactions