idiomatic way to return errors with json body and StatusCode::Ok

[danieleades]

i'm making a toy server that implements the alternative registries web API.
The endpoints all need to return a 200 response on errors, with a json body encoding the actual details.

I'm struggling to find a nice pattern for doing this using tide.

• My endpoint functions have to return Result<impl Into<Response>, tide::Error>, even though the tide::Error path is never reachable.
• i can't propagate errors with the ? operator-

what i've come up with is an "inner" endpoint function that returns a result, and then a "public" endpoint function that converts that Result into a tide::Response and Ok-wraps it. It works, but it feels slightly clumsy.

pub async fn endpoint(request: Request<State>) -> tide::Result<tide::Response> {
    Ok(
        match inner_endpoint(request).await {
            Ok(response) => response.into(),
            Err(e) => e.into()
        }
    )
}

pub async fn inner_endpoint(request: Request<State>) -> Result<MyResponse, MyError> {
    ...
}

impl From<MyError> for tide::Response {
    fn from(e: MyError) -> Self {
        ...
    }
}

impl From<MyResponse> for tide::Response {
    fn from(e: MyResponse) -> Self {
        ...
    }
}

[danieleades]

i suspect this is a duplicate of #452

[sdimkov]

I guess returning 2xx HTTP statuses on failure is not your choice but I also hope you agree that it is a gross anti-pattern.

Not the most helpful comment but I couldn’t resist

[danieleades]

I guess returning 2xx HTTP statuses on failure is not your choice but I also hope you agree that it is a gross anti-pattern.

I don't really have a strong opinion here. It indicates that the operation executed successfully, and allows you to provide a structured response. Also the API is only ever consumed by one client, which is expecting precisely this. But as you say, it's out of my hands anyway

Even if you were returning other http codes, but wanted to choose them manually, or set a custom body or headers, you'd run into the problem I'm describing. It's in no way specific to 200 codes.

Not the most helpful comment but I couldn’t resist

Agreed.

[Fishrock123]

Will this be addressed by #549?

    app.middleware(ErrorHandler::new(
        |err: tide::http::url::ParseError| async move {
            Ok(Response::new(StatusCode::Ok).body_json(json_api_error_response))
        },
    ));

[danieleades]

@Fishrock123 possibly! Conceptually though, it does seem awkward to take a structured error, convert to a tide::Error, and then use a handler to turn it back into some structured error response

[Fishrock123]

Is this still an issue in Tide 0.12? (i.e. with #570)

[yoshuawuyts]

It should now indeed be possible to write:

let mut app = tide::new();
app.at("/").get(|_| async { Ok(json!({ "hello": "nori" })) });
app.listen("localhost:8080").await?;