How can I commit() this transaction?

[frederikhors]

In the below code I'm getting this error:

error[E0599]: no method named `commit` found for mutable reference `&mut sqlx::PgConnection` in the current scope
   --> src/main.rs:103:12
    |
103 |         db.commit().await?;
    |            ^^^^^^ method not found in `&mut PgConnection`

I need to commit if the db is None since I'm starting a new transaction with: &mut self.pool.begin().await?.

It's ok to use db: Option<&mut sqlx::PgConnection> as argument type or should I use something else, like Acquire trait?

Code on Rust Playground

impl Repository {
    pub fn new(pool: sqlx::PgPool) -> Self {
        Self { pool }
    }

    pub async fn find_player_id(
        &self,
        db: Option<&mut sqlx::PgConnection>,
        id: &str,
    ) -> Result<String, Error> {
        let db = match db {
            Some(db) => db,
            None => &mut self.pool.acquire().await?,
        };

        let query = "SELECT * FROM player WHERE id = $1";

        let id = sqlx::query_scalar(query).bind(id).fetch_optional(db).await?.ok_or(Error::RowNotFound)?;

        Ok(id)
    }
}

pub struct PlayerService {
    repo: Arc<Repository>,
    pool: sqlx::PgPool,
    team_service: TeamService,
}

impl PlayerService {
    pub fn new(repo: Arc<Repository>, pool: sqlx::PgPool, team_service: TeamService) -> Self {
        Self {
            repo,
            pool,
            team_service,
        }
    }

    pub async fn find_player_id(
        &self,
        db: Option<&mut sqlx::PgConnection>,
        id: &str,
        team_id: &str,
    ) -> Result<String, Error> {
        let db = match db {
            Some(db) => db,
            None => &mut self.pool.begin().await?,
        };

        let _ = self.team_service.find_team_id(Some(db), team_id).await?;

        let player_id = self.repo.find_player_id(Some(db), id).await?;

        db.commit().await?;

        Ok(player_id)
    }
}

pub struct TeamService {
    repo: Arc<Repository>,
    pool: sqlx::PgPool,
}

impl TeamService {
    pub fn new(repo: Arc<Repository>, pool: sqlx::PgPool) -> Self {
        Self { repo, pool }
    }

    pub async fn find_team_id(
        &self,
        db: Option<&mut sqlx::PgConnection>,
        id: &str,
    ) -> Result<String, Error> {
        let db = match db {
            Some(db) => db,
            None => &mut self.pool.begin().await?,
        };

        let team_id = self.repo.find_team_id(db, id).await?;

        Ok(team_id)
    }
}

[CommanderStorm]

I think this is at the core the same issue as here #3406 (comment)

=> If you simply your code to not have two sources of truth for your PGConnection (db vs pool) you are going to have a much better life. You also don't want two sources for your pool.. that seems very messy (not buggy messy, but in my experience in rust the simpler solution is better)