src/extract/mod.rs

//! Types and traits for extracting data from requests.

use crate::{body::Body, response::IntoResponse};
use async_trait::async_trait;
use bytes::Bytes;
use http::{header, Request, Response};
use rejection::{
    BodyAlreadyTaken, FailedToBufferBody, InvalidJsonBody, InvalidUrlParam, 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: Sized {
    type Rejection: IntoResponse;

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

#[async_trait]
impl<T> FromRequest for Option<T>
where
    T: FromRequest,
{
    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, Default)]
pub struct Query<T>(pub T);

#[async_trait]
impl<T> FromRequest 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, Default)]
pub struct Json<T>(pub T);

#[async_trait]
impl<T> FromRequest 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 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 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 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 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 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 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)
        }
    }
}

pub struct UrlParams<T>(pub T);

macro_rules! impl_parse_url {
    () => {};

    ( $head:ident, $($tail:ident),* $(,)? ) => {
        #[async_trait]
        impl<$head, $($tail,)*> FromRequest 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, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);

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)
    }
}

macro_rules! impl_from_request_tuple {
    () => {};

    ( $head:ident, $($tail:ident),* $(,)? ) => {
        #[allow(non_snake_case)]
        #[async_trait]
        impl<R, $head, $($tail,)*> FromRequest for ($head, $($tail,)*)
        where
            R: IntoResponse,
            $head: FromRequest<Rejection = R> + Send,
            $( $tail: FromRequest<Rejection = R> + Send, )*
        {
            type Rejection = R;

            async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {
                let $head = FromRequest::from_request(req).await?;
                $( let $tail = FromRequest::from_request(req).await?; )*
                Ok(($head, $($tail,)*))
            }
        }

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

impl_from_request_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);
More docs 2021-06-07 16:28:40 +02:00			`//! Types and traits for extracting data from requests.`

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::{`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`BodyAlreadyTaken, FailedToBufferBody, InvalidJsonBody, InvalidUrlParam, InvalidUtf8,`
			`LengthRequired, MissingExtension, MissingJsonContentType, MissingRouteParams, PayloadTooLarge,`
Move things around a bit 2021-06-06 11:37:08 +02:00			`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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`pub trait FromRequest: Sized {`
			`type Rejection: IntoResponse;`
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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> FromRequest for Option<T>`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`T: FromRequest,`
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			`}`
			`}`

Write some docs 2021-06-06 15:19:54 +02:00			`#[derive(Debug, Clone, Copy, Default)]`
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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> FromRequest 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> {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +02:00			`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			`}`
			`}`

Write some docs 2021-06-06 15:19:54 +02:00			`#[derive(Debug, Clone, Copy, Default)]`
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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> FromRequest 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 {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> FromRequest 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>()`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl FromRequest 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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl FromRequest 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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl FromRequest for Body {`
This changes everything 2021-05-31 22:54:21 +02:00			`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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<const N: u64> FromRequest 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 {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +02:00			`return Err(PayloadTooLarge.into_response());`
Just use async_trait for FromRequest 2021-05-31 12:55:39 +02:00			`}`
			`} else {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl FromRequest for UrlParamsMap {`
This changes everything 2021-05-31 22:54:21 +02:00			`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 {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +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
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]`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<$head, $($tail,)> FromRequest 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 {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +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 {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +02:00			`return Err(MissingRouteParams.into_response())`
Typed url param extractor 2021-05-30 16:53:27 +02:00			`}`
			`}`
			`}`

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

More docs 2021-06-07 16:28:40 +02:00			`impl_parse_url!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);`
This changes everything 2021-05-31 22:54:21 +02:00
			`fn take_body(req: &mut Request<Body>) -> Result<Body, BodyAlreadyTaken> {`
			`struct BodyAlreadyTakenExt;`

			`if req.extensions_mut().insert(BodyAlreadyTakenExt).is_some() {`
More docs and expand `key_value_store` example 2021-06-08 12:43:16 +02:00			`Err(BodyAlreadyTaken)`
This changes everything 2021-05-31 22:54:21 +02:00			`} else {`
			`let body = std::mem::take(req.body_mut());`
			`Ok(body)`
			`}`
			`}`
More docs 2021-06-07 16:28:40 +02:00
			`macro_rules! impl_from_request_tuple {`
			`() => {};`

			`( $head:ident, $($tail:ident),* $(,)? ) => {`
			`#[allow(non_snake_case)]`
			`#[async_trait]`
			`impl<R, $head, $($tail,)> FromRequest for ($head, $($tail,))`
			`where`
			`R: IntoResponse,`
			`$head: FromRequest<Rejection = R> + Send,`
			`$( $tail: FromRequest<Rejection = R> + Send, )*`
			`{`
			`type Rejection = R;`

			`async fn from_request(req: &mut Request<Body>) -> Result<Self, Self::Rejection> {`
			`let $head = FromRequest::from_request(req).await?;`
			`$( let $tail = FromRequest::from_request(req).await?; )*`
			`Ok(($head, $($tail,)*))`
			`}`
			`}`

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

			`impl_from_request_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);`