src/extract/mod.rs

use crate::{body::Body, response::IntoResponse};
use async_trait::async_trait;
use bytes::Bytes;
use http::{header, Request, Response};
use rejection::{
    BodyAlreadyTaken, FailedToBufferBody, InvalidJsonBody, InvalidUtf8, LengthRequired,
    MissingExtension, MissingJsonContentType, MissingRouteParams, PayloadTooLarge,
    QueryStringMissing,
};
use serde::de::DeserializeOwned;
use std::{collections::HashMap, convert::Infallible, str::FromStr};

pub mod rejection;

#[async_trait]
pub trait FromRequest<B>: Sized {
    type Rejection: IntoResponse<B>;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection>;
}

#[async_trait]
impl<T, B> FromRequest<B> for Option<T>
where
    T: FromRequest<B>,
{
    type Rejection = Infallible;

    async fn from_request(req: &mut Request<Body>) -> Result<Option<T>, Self::Rejection> {
        Ok(T::from_request(req).await.ok())
    }
}

#[derive(Debug, Clone, Copy)]
pub struct Query<T>(pub T);

#[async_trait]
impl<T> FromRequest<Body> for Query<T>
where
    T: DeserializeOwned,
{
    type Rejection = QueryStringMissing;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        let query = req.uri().query().ok_or(QueryStringMissing(()))?;
        let value = serde_urlencoded::from_str(query).map_err(|_| QueryStringMissing(()))?;
        Ok(Query(value))
    }
}

#[derive(Debug, Clone, Copy)]
pub struct Json<T>(pub T);

#[async_trait]
impl<T> FromRequest<Body> for Json<T>
where
    T: DeserializeOwned,
{
    type Rejection = Response<Body>;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        if has_content_type(req, "application/json") {
            let body = take_body(req).map_err(IntoResponse::into_response)?;

            let bytes = hyper::body::to_bytes(body)
                .await
                .map_err(InvalidJsonBody::from_err)
                .map_err(IntoResponse::into_response)?;

            let value = serde_json::from_slice(&bytes)
                .map_err(InvalidJsonBody::from_err)
                .map_err(IntoResponse::into_response)?;

            Ok(Json(value))
        } else {
            Err(MissingJsonContentType(()).into_response())
        }
    }
}

fn has_content_type<B>(req: &Request<B>, expected_content_type: &str) -> bool {
    let content_type = if let Some(content_type) = req.headers().get(header::CONTENT_TYPE) {
        content_type
    } else {
        return false;
    };

    let content_type = if let Ok(content_type) = content_type.to_str() {
        content_type
    } else {
        return false;
    };

    content_type.starts_with(expected_content_type)
}

#[derive(Debug, Clone, Copy)]
pub struct Extension<T>(pub T);

#[async_trait]
impl<T> FromRequest<Body> for Extension<T>
where
    T: Clone + Send + Sync + 'static,
{
    type Rejection = MissingExtension;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        let value = req
            .extensions()
            .get::<T>()
            .ok_or(MissingExtension(()))
            .map(|x| x.clone())?;

        Ok(Extension(value))
    }
}

#[async_trait]
impl FromRequest<Body> for Bytes {
    type Rejection = Response<Body>;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        let body = take_body(req).map_err(IntoResponse::into_response)?;

        let bytes = hyper::body::to_bytes(body)
            .await
            .map_err(FailedToBufferBody::from_err)
            .map_err(IntoResponse::into_response)?;

        Ok(bytes)
    }
}

#[async_trait]
impl FromRequest<Body> for String {
    type Rejection = Response<Body>;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        let body = take_body(req).map_err(IntoResponse::into_response)?;

        let bytes = hyper::body::to_bytes(body)
            .await
            .map_err(FailedToBufferBody::from_err)
            .map_err(IntoResponse::into_response)?
            .to_vec();

        let string = String::from_utf8(bytes)
            .map_err(InvalidUtf8::from_err)
            .map_err(IntoResponse::into_response)?;

        Ok(string)
    }
}

#[async_trait]
impl FromRequest<Body> for Body {
    type Rejection = BodyAlreadyTaken;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        take_body(req)
    }
}

#[derive(Debug, Clone)]
pub struct BytesMaxLength<const N: u64>(pub Bytes);

#[async_trait]
impl<const N: u64> FromRequest<Body> for BytesMaxLength<N> {
    type Rejection = Response<Body>;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        let content_length = req.headers().get(http::header::CONTENT_LENGTH).cloned();
        let body = take_body(req).map_err(|reject| reject.into_response())?;

        let content_length =
            content_length.and_then(|value| value.to_str().ok()?.parse::<u64>().ok());

        if let Some(length) = content_length {
            if length > N {
                return Err(PayloadTooLarge(()).into_response());
            }
        } else {
            return Err(LengthRequired(()).into_response());
        };

        let bytes = hyper::body::to_bytes(body)
            .await
            .map_err(|e| FailedToBufferBody::from_err(e).into_response())?;

        Ok(BytesMaxLength(bytes))
    }
}

#[derive(Debug)]
pub struct UrlParamsMap(HashMap<String, String>);

impl UrlParamsMap {
    pub fn get(&self, key: &str) -> Option<&str> {
        self.0.get(key).map(|s| &**s)
    }

    pub fn get_typed<T>(&self, key: &str) -> Option<T>
    where
        T: FromStr,
    {
        self.get(key)?.parse().ok()
    }
}

#[async_trait]
impl FromRequest<Body> for UrlParamsMap {
    type Rejection = MissingRouteParams;

    async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
        if let Some(params) = req
            .extensions_mut()
            .get_mut::<Option<crate::routing::UrlParams>>()
        {
            let params = params.take().expect("params already taken").0;
            Ok(Self(params.into_iter().collect()))
        } else {
            Err(MissingRouteParams(()))
        }
    }
}

#[derive(Debug)]
pub struct InvalidUrlParam {
    type_name: &'static str,
}

impl InvalidUrlParam {
    fn new<T>() -> Self {
        InvalidUrlParam {
            type_name: std::any::type_name::<T>(),
        }
    }
}

impl IntoResponse<Body> for InvalidUrlParam {
    fn into_response(self) -> http::Response<Body> {
        let mut res = http::Response::new(Body::from(format!(
            "Invalid URL param. Expected something of type `{}`",
            self.type_name
        )));
        *res.status_mut() = http::StatusCode::BAD_REQUEST;
        res
    }
}

pub struct UrlParams<T>(pub T);

macro_rules! impl_parse_url {
    () => {};

    ( $head:ident, $($tail:ident),* $(,)? ) => {
        #[async_trait]
        impl<$head, $($tail,)*> FromRequest<Body> for UrlParams<($head, $($tail,)*)>
        where
            $head: FromStr + Send,
            $( $tail: FromStr + Send, )*
        {
            type Rejection = Response<Body>;

            #[allow(non_snake_case)]
            async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
                let params = if let Some(params) = req
                    .extensions_mut()
                    .get_mut::<Option<crate::routing::UrlParams>>()
                {
                    params.take().expect("params already taken").0
                } else {
                    return Err(MissingRouteParams(()).into_response())
                };

                if let [(_, $head), $((_, $tail),)*] = &*params {
                    let $head = if let Ok(x) = $head.parse::<$head>() {
                       x
                    } else {
                        return Err(InvalidUrlParam::new::<$head>().into_response());
                    };

                    $(
                        let $tail = if let Ok(x) = $tail.parse::<$tail>() {
                           x
                        } else {
                            return Err(InvalidUrlParam::new::<$tail>().into_response());
                        };
                    )*

                    Ok(UrlParams(($head, $($tail,)*)))
                } else {
                    return Err(MissingRouteParams(()).into_response())
                }
            }
        }

        impl_parse_url!($($tail,)*);
    };
}

impl_parse_url!(T1, T2, T3, T4, T5, T6);

fn take_body(req: &mut Request<Body>) -> Result<Body, BodyAlreadyTaken> {
    struct BodyAlreadyTakenExt;

    if req.extensions_mut().insert(BodyAlreadyTakenExt).is_some() {
        Err(BodyAlreadyTaken(()))
    } else {
        let body = std::mem::take(req.body_mut());
        Ok(body)
    }
}
Quality of life improvements 2021-06-01 14:52:18 +02:00			`use crate::{body::Body, response::IntoResponse};`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`use async_trait::async_trait;`
Add example 2021-05-30 14:33:20 +02:00			`use bytes::Bytes;`
Move things around a bit 2021-06-06 11:37:08 +02:00			`use http::{header, Request, Response};`
			`use rejection::{`
			`BodyAlreadyTaken, FailedToBufferBody, InvalidJsonBody, InvalidUtf8, LengthRequired,`
			`MissingExtension, MissingJsonContentType, MissingRouteParams, PayloadTooLarge,`
			`QueryStringMissing,`
			`};`
Break things into modules 2021-05-30 13:24:03 +02:00			`use serde::de::DeserializeOwned;`
This changes everything 2021-05-31 22:54:21 +02:00			`use std::{collections::HashMap, convert::Infallible, str::FromStr};`
Break things into modules 2021-05-30 13:24:03 +02:00
Move things around a bit 2021-06-06 11:37:08 +02:00			`pub mod rejection;`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`pub trait FromRequest<B>: Sized {`
			`type Rejection: IntoResponse<B>;`
Add some more tests 2021-05-31 14:04:05 +02:00
This changes everything 2021-05-31 22:54:21 +02:00			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection>;`
Add some more tests 2021-05-31 14:04:05 +02:00			`}`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl<T, B> FromRequest<B> for Option<T>`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
This changes everything 2021-05-31 22:54:21 +02:00			`T: FromRequest<B>,`
Break things into modules 2021-05-30 13:24:03 +02:00			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`type Rejection = Infallible;`

			`async fn from_request(req: &mut Request<Body>) -> Result<Option<T>, Self::Rejection> {`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`Ok(T::from_request(req).await.ok())`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

			`#[derive(Debug, Clone, Copy)]`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`pub struct Query<T>(pub T);`
Break things into modules 2021-05-30 13:24:03 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl<T> FromRequest<Body> for Query<T>`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`T: DeserializeOwned,`
Break things into modules 2021-05-30 13:24:03 +02:00			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`type Rejection = QueryStringMissing;`

			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
			`let query = req.uri().query().ok_or(QueryStringMissing(()))?;`
			`let value = serde_urlencoded::from_str(query).map_err(\|_\| QueryStringMissing(()))?;`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`Ok(Query(value))`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

			`#[derive(Debug, Clone, Copy)]`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`pub struct Json<T>(pub T);`
Break things into modules 2021-05-30 13:24:03 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl<T> FromRequest<Body> for Json<T>`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
			`T: DeserializeOwned,`
			`{`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`type Rejection = Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00
			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Move things around a bit 2021-06-06 11:37:08 +02:00			`if has_content_type(req, "application/json") {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`let body = take_body(req).map_err(IntoResponse::into_response)?;`
Start writing more tests 2021-05-31 12:22:16 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`let bytes = hyper::body::to_bytes(body)`
			`.await`
This changes everything 2021-05-31 22:54:21 +02:00			`.map_err(InvalidJsonBody::from_err)`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`.map_err(IntoResponse::into_response)?;`
This changes everything 2021-05-31 22:54:21 +02:00
			`let value = serde_json::from_slice(&bytes)`
			`.map_err(InvalidJsonBody::from_err)`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`.map_err(IntoResponse::into_response)?;`
This changes everything 2021-05-31 22:54:21 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`Ok(Json(value))`
Start writing more tests 2021-05-31 12:22:16 +02:00			`} else {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`Err(MissingJsonContentType(()).into_response())`
Start writing more tests 2021-05-31 12:22:16 +02:00			`}`
			`}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00
Start writing more tests 2021-05-31 12:22:16 +02:00			`fn has_content_type<B>(req: &Request<B>, expected_content_type: &str) -> bool {`
			`let content_type = if let Some(content_type) = req.headers().get(header::CONTENT_TYPE) {`
			`content_type`
			`} else {`
			`return false;`
			`};`
Break things into modules 2021-05-30 13:24:03 +02:00
Start writing more tests 2021-05-31 12:22:16 +02:00			`let content_type = if let Ok(content_type) = content_type.to_str() {`
			`content_type`
			`} else {`
			`return false;`
			`};`

			`content_type.starts_with(expected_content_type)`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`

			`#[derive(Debug, Clone, Copy)]`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`pub struct Extension<T>(pub T);`
Break things into modules 2021-05-30 13:24:03 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl<T> FromRequest<Body> for Extension<T>`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
			`T: Clone + Send + Sync + 'static,`
			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`type Rejection = MissingExtension;`

			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`let value = req`
			`.extensions()`
			`.get::<T>()`
This changes everything 2021-05-31 22:54:21 +02:00			`.ok_or(MissingExtension(()))`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`.map(\|x\| x.clone())?;`

			`Ok(Extension(value))`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl FromRequest<Body> for Bytes {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`type Rejection = Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00
			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`let body = take_body(req).map_err(IntoResponse::into_response)?;`
Add example 2021-05-30 14:33:20 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`let bytes = hyper::body::to_bytes(body)`
			`.await`
This changes everything 2021-05-31 22:54:21 +02:00			`.map_err(FailedToBufferBody::from_err)`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`.map_err(IntoResponse::into_response)?;`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00
			`Ok(bytes)`
Add example 2021-05-30 14:33:20 +02:00			`}`
			`}`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl FromRequest<Body> for String {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`type Rejection = Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00
			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`let body = take_body(req).map_err(IntoResponse::into_response)?;`
Start writing more tests 2021-05-31 12:22:16 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`let bytes = hyper::body::to_bytes(body)`
			`.await`
This changes everything 2021-05-31 22:54:21 +02:00			`.map_err(FailedToBufferBody::from_err)`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`.map_err(IntoResponse::into_response)?`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`.to_vec();`

This changes everything 2021-05-31 22:54:21 +02:00			`let string = String::from_utf8(bytes)`
			`.map_err(InvalidUtf8::from_err)`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`.map_err(IntoResponse::into_response)?;`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00
			`Ok(string)`
Start writing more tests 2021-05-31 12:22:16 +02:00			`}`
			`}`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl FromRequest<Body> for Body {`
			`type Rejection = BodyAlreadyTaken;`

			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
			`take_body(req)`
Start writing more tests 2021-05-31 12:22:16 +02:00			`}`
			`}`

Break things into modules 2021-05-30 13:24:03 +02:00			`#[derive(Debug, Clone)]`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`pub struct BytesMaxLength<const N: u64>(pub Bytes);`
Break things into modules 2021-05-30 13:24:03 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl<const N: u64> FromRequest<Body> for BytesMaxLength<N> {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`type Rejection = Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00
			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Add example 2021-05-30 14:33:20 +02:00			`let content_length = req.headers().get(http::header::CONTENT_LENGTH).cloned();`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`let body = take_body(req).map_err(\|reject\| reject.into_response())?;`
Break things into modules 2021-05-30 13:24:03 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`let content_length =`
			`content_length.and_then(\|value\| value.to_str().ok()?.parse::<u64>().ok());`
Add example 2021-05-30 14:33:20 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`if let Some(length) = content_length {`
			`if length > N {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`return Err(PayloadTooLarge(()).into_response());`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`}`
			`} else {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`return Err(LengthRequired(()).into_response());`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`};`
Add example 2021-05-30 14:33:20 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`let bytes = hyper::body::to_bytes(body)`
			`.await`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`.map_err(\|e\| FailedToBufferBody::from_err(e).into_response())?;`
Add example 2021-05-30 14:33:20 +02:00
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`Ok(BytesMaxLength(bytes))`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00
not quite working 2021-06-03 21:36:39 +02:00			`#[derive(Debug)]`
Changes to UrlParamsMap 2021-05-30 16:37:27 +02:00			`pub struct UrlParamsMap(HashMap<String, String>);`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00
Changes to UrlParamsMap 2021-05-30 16:37:27 +02:00			`impl UrlParamsMap {`
More error handling 2021-06-01 00:34:09 +02:00			`pub fn get(&self, key: &str) -> Option<&str> {`
			`self.0.get(key).map(\|s\| &**s)`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00			`}`
Changes to UrlParamsMap 2021-05-30 16:37:27 +02:00
More error handling 2021-06-01 00:34:09 +02:00			`pub fn get_typed<T>(&self, key: &str) -> Option<T>`
Changes to UrlParamsMap 2021-05-30 16:37:27 +02:00			`where`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`T: FromStr,`
Changes to UrlParamsMap 2021-05-30 16:37:27 +02:00			`{`
More error handling 2021-06-01 00:34:09 +02:00			`self.get(key)?.parse().ok()`
Changes to UrlParamsMap 2021-05-30 16:37:27 +02:00			`}`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00			`}`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl FromRequest<Body> for UrlParamsMap {`
			`type Rejection = MissingRouteParams;`

			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00			`if let Some(params) = req`
			`.extensions_mut()`
			`.get_mut::<Option<crate::routing::UrlParams>>()`
			`{`
			`let params = params.take().expect("params already taken").0;`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`Ok(Self(params.into_iter().collect()))`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00			`} else {`
This changes everything 2021-05-31 22:54:21 +02:00			`Err(MissingRouteParams(()))`
Routing with dynamic parts! 2021-05-30 15:44:26 +02:00			`}`
			`}`
			`}`
Typed url param extractor 2021-05-30 16:53:27 +02:00
This changes everything 2021-05-31 22:54:21 +02:00			`#[derive(Debug)]`
			`pub struct InvalidUrlParam {`
			`type_name: &'static str,`
			`}`
Typed url param extractor 2021-05-30 16:53:27 +02:00
This changes everything 2021-05-31 22:54:21 +02:00			`impl InvalidUrlParam {`
			`fn new<T>() -> Self {`
			`InvalidUrlParam {`
			`type_name: std::any::type_name::<T>(),`
			`}`
			`}`
			`}`

			`impl IntoResponse<Body> for InvalidUrlParam {`
			`fn into_response(self) -> http::Response<Body> {`
			`let mut res = http::Response::new(Body::from(format!(`
			"Invalid URL param. Expected something of type `{}`",
			`self.type_name`
			`)));`
			`*res.status_mut() = http::StatusCode::BAD_REQUEST;`
			`res`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`}`
			`}`

Quality of life improvements 2021-06-01 14:52:18 +02:00			`pub struct UrlParams<T>(pub T);`
This changes everything 2021-05-31 22:54:21 +02:00
Typed url param extractor 2021-05-30 16:53:27 +02:00			`macro_rules! impl_parse_url {`
			`() => {};`

			`( $head:ident, $($tail:ident),* $(,)? ) => {`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`#[async_trait]`
This changes everything 2021-05-31 22:54:21 +02:00			`impl<$head, $($tail,)> FromRequest<Body> for UrlParams<($head, $($tail,))>`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`where`
			`$head: FromStr + Send,`
			`$( $tail: FromStr + Send, )*`
			`{`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`type Rejection = Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00
Typed url param extractor 2021-05-30 16:53:27 +02:00			`#[allow(non_snake_case)]`
This changes everything 2021-05-31 22:54:21 +02:00			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`let params = if let Some(params) = req`
			`.extensions_mut()`
			`.get_mut::<Option<crate::routing::UrlParams>>()`
			`{`
			`params.take().expect("params already taken").0`
			`} else {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`return Err(MissingRouteParams(()).into_response())`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`};`

			`if let [(_, $head), $((_, $tail),)] = &params {`
			`let $head = if let Ok(x) = $head.parse::<$head>() {`
			`x`
			`} else {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`return Err(InvalidUrlParam::new::<$head>().into_response());`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`};`

			`$(`
			`let $tail = if let Ok(x) = $tail.parse::<$tail>() {`
			`x`
			`} else {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`return Err(InvalidUrlParam::new::<$tail>().into_response());`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`};`
			`)*`

Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`Ok(UrlParams(($head, $($tail,)*)))`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`} else {`
Quality of life improvements 2021-06-01 14:52:18 +02:00			`return Err(MissingRouteParams(()).into_response())`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`}`
			`}`
			`}`

			`impl_parse_url!($($tail,)*);`
			`};`
			`}`

This changes everything 2021-05-31 22:54:21 +02:00			`impl_parse_url!(T1, T2, T3, T4, T5, T6);`

			`fn take_body(req: &mut Request<Body>) -> Result<Body, BodyAlreadyTaken> {`
			`struct BodyAlreadyTakenExt;`

			`if req.extensions_mut().insert(BodyAlreadyTakenExt).is_some() {`
			`Err(BodyAlreadyTaken(()))`
			`} else {`
			`let body = std::mem::take(req.body_mut());`
			`Ok(body)`
			`}`
			`}`