Returning Response from endpoint

[jafioti]

I'm trying to move my server to 0.5.0, and am having trouble with returning a Response<'a> from an endpoint.

Previously I did:

pub async fn endpoint<'a>() -> Response<'a>

Now I get an error the trait bound rocket::Response<'_>: rocket::response::Responder<'_, '_> is not satisfied

I read the changelog and noticed this line:

Removed Responder impl for Response. Prefer custom responders with #[derive(Responder)].

The problem is that I'm not sure if I can use a custom responder, since I am returning a JSON response with CORS options:

return Response::build()
        .raw_header("Access-Control-Allow-Origin", "*")
        .raw_header("Access-Control-Allow-Methods", "OPTIONS, POST")
        .raw_header("Access-Control-Allow-Headers", "Content-Type")
        .sized_body(return_string.len(), Cursor::new(return_string))
        .finalize();

Is it possible to create a custom responder with raw headers like those above?

[SergioBenitez]

Is it possible to create a custom responder with raw headers like those above?

Of course. Everything that sends a response is a Responder, so if this wasn't possible, Rocket would be rather useless. See the Responder docs.

[jafioti]

Ok so I built a wrapper around the responder to return a string with those headers and I think it will work. Thanks!

[JenChampagne]

Is there any way to still use a Response Builder like the example given, or must they all be replaced for 0.5? @SergioBenitez

Just wanting to confirm before I spend time upgrading my projects and replacing all of these custom Responses.

[BlitzBanana]

@JenChampagne Yeah it would be nice to be able to do it like that:

trait ToResponseHelper<'r> {
    fn to_response_builder(self) -> &'r mut rocket::response::Builder<'static>;
    fn to_response(self) -> rocket::Response<'static>;
}

impl<'r> ToResponseHelper<'r> for maud::Markup {
    fn to_response_builder(self) -> &'r mut rocket::response::Builder<'static> {
        let body = self.render().into_string();
        rocket::Response::build()
            .header(rocket::http::ContentType:: HTML)
            .sized_body(body.len(), std::io::Cursor::new(body))
    }

    fn to_response(self) -> rocket::Response<'static> {
        self.to_response_builder().finalize()
    }
}

#[post("/register", data = "<profile>")]
pub async fn register_action<'r>(
    profile: Form<RegisterActionData<'_>>,
    pool: &State<PgPool>,
) -> impl Responder<'r, 'static> {
    let registration = profile
        .try_to_user_registration()
        .map_err(|error| {
            views::auth::register_form_partial(
                Some(profile.email),
                Some(profile.username),
                Some(&error)
            )
                .to_response_builder()
                .status(rocket::http::Status::BadRequest)
                .finalize()
        })?;

    register_new_user(&registration, pool)
        .await
        .map(|_| {
            views::empty()
                .to_response_builder()
                .raw_header("HX-Redirect", uri!(index_page()).to_string())
                .finalize()
        })
        .map_err(|error| {
            views::auth::register_form_partial(
                Some(profile.email),
                Some(profile.username),
                Some(&error)
            )
                .to_response_builder()
                .status(rocket::http::Status::InternalServerError)
                .finalize()
        })
}

Or is there something I'm missing ? (still in early rust learning)
The removal of the implementation of Responder by Response is giving me a hard time.