hashira 0.0.2-alpha

A server side rendering framework build on top of Yew
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

use yew::{html::ChildrenProps, BaseComponent};

use crate::{app::RenderContext, error::BoxError, types::BoxFuture, web::{Response, Body}};

/// Represents a page of a web app.
pub trait PageComponent: BaseComponent {
    /// Returns an unique identifier for this component.
    fn id() -> &'static str {
        std::any::type_name::<Self>()
    }

    /// The route of this page.
    fn route() -> Option<&'static str>;

    /// A function that renders this page component.
    fn render<BASE>(ctx: RenderContext, body: Body) -> BoxFuture<Result<Response, BoxError>>
    where
        BASE: BaseComponent<Properties = ChildrenProps>;
}

// A handler that renders a page component.
pub mod handler {
    use crate::{
        app::RenderContext,
        web::{Body, FromRequest, IntoResponse, Response},
    };
    use futures::Future;

    /// Calls the render function of a handler.
    pub async fn call_render<H, Args>(
        ctx: RenderContext,
        mut body: Body,
        handler: H,
    ) -> crate::Result<Response>
    where
        H: RenderHandler<Args>,
        Args: FromRequest,
    {
        let args = match Args::from_request(&ctx, &mut body).await {
            Ok(x) => x,
            Err(err) => return Err(err.into()),
        };
        let ret = handler.call(ctx, args).await;
        let res = ret.into_response();
        Ok(res)
    }

    /// A function that renders a page component.
    pub trait RenderHandler<Args>: Clone + 'static {
        type Output: IntoResponse;
        type Future: Future<Output = Self::Output>;

        fn call(&self, ctx: crate::app::RenderContext, args: Args) -> Self::Future;
    }

    macro_rules! impl_render_handler_tuple ({ $($param:ident)* } => {
        impl<Func, Fut, $($param,)*> RenderHandler<($($param,)*)> for Func
        where
            Func: Fn(RenderContext, $($param),*) -> Fut + Clone + 'static,
            Fut::Output: IntoResponse,
            Fut: Future,
        {
            type Output = Fut::Output;
            type Future = Fut;

            #[inline]
            #[allow(non_snake_case)]
            fn call(&self, ctx: RenderContext, ($($param,)*): ($($param,)*)) -> Self::Future {
                (self)(ctx, $($param,)*)
            }
        }
    });

    impl_render_handler_tuple! {}
    impl_render_handler_tuple! { T1 }
    impl_render_handler_tuple! { T1 T2 }
    impl_render_handler_tuple! { T1 T2 T3 }
    impl_render_handler_tuple! { T1 T2 T3 T4 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 T7 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 T7 T8 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 T7 T8 T9 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 }
    impl_render_handler_tuple! { T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 }
}

pub(crate) mod macros {
    /// Helper to implement `PageComponent`
    #[doc(hidden)]
    #[macro_export]
    macro_rules! impl_page_component {
        ($component:ty) => {
            impl $crate::components::PageComponent for $component {
                fn route() -> Option<&'static str> {
                    None
                }

                fn render<BASE>(
                    ctx: $crate::app::RenderContext,
                    _body: $crate::web::Body
                ) -> $crate::types::BoxFuture<Result<$crate::web::Response, $crate::error::BoxError>>
                where
                    BASE: ::yew::BaseComponent<Properties = ChildrenProps>,
                {
                    std::boxed::Box::pin(async move {
                        let res = ctx.render::<Self, BASE>().await;
                        Ok(res)
                    })
                }
            }
        };

        ($component:ty, $path:literal) => {
            impl $crate::components::PageComponent for $component {
                fn route() -> Option<&'static str> {
                    Some($path)
                }

                fn render<BASE>(
                    ctx: $crate::app::RenderContext,
                    _body: $crate::web::Body
                ) -> $crate::types::BoxFuture<Result<$crate::web::Response, $crate::error::BoxError>>
                where
                    BASE: ::yew::BaseComponent<Properties = ChildrenProps>,
                {
                    std::boxed::Box::pin(async move {
                        let res = ctx.render::<Self, BASE>().await;
                        Ok(res)
                    })
                }
            }
        };
    }
}