sword-macros 0.2.1

Structured web framework built on top of tokio ecosystem, providing powerful features for building robust web applications.
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

use proc_macro2::TokenStream;
use quote::quote;

use super::InterceptorArgs;

/// Expands middleware arguments into the appropriate runtime code.
///
/// 1. **Simple middleware** (`#[uses(MyMiddleware)]`):
///    - Requires `MyMiddleware` to implement `OnRequest`
///
/// 2. **Middleware with config** (`#[uses(MyMiddleware(config))]`):
///    - Requires `MyMiddleware` to implement `OnRequestWithConfig<ConfigType>`
pub fn expand_interceptor_args(args: &InterceptorArgs) -> TokenStream {
    match args {
        InterceptorArgs::SwordSimple(path) => {
            quote! {
                {
                    fn __check_on_request<M: ::sword::prelude::OnRequest>(mw: &M) -> &M { mw }

                    let middleware = state.borrow::<#path>()
                        .expect("Failed to retrieve middleware from State");

                    let _ = __check_on_request(&*middleware);

                    ::sword::internal::axum::mw_with_state(
                        state.clone(),
                        move |mut req: ::sword::prelude::Request, next: ::sword::prelude::Next| {
                            req.set_next(next);

                            let mw = ::std::sync::Arc::clone(&middleware);
                            async move {
                                <#path as ::sword::prelude::OnRequest>::on_request(&*mw, req).await
                            }
                        }
                    )
                }
            }
        }
        InterceptorArgs::SwordWithConfig { middleware, config } => {
            quote! {
                {
                    fn __check_on_request_with_config<M, C>(mw: &M) -> &M
                    where
                        M: ::sword::prelude::OnRequestWithConfig<C>
                    {
                        mw
                    }

                    let middleware = state.borrow::<#middleware>()
                        .expect("Failed to retrieve middleware from State");

                    let _ = __check_on_request_with_config::<#middleware, _>(&*middleware);

                    ::sword::internal::axum::mw_with_state(
                        state.clone(),
                        move |mut req: ::sword::prelude::Request, next: ::sword::prelude::Next| {
                            req.set_next(next);
                            let mw = ::std::sync::Arc::clone(&middleware);
                            async move {
                                <#middleware as ::sword::prelude::OnRequestWithConfig<_>>::on_request_with_config(
                                    &*mw,
                                    #config,
                                    req,
                                ).await
                            }
                        }
                    )
                }
            }
        }
        InterceptorArgs::Expression(expr) => {
            quote! { #expr }
        }
    }
}