axol 0.2.0

Axol Web Framework
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

use crate::{FromRequestParts, Result};
use axol_http::{request::RequestPartsRef, response::Response};
use futures::Future;

#[async_trait::async_trait]
pub trait EarlyResponseHook: Send + Sync + 'static {
    /// Called when a handler returns an Ok(response)
    /// Any errors returned here will go through ErrorHooks.
    async fn handle_response<'a>(
        &self,
        request: RequestPartsRef<'a>,
        response: &mut Response,
    ) -> Result<()>;
}

#[async_trait::async_trait]
pub trait LateResponseHook: Send + Sync + 'static {
    /// Called before a response is written over the wire. Error responses also go through this stage.
    /// Notably, errors cannot be thrown here.
    /// If any request extractors fail, an error is logged and the hook is skipped. Keep that in mind!
    /// It's best to use Option extractors if any.
    async fn handle_response<'a>(&self, request: RequestPartsRef<'a>, response: &mut Response);
}

#[async_trait::async_trait]
impl<F, Fut> EarlyResponseHookExpansion<()> for F
where
    F: Fn() -> Fut + Send + Sync + 'static,
    Fut: Future<Output = Result<()>> + Send,
{
    async fn handle_response<'a>(
        &self,
        _request: RequestPartsRef<'a>,
        _response: &mut Response,
    ) -> Result<()> {
        self().await
    }
}

#[async_trait::async_trait]
pub trait EarlyResponseHookExpansion<G>: Send + Sync + 'static {
    async fn handle_response<'a>(
        &self,
        request: RequestPartsRef<'a>,
        response: &mut Response,
    ) -> Result<()>;
}

#[async_trait::async_trait]
impl<G: 'static> EarlyResponseHook for Box<dyn EarlyResponseHookExpansion<G>> {
    async fn handle_response<'a>(
        &self,
        request: RequestPartsRef<'a>,
        response: &mut Response,
    ) -> Result<()> {
        (**self).handle_response(request, response).await
    }
}
//

#[async_trait::async_trait]
impl<F, Fut> LateResponseHookExpansion<()> for F
where
    F: Fn() -> Fut + Send + Sync + 'static,
    Fut: Future<Output = ()> + Send,
{
    async fn handle_response<'a>(&self, _request: RequestPartsRef<'a>, _response: &mut Response) {
        self().await
    }
}

#[async_trait::async_trait]
pub trait LateResponseHookExpansion<G>: Send + Sync + 'static {
    async fn handle_response<'a>(&self, request: RequestPartsRef<'a>, response: &mut Response);
}

#[async_trait::async_trait]
impl<G: 'static> LateResponseHook for Box<dyn LateResponseHookExpansion<G>> {
    async fn handle_response<'a>(&self, request: RequestPartsRef<'a>, response: &mut Response) {
        (**self).handle_response(request, response).await
    }
}

//
macro_rules! impl_handler {
    ( $($ty:ident),* $(,)? ) => {
        #[allow(non_snake_case)]
        #[allow(unused_variables)]
        #[async_trait::async_trait]
        impl<F, Fut, $($ty,)*> EarlyResponseHookExpansion<(($($ty,)*), Fut)> for F
        where for<'a> F: Fn($($ty,)* &mut Response) -> Fut + Send + Sync + 'static,
            Fut: Future<Output = Result<()>> + Send + 'static,
            $( for<'a> $ty: FromRequestParts<'a> + Send, )*
        {
            async fn handle_response<'a>(&self, request: RequestPartsRef<'a>, response: &mut Response) -> Result<()> {
                $(
                    let $ty = $ty::from_request_parts(request).await?;
                )*

                self($($ty,)* response).await
            }
        }

        #[allow(non_snake_case)]
        #[allow(unused_variables)]
        #[async_trait::async_trait]
        impl<F, Fut, $($ty,)*> LateResponseHookExpansion<(($($ty,)*), Fut)> for F
        where for<'a> F: Fn($($ty,)* Response) -> Fut + Send + Sync + 'static,
            Fut: Future<Output = Response> + Send + 'static,
            $( for<'a> $ty: FromRequestParts<'a> + Send, )*
        {
            async fn handle_response<'a>(&self, request: RequestPartsRef<'a>, response: &mut Response) {
                $(
                    let $ty = match $ty::from_request_parts(request).await {
                        Ok(x) => x,
                        Err(e) => {
                            log::warn!("late response hook extractor error, skipped hook: {e}");
                            return;
                        }
                    };
                )*

                let owned_response = std::mem::take(response);
                *response = self($($ty,)* owned_response).await;
            }
        }
    };
}

all_the_tuples_no_last_special_case!(impl_handler);