Can I implement actix_web::ResponseError trait for rustis::Error?

[bioinformatist]

@mcatanzariti Hi Michaël, we're developing web apps with actix-web and rustis. In order to use Result<impl Responder, E> as the return value of actix-web's handlers, the actix_web::ResponseError trait needs to be implemented for rustis::Error. I think rustis is the best Redis client (with well-designed architecture and easy-to-use APIs), and given that Redis will be utilized by numerous applications, I believe this implementation will greatly benefit many developers (and also attract new users for us). May I submit a PR for this?

[mcatanzariti]

Hi @bioinformatist,

In my opinion, the best way to handle errors in web frameworks is to define your own error enum.

It would not be scalable to ask every library to implement the error traits defined by all existing frameworks.

This is a solution I use for my own rest apis:

You can then implement the trait actix_web::ResponseError on your custom error and implement From<rustis::Error> manually or with the help of the crate thiserror

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Rustis Error: {0}")]
    Rustis(#[from] rustis::Error),
    // Add other nested errors here
}

implement actix_web::ResponseError for Error {
    // Implement the trait here
}

You can then declare routes with functions returning your custom error and you use the idiomatic error ? operator to return rustis errors which will be automatically converted to your custom error.

Please let me know if this solution is suitable for you and will close this issue.

PS: thank you for the good words about rustis <3

[bioinformatist]

Yeah, currently I use snafu to define all errors:

use actix_web::error;
use snafu::prelude::*;

#[non_exhaustive]
#[derive(Debug, Snafu)]
#[snafu(visibility(pub(super)))]
pub(super) enum Error {
    #[snafu(display("Error interacting with redis: {source}"))]
    InternalError { source: rustis::Error },
}

impl error::ResponseError for Error {}

I agree that we don't need to implement such traits for every framework. My suggestion is to add a feature through conditional compilation (similar to the serde feature for many crates, disabled by default) to bring convenience to users, making rustis more attractive.

[mcatanzariti]

Hi @bioinformatist,

My point is that, even with conditional compilation it would not be scalable to add such convenience to rustis or any other library. We should then add conveniences for axum, rocket, etc.

Moreover this convenience is not needed because the rust idiomatic way of implementing error management is through the implementation of the From trait to convert automatically (with Rust syntax sugaring of the ? operator) a lower level error (e.g. rustis::Error) to the expected return error.

Cheers

[bioinformatist]

Got that. I buy your point!

Cheers!

[mcatanzariti]

By the way, you can fine a complete example here:
https://github.com/dahomey-technologies/rustis/blob/main/examples/actix_crud.rs

In this example, From<rustis::Error> is implemented manually and the rustis error is not kept in an enum.

[bioinformatist]

Ahhh my eyes missed these fantastic examples! Thanks for such a detailed reply!