ntex 4.0.0-beta.6

Framework for composable network services
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

use std::{fmt, future::Future, marker::PhantomData};

use super::{AppState, FromRequest, Responder, WebRequest, WebResponse, WebResponseError};
use crate::util::BoxFuture;

/// Async fn handler
pub trait Handler<St, T>
where
    St: AppState,
{
    type Output: Responder<St>;

    fn call(&self, param: T) -> impl Future<Output = Self::Output>;
}

impl<St, F, R> Handler<St, ()> for F
where
    F: AsyncFn() -> R,
    R: Responder<St>,
    St: AppState,
{
    type Output = R;

    #[allow(clippy::ignored_unit_patterns)]
    async fn call(&self, _: ()) -> R {
        (self)().await
    }
}

pub(super) trait HandlerFn<St: AppState>: fmt::Debug {
    fn call<'a>(
        &'a self,
        _: &'a St,
        _: WebRequest,
    ) -> BoxFuture<'a, Result<WebResponse, St::Error>>;
}

pub(super) struct HandlerWrapper<St, F, T> {
    hnd: F,
    _t: PhantomData<(St, T)>,
}

impl<St, F, T> HandlerWrapper<St, F, T> {
    pub(super) fn new(hnd: F) -> Self {
        HandlerWrapper {
            hnd,
            _t: PhantomData,
        }
    }
}

impl<St, F, T> fmt::Debug for HandlerWrapper<St, F, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Handler({:?})", std::any::type_name::<F>())
    }
}

impl<St, F, T> HandlerFn<St> for HandlerWrapper<St, F, T>
where
    F: Handler<St, T> + 'static,
    T: FromRequest<St> + 'static,
    T::Error: WebResponseError<St::Error>,
    St: AppState,
{
    fn call<'a>(
        &'a self,
        st: &'a St,
        req: WebRequest,
    ) -> BoxFuture<'a, Result<WebResponse, St::Error>> {
        Box::pin(async move {
            let (req, mut payload) = req.into_parts();
            let param = match T::from_request(st, &req, &mut payload).await {
                Ok(param) => param,
                Err(e) => return Ok(WebResponse::from_err(e, req)),
            };

            let result = self.hnd.call(param).await;
            let response = result.respond_to(&req).await;
            Ok(WebResponse::new(response, req))
        })
    }
}

/// `FromRequest` trait impl for tuples
macro_rules! factory_tuple (
    {$(#[$meta:meta])* $(($T:ident, $t:ident)),+} => {
        $(#[$meta])*
        impl<St, Func, $($T,)+ Res> Handler<St, ($($T,)+)> for Func
        where
            St: AppState,
            Func: AsyncFn($($T,)+) -> Res,
            Res: Responder<St>,
        {
            type Output = Res;

            async fn call(&self, ($($t,)+): ($($T,)+)) -> Self::Output {
                (self)($($t,)+).await
            }
        }
    }
);

#[allow(clippy::wildcard_imports)]
#[rustfmt::skip]
mod m {
    use super::*;
    use variadics_please::all_tuples;

    // Can't use #[doc(fake_variadic)] here
    all_tuples!(factory_tuple, 1, 16, T, t);
}