src/response.rs

//! Types and traits for generating responses.

use crate::Body;
use bytes::Bytes;
use http::{header, HeaderMap, HeaderValue, Response, StatusCode};
use serde::Serialize;
use std::{borrow::Cow, convert::Infallible};
use tower::util::Either;

/// Trait for generating responses.
///
/// Types that implement `IntoResponse` can be returned from handlers.
pub trait IntoResponse {
    /// Create a response.
    fn into_response(self) -> Response<Body>;
}

impl IntoResponse for () {
    fn into_response(self) -> Response<Body> {
        Response::new(Body::empty())
    }
}

impl IntoResponse for Infallible {
    fn into_response(self) -> Response<Body> {
        match self {}
    }
}

impl<T, K> IntoResponse for Either<T, K>
where
    T: IntoResponse,
    K: IntoResponse,
{
    fn into_response(self) -> Response<Body> {
        match self {
            Either::A(inner) => inner.into_response(),
            Either::B(inner) => inner.into_response(),
        }
    }
}

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

impl IntoResponse for Response<Body> {
    fn into_response(self) -> Self {
        self
    }
}

impl IntoResponse for Body {
    fn into_response(self) -> Response<Body> {
        Response::new(self)
    }
}

impl IntoResponse for &'static str {
    #[inline]
    fn into_response(self) -> Response<Body> {
        Cow::Borrowed(self).into_response()
    }
}

impl IntoResponse for String {
    #[inline]
    fn into_response(self) -> Response<Body> {
        Cow::<'static, str>::Owned(self).into_response()
    }
}

impl IntoResponse for std::borrow::Cow<'static, str> {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut()
            .insert(header::CONTENT_TYPE, HeaderValue::from_static("text/plain"));
        res
    }
}

impl IntoResponse for Bytes {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for &'static [u8] {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for Vec<u8> {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for std::borrow::Cow<'static, [u8]> {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for StatusCode {
    fn into_response(self) -> Response<Body> {
        Response::builder()
            .status(self)
            .body(Body::empty())
            .unwrap()
    }
}

impl<T> IntoResponse for (StatusCode, T)
where
    T: IntoResponse,
{
    fn into_response(self) -> Response<Body> {
        let mut res = self.1.into_response();
        *res.status_mut() = self.0;
        res
    }
}

impl<T> IntoResponse for (HeaderMap, T)
where
    T: IntoResponse,
{
    fn into_response(self) -> Response<Body> {
        let mut res = self.1.into_response();
        res.headers_mut().extend(self.0);
        res
    }
}

impl<T> IntoResponse for (StatusCode, HeaderMap, T)
where
    T: IntoResponse,
{
    fn into_response(self) -> Response<Body> {
        let mut res = self.2.into_response();
        *res.status_mut() = self.0;
        res.headers_mut().extend(self.1);
        res
    }
}

impl IntoResponse for HeaderMap {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::empty());
        *res.headers_mut() = self;
        res
    }
}

/// An HTML response.
///
/// Will automatically get `Content-Type: text/html`.
#[derive(Clone, Copy, Debug)]
pub struct Html<T>(pub T);

impl<T> IntoResponse for Html<T>
where
    T: Into<Body>,
{
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(self.0.into());
        res.headers_mut()
            .insert(header::CONTENT_TYPE, HeaderValue::from_static("text/html"));
        res
    }
}

impl<T> From<T> for Html<T> {
    fn from(inner: T) -> Self {
        Self(inner)
    }
}

/// A JSON response.
///
/// Can be created from any type that implements [`serde::Serialize`].
///
/// Will automatically get `Content-Type: application/json`.
///
/// # Example
///
/// ```
/// use serde_json::json;
/// use axum::{body::Body, response::{Json, IntoResponse}};
/// use http::{Response, header::CONTENT_TYPE};
///
/// let json = json!({
///     "data": 42,
/// });
///
/// let response: Response<Body> = Json(json).into_response();
///
/// assert_eq!(
///     response.headers().get(CONTENT_TYPE).unwrap(),
///     "application/json",
/// );
/// ```
#[derive(Clone, Copy, Debug)]
pub struct Json<T>(pub T);

impl<T> IntoResponse for Json<T>
where
    T: Serialize,
{
    fn into_response(self) -> Response<Body> {
        let bytes = match serde_json::to_vec(&self.0) {
            Ok(res) => res,
            Err(err) => {
                return Response::builder()
                    .status(StatusCode::INTERNAL_SERVER_ERROR)
                    .header(header::CONTENT_TYPE, "text/plain")
                    .body(Body::from(err.to_string()))
                    .unwrap();
            }
        };

        let mut res = Response::new(Body::from(bytes));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/json"),
        );
        res
    }
}

impl<T> From<T> for Json<T> {
    fn from(inner: T) -> Self {
        Self(inner)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use http::header::{HeaderMap, HeaderName};

    #[test]
    fn test_merge_headers() {
        struct MyResponse;

        impl IntoResponse for MyResponse {
            fn into_response(self) -> Response<Body> {
                let mut resp = Response::new(String::new().into());
                resp.headers_mut()
                    .insert(HeaderName::from_static("a"), HeaderValue::from_static("1"));
                resp
            }
        }

        fn check(resp: impl IntoResponse) {
            let resp = resp.into_response();
            assert_eq!(
                resp.headers().get(HeaderName::from_static("a")).unwrap(),
                &HeaderValue::from_static("1")
            );
            assert_eq!(
                resp.headers().get(HeaderName::from_static("b")).unwrap(),
                &HeaderValue::from_static("2")
            );
        }

        let headers: HeaderMap =
            std::iter::once((HeaderName::from_static("b"), HeaderValue::from_static("2")))
                .collect();

        check((headers.clone(), MyResponse));
        check((StatusCode::OK, headers, MyResponse));
    }
}
More docs 2021-06-07 16:28:40 +02:00			`//! Types and traits for generating responses.`

This changes everything 2021-05-31 22:54:21 +02:00			`use crate::Body;`
Break things into modules 2021-05-30 13:24:03 +02:00			`use bytes::Bytes;`
Some simplifications 2021-06-01 08:32:58 +02:00			`use http::{header, HeaderMap, HeaderValue, Response, StatusCode};`
Break things into modules 2021-05-30 13:24:03 +02:00			`use serde::Serialize;`
Write some docs 2021-06-06 15:19:54 +02:00			`use std::{borrow::Cow, convert::Infallible};`
Some simplifications 2021-06-01 08:32:58 +02:00			`use tower::util::Either;`
Break things into modules 2021-05-30 13:24:03 +02:00
Write a few docs 2021-06-06 23:58:44 +02:00			`/// Trait for generating responses.`
			`///`
			/// Types that implement `IntoResponse` can be returned from handlers.
Remove some needless type params 2021-06-06 22:41:52 +02:00			`pub trait IntoResponse {`
Write a few docs 2021-06-06 23:58:44 +02:00			`/// Create a response.`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`fn into_response(self) -> Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for () {`
Write some docs 2021-06-06 15:19:54 +02:00			`fn into_response(self) -> Response<Body> {`
			`Response::new(Body::empty())`
This changes everything 2021-05-31 22:54:21 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Infallible {`
			`fn into_response(self) -> Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`match self {}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T, K> IntoResponse for Either<T, K>`
Don't force handlers to return `Result`s 2021-05-31 20:42:57 +02:00			`where`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`T: IntoResponse,`
			`K: IntoResponse,`
Don't force handlers to return `Result`s 2021-05-31 20:42:57 +02:00			`{`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`fn into_response(self) -> Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`match self {`
			`Either::A(inner) => inner.into_response(),`
			`Either::B(inner) => inner.into_response(),`
			`}`
			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T, E> IntoResponse for Result<T, E>`
This changes everything 2021-05-31 22:54:21 +02:00			`where`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`T: IntoResponse,`
			`E: IntoResponse,`
This changes everything 2021-05-31 22:54:21 +02:00			`{`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`fn into_response(self) -> Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`match self {`
			`Ok(value) => value.into_response(),`
			`Err(err) => err.into_response(),`
			`}`
Don't force handlers to return `Result`s 2021-05-31 20:42:57 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Self {`
			`self`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Implement `IntoResponse` for `Body` 2021-07-22 21:22:46 +02:00			`impl IntoResponse for Body {`
			`fn into_response(self) -> Response<Body> {`
			`Response::new(self)`
			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for &'static str {`
Write some docs 2021-06-06 15:19:54 +02:00			`#[inline]`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Write some docs 2021-06-06 15:19:54 +02:00			`Cow::Borrowed(self).into_response()`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for String {`
Write some docs 2021-06-06 15:19:54 +02:00			`#[inline]`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Write some docs 2021-06-06 15:19:54 +02:00			`Cow::<'static, str>::Owned(self).into_response()`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for std::borrow::Cow<'static, str> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Write some docs 2021-06-06 15:19:54 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut()`
			`.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/plain"));`
			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Bytes {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for &'static [u8] {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Vec<u8> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for std::borrow::Cow<'static, [u8]> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for StatusCode {`
Write some docs 2021-06-06 15:19:54 +02:00			`fn into_response(self) -> Response<Body> {`
			`Response::builder()`
			`.status(self)`
			`.body(Body::empty())`
			`.unwrap()`
Move things around a bit 2021-06-06 11:37:08 +02:00			`}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for (StatusCode, T)`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
More flexible generic responses 2021-07-22 11:14:55 +02:00			`T: IntoResponse,`
Break things into modules 2021-05-30 13:24:03 +02:00			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
More flexible generic responses 2021-07-22 11:14:55 +02:00			`let mut res = self.1.into_response();`
			`*res.status_mut() = self.0;`
			`res`
Move things around a bit 2021-06-06 11:37:08 +02:00			`}`
			`}`
This changes everything 2021-05-31 22:54:21 +02:00
Add support for websockets (#3 ) 2021-06-12 20:50:30 +02:00			`impl<T> IntoResponse for (HeaderMap, T)`
			`where`
More flexible generic responses 2021-07-22 11:14:55 +02:00			`T: IntoResponse,`
Add support for websockets (#3 ) 2021-06-12 20:50:30 +02:00			`{`
			`fn into_response(self) -> Response<Body> {`
More flexible generic responses 2021-07-22 11:14:55 +02:00			`let mut res = self.1.into_response();`
Fixed the implementation of `IntoResponse` of `(HeaderMap, T)` and `(StatusCode, HeaderMap, T)` would ignore headers from `T` (#137 ) 2021-08-06 16:31:38 +08:00			`res.headers_mut().extend(self.0);`
Add support for websockets (#3 ) 2021-06-12 20:50:30 +02:00			`res`
			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for (StatusCode, HeaderMap, T)`
Move things around a bit 2021-06-06 11:37:08 +02:00			`where`
More flexible generic responses 2021-07-22 11:14:55 +02:00			`T: IntoResponse,`
Move things around a bit 2021-06-06 11:37:08 +02:00			`{`
			`fn into_response(self) -> Response<Body> {`
More flexible generic responses 2021-07-22 11:14:55 +02:00			`let mut res = self.2.into_response();`
Move things around a bit 2021-06-06 11:37:08 +02:00			`*res.status_mut() = self.0;`
Fixed the implementation of `IntoResponse` of `(HeaderMap, T)` and `(StatusCode, HeaderMap, T)` would ignore headers from `T` (#137 ) 2021-08-06 16:31:38 +08:00			`res.headers_mut().extend(self.1);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Add example 2021-05-30 14:33:20 +02:00			`}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00
Implement `IntoResponse` for `HeaderMap` 2021-07-22 21:21:53 +02:00			`impl IntoResponse for HeaderMap {`
			`fn into_response(self) -> Response<Body> {`
			`let mut res = Response::new(Body::empty());`
			`*res.headers_mut() = self;`
			`res`
			`}`
			`}`

Write a few docs 2021-06-06 23:58:44 +02:00			`/// An HTML response.`
			`///`
			/// Will automatically get `Content-Type: text/html`.
Write some more docs 2021-06-07 15:45:19 +02:00			`#[derive(Clone, Copy, Debug)]`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`pub struct Html<T>(pub T);`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for Html<T>`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`where`
Move things around a bit 2021-06-06 11:37:08 +02:00			`T: Into<Body>,`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Move things around a bit 2021-06-06 11:37:08 +02:00			`let mut res = Response::new(self.0.into());`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`res.headers_mut()`
			`.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/html"));`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`}`
			`}`

Add error handling and dependency injection example (#23 ) 2021-06-19 12:34:42 +02:00			`impl<T> From<T> for Html<T> {`
			`fn from(inner: T) -> Self {`
			`Self(inner)`
			`}`
			`}`

Write a few docs 2021-06-06 23:58:44 +02:00			`/// A JSON response.`
			`///`
			/// Can be created from any type that implements [`serde::Serialize`].
			`///`
			/// Will automatically get `Content-Type: application/json`.
			`///`
			`/// # Example`
			`///`
			/// ```
			`/// use serde_json::json;`
Rename to axum (#28 ) 2021-07-09 21:36:14 +02:00			`/// use axum::{body::Body, response::{Json, IntoResponse}};`
Write a few docs 2021-06-06 23:58:44 +02:00			`/// use http::{Response, header::CONTENT_TYPE};`
			`///`
			`/// let json = json!({`
			`/// "data": 42,`
			`/// });`
			`///`
			`/// let response: Response<Body> = Json(json).into_response();`
			`///`
			`/// assert_eq!(`
			`/// response.headers().get(CONTENT_TYPE).unwrap(),`
			`/// "application/json",`
			`/// );`
			/// ```
Write some more docs 2021-06-07 15:45:19 +02:00			`#[derive(Clone, Copy, Debug)]`
Move things around a bit 2021-06-06 11:37:08 +02:00			`pub struct Json<T>(pub T);`
More error handling 2021-06-01 00:34:09 +02:00
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for Json<T>`
More error handling 2021-06-01 00:34:09 +02:00			`where`
Move things around a bit 2021-06-06 11:37:08 +02:00			`T: Serialize,`
More error handling 2021-06-01 00:34:09 +02:00			`{`
			`fn into_response(self) -> Response<Body> {`
Move things around a bit 2021-06-06 11:37:08 +02:00			`let bytes = match serde_json::to_vec(&self.0) {`
			`Ok(res) => res,`
			`Err(err) => {`
			`return Response::builder()`
Use correct error type if `Json` serialization fails 2021-07-22 13:26:14 +02:00			`.status(StatusCode::INTERNAL_SERVER_ERROR)`
Move things around a bit 2021-06-06 11:37:08 +02:00			`.header(header::CONTENT_TYPE, "text/plain")`
			`.body(Body::from(err.to_string()))`
			`.unwrap();`
			`}`
			`};`

			`let mut res = Response::new(Body::from(bytes));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/json"),`
			`);`
			`res`
More error handling 2021-06-01 00:34:09 +02:00			`}`
			`}`
Add error handling and dependency injection example (#23 ) 2021-06-19 12:34:42 +02:00
			`impl<T> From<T> for Json<T> {`
			`fn from(inner: T) -> Self {`
			`Self(inner)`
			`}`
			`}`
Fixed the implementation of `IntoResponse` of `(HeaderMap, T)` and `(StatusCode, HeaderMap, T)` would ignore headers from `T` (#137 ) 2021-08-06 16:31:38 +08:00
			`#[cfg(test)]`
			`mod tests {`
			`use super::*;`
			`use http::header::{HeaderMap, HeaderName};`

			`#[test]`
			`fn test_merge_headers() {`
			`struct MyResponse;`

			`impl IntoResponse for MyResponse {`
			`fn into_response(self) -> Response<Body> {`
			`let mut resp = Response::new(String::new().into());`
			`resp.headers_mut()`
			`.insert(HeaderName::from_static("a"), HeaderValue::from_static("1"));`
			`resp`
			`}`
			`}`

			`fn check(resp: impl IntoResponse) {`
			`let resp = resp.into_response();`
			`assert_eq!(`
			`resp.headers().get(HeaderName::from_static("a")).unwrap(),`
			`&HeaderValue::from_static("1")`
			`);`
			`assert_eq!(`
			`resp.headers().get(HeaderName::from_static("b")).unwrap(),`
			`&HeaderValue::from_static("2")`
			`);`
			`}`

			`let headers: HeaderMap =`
			`std::iter::once((HeaderName::from_static("b"), HeaderValue::from_static("2")))`
			`.collect();`

			`check((headers.clone(), MyResponse));`
			`check((StatusCode::OK, headers, MyResponse));`
			`}`
			`}`