How to use question mark operator (?) for errors

[dfego]

I'm currently trying to build out a small Rocket REST API that primarily wraps database calls. Normally I use anyhow for making error handling easy, but I don't think it works with Rocket currently. Please correct me if that's wrong. So then I went my backup plan on using an error enum. Using thiserror, an abridged example would be:

use thiserror::Error;

/// Error type for this crates
#[derive(Error, Debug, Responder)]
pub enum Error {
    #[response(status = 500)]
    #[error("database error")]
    DatabaseError(#[from] sqlx::Error),
}

Or so I thought. When I try and derive Responder on my error type, the issue is that sqlx::Error does not implement it, so it doesn't work. I'm under the impression I can't be alone in this, but I've struggled thus far to find any resources that directly address the correct way to solve this since, I assume (or at least hope) there is an intended way to do this.

For reference, the error for the above is:

the trait bound `sqlx::Error: Responder<'_, '_>` is not satisfied

Apologies if I missed another discussion, but it's hard to search for things that are about ?.

[dfego]

For anyone coming after this, I ended up grabbing the code from rocket_anyhow and using it in my project. The crate itself is pinned against an older version of Rocket.

[the10thWiz]

Another option for solving this issue would be wrapper either sqlx::Error or Error in something like Debug, or another generic responder. The main issue, is that sqlx::Error doesn't define how it should be converted into a response - e.g., how should Rocket serialize it, what status and headers should be sent, etc.

A true solution would probably look like a custom Responder impl, something like this:

impl<'r> Responder<'r, 'static> for Error {
    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
        Response::build_from(json!({
                "status": 500,
                "error": format!("{}", self),
            }).respond_to(req)?)
            .status(Status::InternalServerError)
            .ok()
    }
}

[raif-s-naffah]

brilliant!

i adopted this solution in my error enum, which like the OP derives thiserror::Error. however i also added the followings:

1. another variant to the error enum like so...

    /// Rocket-fiendly handler error.
    #[error("Rocket handler error ({status}): {info}")]
    HTTP {
        /// HTTP Status code.
        status: rocket::http::Status,
        /// Text message giving more context to the reason this error was raised.
        info: std::borrow::Cow<'static, str>,
    },

2. an impl to my error that does this...

    /// Return a new instance that is an HTTP variant w/ the designated Status
    /// code and the original error string.
    pub fn with_status(self, s: Status) -> Self {
        match self {
            MyError::HTTP { status, info } => {
                tracing::info!("Replace status {} w/ {}", status, s);
                MyError::HTTP { status: s, info }
            }
            _ => MyError::HTTP { status: s, info: self.to_string().into() },
        }
    }

the new variant caters for business and other logic constraint violations in the process of handling a request.

the impl method "maps" an instance of the error raised in other parts/layers of the server.