Responder for a foreign T: Error

[s0lst1ce]

Hello!
I have looked at the answered questions on GitHub but have not found one that answered my question. I'm writing a simple API with rocket (v0.5-rc1). For this I'm using another crate I built that provides me with structs and methods used for the "route" methods of the rocket crate. The library also provides an AdapterError enum that impls Debug, Error.

Now I would very much like to be able to do the following:

use library_crate::ret_error; //a function returning Result<(), AdapterError>
#[get("/some/route")]
async fn endpoint() -> Result<(), AdapterError> {
    ret_error().await?;
   Ok(())
}

The issue is that AdapterError doesn't implement rocket::Responder<'_, '_>. I could modify the code in the library so that it does but then I reach another issue. Indeed AdapterError is an enum with many variants and I would like to return a different message (Status or (Status, &str)) depending on the variant. Can I do this by implementing Responder?

Currently I pass Result<(), AdapterError> to a function I built that calls map_err on it and matches on the variant.
What are the rewcomended designs for this case?

[3olkin]

You can create another Error struct or enum or just type and impl From<AdapterError> for Error. This way you could use almost the same code as in your example, but you have to change from Result<(), AdapterError> to Result<(), Error

Small example:

use thiserror::Error;

#[derive(Debug, Error)]
pub enum Error {
    #[error("jwt error: {0}")]
    JwtError(#[from] jsonwebtoken::errors::Error),
    #[error("diesel query error: {0}")]
    DieselQueryError(#[from] diesel::result::Error),
    #[error("wrong credentials")]
    WrongCredentials,
}

impl From<Error> for api::Error {
    fn from(err: Error) -> Self {
        let (status, reason) = match err {
            _ => (Status::InternalServerError, "Unknown"),
        };
        let error = api::ErrorDetails {
            reason: reason.to_string(),
            description: err.to_string(),
        };
        (status, error).into()
    }
}

[s0lst1ce]

Thanks for your reply. I'm assuming api::Error is an error coming from the rocket binary? If so I don't quite understand what's the role of api::ErrorDetails? Does it implement Responder?
Also assuming I got it right there's the need to implement Responder on api::Error? I don't understand how this works.

[3olkin]

api::Error represents Custom<Json<api::ErrorDetails and api::ErrorDetails are my own struct. In general only api::Error should implement Responder.

[s0lst1ce]

Thank you very much for your help! I was able to fix all my issues and I can now handle errors in a simple and idiomatic way.

[s0lst1ce]

For eventual users finding themselves in the same predicament, here's what I came up with.

use thiserror;
use rocket::*; //only for the sake of this simplified example

//the foreign crate's `Error` type and a function that returns `Result<(), AdapterError>`
use foreign::{AdapterError, returning_adapter_error};

#[derive(Debug, thiserror::Error)]
#[error("We couldn't process your request: {reason}. Error: {source}")]
struct ApiError<'a> {
    status: Status,
    reason: &'a str,
    #[source]
    source: AdapterError,
}

impl<'a> From<AdapterError> for ApiError<'a> {
    fn from(err: AdapterError) -> Self {
        let (status, reason) = match &err {
            //you handle the variants and how they're processed here
            AdapterError::SqlxError(_) => (
                Status::InternalServerError,
                "sqlx driver failed to query the database",
            ),
            _ => todo!(),
        };

        ApiError {
            status,
            reason,
            source: err,
        }
    }
}

impl<'r, 'o: 'r> Responder<'r, 'o> for ApiError<'o> {
    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
        Response::build()
            .header(ContentType::JSON)
            .status(self.status)
            .sized_body(self.reason.len(), Cursor::new(self.reason))
            .ok()
    }
}

#[get("/some/route")]
async fn endpoint<'a>() -> Result<(), ApiError> {
    //remember this function returns `Result<(), AdapterError>`
    Ok(returning_adapter_error()?);
}