IntoResponse 与 IntoResponseParts

pub trait IntoResponse {
    /// Create a response.
    #[must_use]
    fn into_response(self) -> Response;
}

impl<T> IntoResponse for Html<T>
where
    T: IntoResponse,
{
    fn into_response(self) -> Response {
        (
            [(
                header::CONTENT_TYPE,
                HeaderValue::from_static(mime::TEXT_HTML_UTF_8.as_ref()),
            )],
            self.0,
        )
            .into_response()
    }
}

pub trait IntoResponseParts {
    /// The type returned in the event of an error.
    ///
    /// This can be used to fallibly convert types into headers or extensions.
    type Error: IntoResponse;

    /// Set parts of the response
    fn into_response_parts(self, res: ResponseParts) -> Result<ResponseParts, Self::Error>;
}

        impl<R, $($ty,)*> IntoResponse for (StatusCode, $($ty),*, R)
        where
            $( $ty: IntoResponseParts, )*
            R: IntoResponse,
        {
            fn into_response(self) -> Response {
                let (status, $($ty),*, res) = self;

                let res = res.into_response();
                let parts = ResponseParts { res };

                $(
                    let parts = match $ty.into_response_parts(parts) {
                        Ok(parts) => parts,
                        Err(err) => {
                            return err.into_response();
                        }
                    };
                )*

                (status, parts.res).into_response()
            }
        }

use axum::{http::StatusCode, response::IntoResponse};

fn created() -> impl IntoResponse {
  ([("x-request-id", "42")], StatusCode::CREATED, "made it")
}

fn main() {
  let _ = created().into_response();
}

error[E0277]: the trait bound `StatusCode: IntoResponseParts` is not satisfied
 --> src/main.rs:3:17
  |
3 | fn created() -> impl IntoResponse {
  |                 ^^^^^^^^^^^^^^^^^ the trait `IntoResponseParts` is not implemented for `StatusCode`
4 |   ([("x-request-id", "42")], StatusCode::CREATED, "made it")
  |   ---------------------------------------------------------- return type was inferred to be `([(&str, &str); 1], StatusCode, &str)` here
  |
  = help: the following other types implement trait `IntoResponseParts`:
            ()
            (T1,)
            (T1, T2)
            (T1, T2, T3)
            (T1, T2, T3, T4)
            (T1, T2, T3, T4, T5)
            (T1, T2, T3, T4, T5, T6)
            (T1, T2, T3, T4, T5, T6, T7)
          and 15 others
  = note: required for `([(&str, &str); 1], StatusCode, &str)` to implement `IntoResponse`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `exp-axum-body-bad` (bin "exp-axum-body-bad") due to 1 previous error

use axum::{
  Json,
  http::{HeaderMap, StatusCode, header},
  response::{AppendHeaders, IntoResponse, Response},
};
use http_body_util::BodyExt;
use std::collections::HashMap;

async fn show(name: &str, res: Response) {
  let status = res.status();
  let headers: Vec<String> = res
    .headers()
    .iter()
    .map(|(k, v)| format!("{k}: {}", v.to_str().unwrap()))
    .collect();
  let body = res.into_body().collect().await.unwrap().to_bytes();
  println!("{name}\n  {status} | {} | {:?}", headers.join(", "), String::from_utf8_lossy(&body));
}

#[tokio::main]
async fn main() {
  show("1 (StatusCode, [..], body)", (StatusCode::CREATED, [("x-id", "42")], "made").into_response()).await;
  show("2 ([content-type], &str)", ([(header::CONTENT_TYPE, "text/html")], "<b>hi</b>").into_response()).await;
  show("3 ([..], StatusCode)", ([("x-id", "42")], StatusCode::ACCEPTED).into_response()).await;

  let cookies = [(header::SET_COOKIE, "a=1"), (header::SET_COOKIE, "b=2")];
  show("4 [(K, V); 2]", (cookies.clone(), ()).into_response()).await;
  show("5 AppendHeaders", (AppendHeaders(cookies), ()).into_response()).await;

  let mut map = HeaderMap::new();
  map.append(header::SET_COOKIE, "a=1".parse().unwrap());
  map.append(header::SET_COOKIE, "b=2".parse().unwrap());
  map.insert(header::CONTENT_TYPE, "text/html".parse().unwrap());
  show("6 HeaderMap", (map, "<b>hi</b>").into_response()).await;

  show("7 bad header name", (StatusCode::CREATED, [("bad header", "x")], "made").into_response()).await;

  let mut m = HashMap::new();
  m.insert((1, 2), 3);
  show("8 Json alone", Json(m.clone()).into_response()).await;
  show("9 (StatusCode, Json)", (StatusCode::IM_A_TEAPOT, Json(m)).into_response()).await;
}

1 (StatusCode, [..], body)
  201 Created | content-type: text/plain; charset=utf-8, x-id: 42 | "made"
2 ([content-type], &str)
  200 OK | content-type: text/html | "<b>hi</b>"
3 ([..], StatusCode)
  202 Accepted | x-id: 42 | ""
4 [(K, V); 2]
  200 OK | set-cookie: b=2 | ""
5 AppendHeaders
  200 OK | set-cookie: a=1, set-cookie: b=2 | ""
6 HeaderMap
  200 OK | content-type: text/html, set-cookie: a=1, set-cookie: b=2 | "<b>hi</b>"
7 bad header name
  500 Internal Server Error | content-type: text/plain; charset=utf-8 | "invalid HTTP header name"
8 Json alone
  500 Internal Server Error | content-type: text/plain; charset=utf-8 | "key must be a string"
9 (StatusCode, Json)
  418 I'm a teapot | content-type: text/plain; charset=utf-8 | "key must be a string"

pub type Result<T, E = ErrorResponse> = std::result::Result<T, E>;

impl<T> IntoResponse for Result<T>
where
    T: IntoResponse,
{
    fn into_response(self) -> Response {
        match self {
            Ok(ok) => ok.into_response(),
            Err(err) => err.0,
        }
    }
}

#[derive(Debug)]
#[must_use]
pub struct ErrorResponse(Response);

impl<T> From<T> for ErrorResponse
where
    T: IntoResponse,
{
    fn from(value: T) -> Self {
        Self(value.into_response())
    }
}

use axum::{
  Router,
  body::Body,
  extract::{Path, Request},
  http::StatusCode,
  response::{IntoResponse, Response},
  routing::get,
};
use http_body_util::BodyExt;
use tower::ServiceExt;

#[allow(dead_code)]
enum AppError {
  NotFound(u32),
  Db(String),
}

impl IntoResponse for AppError {
  fn into_response(self) -> Response {
    match self {
      AppError::NotFound(id) => (StatusCode::NOT_FOUND, format!("user {id} not found")).into_response(),
      AppError::Db(_) => (StatusCode::INTERNAL_SERVER_ERROR, "internal error").into_response(),
    }
  }
}

async fn user(Path(id): Path<u32>) -> Result<String, AppError> {
  match id {
    1 => Ok("ann".to_owned()),
    2 => Err(AppError::Db("connection reset".to_owned())),
    _ => Err(AppError::NotFound(id)),
  }
}

// axum::response::Result<T> = Result<T, ErrorResponse>; any IntoResponse converts via `?`
async fn mixed(Path(id): Path<u32>) -> axum::response::Result<&'static str> {
  if id == 0 {
    Err((StatusCode::BAD_REQUEST, "id must be positive"))?;
  }
  if id > 100 {
    Err(StatusCode::IM_A_TEAPOT)?;
  }
  Ok("fine")
}

#[tokio::main]
async fn main() {
  let app = Router::new().route("/user/{id}", get(user)).route("/mixed/{id}", get(mixed));
  for uri in ["/user/1", "/user/2", "/user/9", "/mixed/0", "/mixed/5", "/mixed/500"] {
    let res = app.clone().oneshot(Request::get(uri).body(Body::empty()).unwrap()).await.unwrap();
    let status = res.status();
    let b = res.into_body().collect().await.unwrap().to_bytes();
    println!("{uri:<11} {status} {:?}", String::from_utf8_lossy(&b));
  }
}

/user/1     200 OK "ann"
/user/2     500 Internal Server Error "internal error"
/user/9     404 Not Found "user 9 not found"
/mixed/0    400 Bad Request "id must be positive"
/mixed/5    200 OK "fine"
/mixed/500  418 I'm a teapot ""

a: 200 OK location=["/next"]
b: 308 Permanent Redirect location=["/other"]