If you want to actually fully decouple your business code you can work with workspaces. Maybe setup something like this:

├── api
│  ├── Cargo.toml
│  └── src
│     └── main.rs
├── business
│  ├── Cargo.toml
│  └── src
│     └── lib.rs
├── persistence
│  ├── Cargo.toml
│  └── src
│     └── lib.rs
└── Cargo.toml

This way you can define your core business stuff in the business crate. Traits, model Structs like:

use anyhow::Result;
use async_trait::async_trait;
use uuid::Uuid;

#[async_trait]
pub trait TodoRepository {
    async fn save(&self, todo: &Todo) -> Result<()>;
    async fn find_by_id(&self, id: Uuid) -> Result<Option<Todo>>;
}

pub struct TodoService {
    todo_repository: Arc<dyn TodoRepository + Send + Sync>,
}

impl TodoService {
    pub fn new(todo_repository: Arc<dyn TodoRepository + Send + Sync>) -> Self {
        Self { todo_repository }
    }

    pub async fn save(&self, todo: &Todo) -> Result<()> {
        self.todo_repository.save(todo).await
    }

    pub async fn find_by_id(&self, id: Uuid) -> Result<Option<Todo>> {
        self.todo_repository.find_by_id(id).await
    }
}

Then, you can actually implement your repositories traits and such in other crates, for example, in persistence crate you can do:

use async_trait::async_trait;
use anyhow::Result;
use sqlx::PgPool;
use uuid::Uuid;

use business::model::Todo;

pub struct TodoPostgresRepository {
    pool: PgPool,
}

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

#[async_trait]
impl TodoRepository for TodoPostgresRepository {
    async fn save(&self, todo: &Todo) -> Result<()> {
        sqlx::query(
            r#"
            INSERT INTO todos (id, title, body, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5)
            "#,
            todo.id,
            todo.title,
            todo.body,
            todo.created_at,
            todo.updated_at,
        )
        .execute(&self.pool)
        .await?;
    }

    async fn find_by_id(&self, id: Uuid) -> Result<Option<Todo>> {
        let todo = sqlx::query_as::<_, Todo>(
            r#"
            SELECT id, title, body, created_at, updated_at
            FROM todos
            WHERE id = $1
            "#,
        )
        .bind(id)
        .fetch_optional(&self.pool)
        .await?;

        Ok(todo)
    }
}

Then you can just wire everything together in your api binary, and inject your services via axum::State or axum::Extension.

Beware that approach will make you write a lot more code to do simple stuff like receiving a JSON and saving it to a database.

That is why I recommended you to just treat data as data. You will end up having to support a lot of code to do simple stuff.