Trying to implement anyhow and diesel examples together

[manstie]

Summary

I am attempting to implement two examples together:
https://github.com/tokio-rs/axum/blob/main/examples/anyhow-error-response/src/main.rs
https://github.com/tokio-rs/axum/blob/main/examples/diesel-postgres/src/main.rs

The database table:

diesel::table! {
    messages (id) {
        id -> Int4,
        body -> Varchar,
        date -> Timestamp,
        deleted -> Bool,
    }
}

Cargo.toml:

[dependencies]
anyhow = "1.0"
axum = "0.7"
chrono = "0.4.31"
deadpool-diesel = { version = "0.5", features = ["postgres"] }
diesel = { version = "2.1", features = ["postgres", "chrono"] }
diesel_migrations = "2.1"
dotenvy = "0.15.0"
tokio = { version = "1.35", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

errors.rs:

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
};

// Make our own error that wraps `anyhow::Error`.
pub struct AppError(anyhow::Error);

// Tell axum how to convert `AppError` into a response.
impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            format!("Something went wrong: {}", self.0),
        )
            .into_response()
    }
}

// This enables using `?` on functions that return `Result<_, anyhow::Error>` to turn them into
// `Result<_, AppError>`. That way you don't need to do that manually.
impl<E> From<E> for AppError
where
    E: Into<anyhow::Error>,
{
    fn from(err: E) -> Self {
        Self(err.into())
    }
}

api.rs:

use crate::errors::AppError;
use crate::{models::message::Message, schema::messages};
use axum::{extract::State, response::Json, routing::get, Router};
use diesel::{QueryDsl, RunQueryDsl, SelectableHelper};

pub fn routes(db_pool: deadpool_diesel::postgres::Pool) -> Router {
    Router::new()
        .route("/messages", get(get_messages))
        .with_state(db_pool)
}

async fn get_messages(
    State(pool): State<deadpool_diesel::postgres::Pool>,
) -> Result<Json<Vec<Message>>, AppError> {
    let conn = pool.get().await?;

    let res = conn
        .interact(|conn| messages::table.select(Message::as_select()).load(conn))
        .await??;

    Ok(Json(res))
}

But I'm getting two errors. The first one is the first ? after interact(...).await?? where it says:

`(dyn std::any::Any + std::marker::Send + 'static)` cannot be shared between threads safely
the trait `std::marker::Sync` is not implemented for `(dyn std::any::Any + std::marker::Send + 'static)`
the following other types implement trait `std::ops::FromResidual<R>`:
  <std::result::Result<T, F> as std::ops::FromResidual<std::ops::Yeet<E>>>
  <std::result::Result<T, F> as std::ops::FromResidual<std::result::Result<std::convert::Infallible, E>>>
required for `std::ptr::Unique<(dyn std::any::Any + std::marker::Send + 'static)>` to implement `std::marker::Sync`
required for `anyhow::Error` to implement `std::convert::From<deadpool_diesel::InteractError>`
required for `deadpool_diesel::InteractError` to implement `std::convert::Into<anyhow::Error>`
1 redundant requirement hidden
required for `errors::AppError` to implement `std::convert::From<deadpool_diesel::InteractError>`
required for `std::result::Result<axum::Json<std::vec::Vec<models::message::Message>>, errors::AppError>` to implement `std::ops::FromResidual<std::result::Result<std::convert::Infallible, deadpool_diesel::InteractError>>`rustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B0%5D?0#file code/routes/api.rs)
boxed.rs(195, 12): required because it appears within the type `Box<dyn Any + Send>`
lib.rs(36, 10): required because it appears within the type `InteractError`

which goes away if I replace my AppError(anyhow::Error) with AppError(Box<dyn std::error::Error>).

And the second error: is with .route("/messages", get(get_messages)):

the trait bound `fn(axum::extract::State<deadpool_diesel::Pool<deadpool_diesel::Manager<diesel::PgConnection>>>) -> impl std::future::Future<Output = std::result::Result<axum::Json<std::vec::Vec<models::message::Message>>, errors::AppError>> {routes::api::get_messages}: axum::handler::Handler<_, _>` is not satisfied
the following other types implement trait `axum::handler::Handler<T, S>`:
  <axum::handler::Layered<L, H, T, S> as axum::handler::Handler<T, S>>
  <axum::routing::MethodRouter<S> as axum::handler::Handler<(), S>>rustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B0%5D?0#file code/routes/api.rs)
api.rs(8, 29): required by a bound introduced by this call
method_routing.rs(140, 16): required by a bound in `axum::routing::get`

I'm not sure how to handle this error?

Would appreciate any suggestions on how to implement generic error handling in axum with diesel.

axum version

0.7.4

[manstie]

I needed to add #[derive(serde::Serialize)] to my model for the second error.

Is there a way to have anyhow handle boxed errors?

[davidpdrsn]

What type does conn.interact(|conn| messages::table.select(Message::as_select()).load(conn)) return?

[manstie]

It is a deadpool_diesel::InteractError:

pub enum InteractError {
    /// Provided callback has panicked.
    Panic(Box<dyn Any + Send + 'static>),

    /// Callback was aborted.
    Aborted,
}

[domoritz]

Did you figure out how to make InteractError and anyhow::Error work together? I'm seeing the same compile errors as you.

[manstie]

Did you figure out how to make InteractError and anyhow::Error work together? I'm seeing the same compile errors as you.

just ditch anyhow and go with a generic error handler e.g. https://gist.github.com/manstie/ef93450a0d8521589be7ce59e70e266c