Trait IntoResponseParts

pub trait IntoResponseParts

Trait for adding headers and extensions to a response.

Example

use axum::{
    response::{ResponseParts, IntoResponse, IntoResponseParts, Response},
    http::{StatusCode, header::{HeaderName, HeaderValue}},
};

// Hypothetical helper type for setting a single header
struct SetHeader<'a>(&'a str, &'a str);

impl<'a> IntoResponseParts for SetHeader<'a> {
    type Error = (StatusCode, String);

    fn into_response_parts(self, mut res: ResponseParts) -> Result<ResponseParts, Self::Error> {
        match (self.0.parse::<HeaderName>(), self.1.parse::<HeaderValue>()) {
            (Ok(name), Ok(value)) => {
                res.headers_mut().insert(name, value);
            },
            (Err(_), _) => {
                return Err((
                    StatusCode::INTERNAL_SERVER_ERROR,
                    format!("Invalid header name {}", self.0),
                ));
            },
            (_, Err(_)) => {
                return Err((
                    StatusCode::INTERNAL_SERVER_ERROR,
                    format!("Invalid header value {}", self.1),
                ));
            },
        }

        Ok(res)
    }
}

// It's also recommended to implement `IntoResponse` so `SetHeader` can be used on its own as
// the response
impl<'a> IntoResponse for SetHeader<'a> {
    fn into_response(self) -> Response {
        // This gives an empty response with the header
        (self, ()).into_response()
    }
}

// We can now return `SetHeader` in responses
//
// Note that returning `impl IntoResponse` might be easier if the response has many parts to
// it. The return type is written out here for clarity.
async fn handler() -> (SetHeader<'static>, SetHeader<'static>, &'static str) {
    (
        SetHeader("server", "axum"),
        SetHeader("x-foo", "custom"),
        "body",
    )
}

// Or on its own as the whole response
async fn other_handler() -> SetHeader<'static> {
    SetHeader("x-foo", "custom")
}

Associated Types

type Error: IntoResponse;

The type returned in the event of an error.

This can be used to fallibly convert types into headers or extensions.

Required Methods

fn into_response_parts(self, res: ResponseParts) -> Result<ResponseParts, Self::Error>

Set parts of the response

Implementors