alux-http-axum 0.1.0

axum interpretation of ALUX typed HTTP programs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

use crate::AxumParts;
use alux_http::{FromPartsAlg, read_cookies, read_header_name};
use axum::body::Body;
use axum::extract::{FromRequest, FromRequestParts, Multipart, Path, Query, Request};
use axum::http::request::Parts;
use axum::http::{StatusCode, header};
use axum::response::{IntoResponse, Response};
use axum::{Form, Json};
use core::fmt::Display;
use core::future::Future;
use core::marker::PhantomData;
use serde::de::DeserializeOwned;

/// Marks a value extracted from the request path by axum.
pub struct AxumPathInput<Input>(PhantomData<Input>);
/// Marks a value extracted from the query string by axum.
pub struct AxumQueryInput<Input>(PhantomData<Input>);
/// Marks a JSON value extracted from the request body by axum.
pub struct AxumBodyInput<Input>(PhantomData<Input>);
/// Marks a form-encoded value extracted from the request body by axum.
pub struct AxumFormInput<Input>(PhantomData<Input>);
/// Marks the request body taken by axum as it arrived.
pub struct AxumRawBodyInput<Input>(PhantomData<Input>);
/// Marks a value extracted from the request head by axum.
pub struct AxumPartsInput<Input>(PhantomData<Input>);

/// Reads one handler argument from a request axum has taken apart.
///
/// The head is read in place and the body is taken once, so an endpoint reading the body reads it
/// exactly as a framework handler would.
pub(crate) trait AxumInputAlg<Output> {
    fn extract(parts: &mut Parts, body: &mut Option<Body>) -> impl Future<Output = Result<Output, Response>> + Send;
}

impl<Input> AxumInputAlg<Input> for AxumPartsInput<Input>
where
    Input: FromRequestParts<()> + Send,
{
    async fn extract(parts: &mut Parts, _body: &mut Option<Body>) -> Result<Input, Response> {
        Input::from_request_parts(parts, &()).await.map_err(IntoResponse::into_response)
    }
}

macro_rules! axum_parts_input {
    ($marker:ident, $extractor:ident) => {
        impl<Input> AxumInputAlg<Input> for $marker<Input>
        where
            Input: DeserializeOwned + Send,
        {
            async fn extract(parts: &mut Parts, _body: &mut Option<Body>) -> Result<Input, Response> {
                Ok($extractor::<Input>::from_request_parts(parts, &()).await.map_err(IntoResponse::into_response)?.0)
            }
        }
    };
}

axum_parts_input!(AxumPathInput, Path);
axum_parts_input!(AxumQueryInput, Query);

/// Rebuilds the request one body extractor reads, taking the body it consumes.
fn taken(parts: &Parts, body: &mut Option<Body>) -> Request {
    Request::from_parts(parts.clone(), body.take().unwrap_or_default())
}

macro_rules! axum_body_input {
    ($marker:ident, $extractor:ident) => {
        impl<Input> AxumInputAlg<Input> for $marker<Input>
        where
            Input: DeserializeOwned + Send,
        {
            async fn extract(parts: &mut Parts, body: &mut Option<Body>) -> Result<Input, Response> {
                let request = taken(parts, body);

                Ok($extractor::<Input>::from_request(request, &()).await.map_err(IntoResponse::into_response)?.0)
            }
        }
    };
}

axum_body_input!(AxumBodyInput, Json);
axum_body_input!(AxumFormInput, Form);

impl<Input> AxumInputAlg<Input> for AxumRawBodyInput<Input>
where
    Input: FromRequest<()> + Send,
{
    async fn extract(parts: &mut Parts, body: &mut Option<Body>) -> Result<Input, Response> {
        let request = taken(parts, body);

        Input::from_request(request, &()).await.map_err(IntoResponse::into_response)
    }
}

/// Marks a value read from the cookies a caller sent.
pub struct AxumCookieInput<Input>(PhantomData<Input>);

/// Marks a value read from the headers a caller sent.
pub struct AxumHeaderInput<Input>(PhantomData<Input>);

/// Reads the headers a caller sent into the argument an author asked for.
///
/// Headers are names and values, so what reads them is what reads any other name-and-value product.
/// A framework's own extractor is what the endpoint-context role states instead.
fn headers_of<Input>(stated: impl Iterator<Item = (String, String)>) -> Result<Input, String>
where
    Input: DeserializeOwned,
{
    let named = stated.map(|(name, value)| (read_header_name(&name), value)).collect::<Vec<_>>();
    let encoded = serde_urlencoded::to_string(&named).map_err(|error| error.to_string())?;

    serde_urlencoded::from_str(&encoded).map_err(|error| error.to_string())
}

/// Reads the cookies a header states into the argument an author asked for.
///
/// Cookies are names and values, so what reads them is what reads any other name-and-value product.
fn cookies_of<Input>(header: Option<&str>) -> Result<Input, String>
where
    Input: DeserializeOwned,
{
    let stated = read_cookies(header.unwrap_or_default());
    let encoded = serde_urlencoded::to_string(&stated).map_err(|error| error.to_string())?;

    serde_urlencoded::from_str(&encoded).map_err(|error| error.to_string())
}

impl<Input> AxumInputAlg<Input> for AxumCookieInput<Input>
where
    Input: DeserializeOwned + Send,
{
    async fn extract(parts: &mut Parts, _body: &mut Option<Body>) -> Result<Input, Response> {
        let header = parts.headers.get(header::COOKIE).and_then(|value| value.to_str().ok());

        cookies_of(header).map_err(|error| (StatusCode::BAD_REQUEST, error).into_response())
    }
}

impl<Input> AxumInputAlg<Input> for AxumHeaderInput<Input>
where
    Input: DeserializeOwned + Send,
{
    async fn extract(parts: &mut Parts, _body: &mut Option<Body>) -> Result<Input, Response> {
        let stated =
            parts.headers.iter().filter_map(|(name, value)| Some((name.to_string(), value.to_str().ok()?.to_owned())));

        headers_of(stated).map_err(|error| (StatusCode::BAD_REQUEST, error).into_response())
    }
}

/// Marks an argument read from a body arriving as parts.
pub struct AxumMultipartInput<Input>(PhantomData<Input>);

impl<Input> AxumInputAlg<Input> for AxumMultipartInput<Input>
where
    Input: FromPartsAlg<AxumParts> + Send,
    Input::Error: Display,
{
    async fn extract(parts: &mut Parts, body: &mut Option<Body>) -> Result<Input, Response> {
        let request = taken(parts, body);
        let read = Multipart::from_request(request, &()).await.map_err(IntoResponse::into_response)?;

        Input::from_parts(AxumParts(read))
            .await
            .map_err(|error| (StatusCode::BAD_REQUEST, error.to_string()).into_response())
    }
}

/// Reads the whole argument product one endpoint states, in declaration order.
pub(crate) trait AxumInputsAlg<Outputs> {
    fn extract(parts: &mut Parts, body: &mut Option<Body>) -> impl Future<Output = Result<Outputs, Response>> + Send;
}

impl AxumInputsAlg<()> for () {
    async fn extract(_parts: &mut Parts, _body: &mut Option<Body>) -> Result<(), Response> {
        Ok(())
    }
}

macro_rules! axum_inputs {
    ($($input:ident => $output:ident),+ $(,)?) => {
        impl<$($input, $output),+> AxumInputsAlg<($($output,)+)> for ($($input,)+)
        where
            $($input: AxumInputAlg<$output>, $output: Send,)+
        {
            async fn extract(parts: &mut Parts, body: &mut Option<Body>) -> Result<($($output,)+), Response> {
                Ok(($($input::extract(parts, body).await?,)+))
            }
        }
    };
}

axum_inputs!(I1 => O1);
axum_inputs!(I1 => O1, I2 => O2);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10, I11 => O11);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10, I11 => O11, I12 => O12);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10, I11 => O11, I12 => O12, I13 => O13);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10, I11 => O11, I12 => O12, I13 => O13, I14 => O14);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10, I11 => O11, I12 => O12, I13 => O13, I14 => O14, I15 => O15);
axum_inputs!(I1 => O1, I2 => O2, I3 => O3, I4 => O4, I5 => O5, I6 => O6, I7 => O7, I8 => O8, I9 => O9, I10 => O10, I11 => O11, I12 => O12, I13 => O13, I14 => O14, I15 => O15, I16 => O16);