httpz 0.0.6

Code once, support every Rust webserver!
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

use std::sync::Arc;

use axum::{
    extract::State,
    routing::{on, MethodFilter},
    Router,
};
use http::{HeaderMap, Request, StatusCode};
use hyper::{body::to_bytes, Body};

use crate::{Endpoint, HttpEndpoint, HttpResponse, Server};

pub use axum;

impl<TEndpoint> Endpoint<TEndpoint>
where
    TEndpoint: HttpEndpoint,
{
    /// is called to mount the endpoint onto an Axum router.
    pub fn axum<S>(mut self) -> Router<S>
    where
        S: Clone + Send + Sync + 'static,
    {
        let (url, methods) = self.endpoint.register();
        let endpoint = Arc::new(self.endpoint);

        let mut method_filter = MethodFilter::empty();
        for method in methods.as_ref().iter() {
            #[allow(clippy::unwrap_used)] // TODO: Error handling
            method_filter.insert(MethodFilter::try_from(method.clone()).unwrap());
        }

        Router::<S>::new().route(
            url.as_ref(),
            on(
                method_filter,
                |state: State<S>, request: Request<Body>| async move {
                    let (mut parts, body) = request.into_parts();
                    parts.extensions.insert(state);

                    let body = match to_bytes(body).await {
                        Ok(body) => body.to_vec(),
                        Err(err) => {
                            return (
                                StatusCode::BAD_REQUEST,
                                HeaderMap::new(),
                                err.to_string().as_bytes().to_vec(),
                            );
                        }
                    };

                    let body = Request::from_parts(parts, body);

                    match endpoint
                        .handler(crate::Request::new(body, Server::Axum))
                        .await
                        .into_response()
                    {
                        Ok(resp) => {
                            let (parts, body) = resp.into_parts();
                            (parts.status, parts.headers, body)
                        }
                        Err(err) => (
                            StatusCode::INTERNAL_SERVER_ERROR,
                            HeaderMap::new(),
                            err.to_string().as_bytes().to_vec(),
                        ),
                    }
                },
            ),
        )
    }
}

impl crate::Request {
    /// TODO
    pub fn get_axum_state<S>(&self) -> Option<&S>
    where
        S: Clone + Send + Sync + 'static,
    {
        self.extensions().get::<State<S>>().map(|state| &state.0)
    }
}