axum-starter 0.11.0

A help crate for simplify the code of starting a axum server
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

mod prepare;

use tower::{
    layer::util::{Identity, Stack},
    ServiceBuilder,
};

use super::{
    effect_collectors::state_collector::StateCollector,
    traits::{
        prepare_middleware::PrepareMiddlewareEffect, prepare_route::PrepareRouteEffect,
        prepare_state::PrepareStateEffect,
    },
};

pub struct BaseRouter<R>(pub(crate) R);
#[cfg(feature = "test-utils")]
pub struct TestRouter;

/// container store the [Prepare] Effects
pub struct EffectContainer<R, L> {
    states: StateCollector,
    middleware: ServiceBuilder<L>,
    route: R,
}

impl<R, L> EffectContainer<R, L> {
    pub(crate) fn unwrap(self) -> (StateCollector, ServiceBuilder<L>, R) {
        (self.states, self.middleware, self.route)
    }
}

impl<R, L> EffectContainer<R, L> {
    pub(crate) fn combine_state(mut self, states: StateCollector) -> Self {
        self.states = self.states & states;
        self
    }
}

impl EffectContainer<BaseRouter<()>, Identity> {
    pub(crate) fn new() -> Self {
        Self {
            states: StateCollector::new(),
            middleware: ServiceBuilder::new(),
            route: BaseRouter(()),
        }
    }
}

#[cfg(feature = "test-utils")]
impl EffectContainer<TestRouter, Identity> {
    pub(crate) fn new_test() -> Self {
        Self {
            states: StateCollector::new(),
            middleware: ServiceBuilder::new(),
            route: TestRouter,
        }
    }
}

impl<R, L> EffectContainer<R, L> {
    pub(crate) fn set_middleware<Service, E: PrepareMiddlewareEffect<Service>>(
        self,
        effect: E,
    ) -> EffectContainer<R, Stack<E::Middleware, L>> {
        let EffectContainer {
            mut states,
            middleware,
            route,
        } = self;

        let middleware = middleware.layer(effect.take(&mut states));

        EffectContainer {
            states,
            middleware,
            route,
        }
    }

    pub(crate) fn layer<M>(self, layer: M) -> EffectContainer<R, Stack<M, L>> {
        let EffectContainer {
            states,
            middleware,
            route,
        } = self;

        let middleware = middleware.layer(layer);

        EffectContainer {
            states,
            middleware,
            route,
        }
    }

    pub(crate) fn set_state<E>(mut self, effect: E) -> EffectContainer<R, L>
    where
        E: PrepareStateEffect,
    {
        effect.take_state(&mut self.states);
        self
    }
}

impl<R, L> EffectContainer<BaseRouter<R>, L> {
    pub(crate) fn set_route<S, E>(self, effect: E) -> EffectContainer<BaseRouter<(E, R)>, L>
    where
        E: PrepareRouteEffect<S>,
        S: Clone + Send + 'static + Sync,
    {
        let EffectContainer {
            states,
            middleware,
            route: BaseRouter(route),
        } = self;

        let route = (effect, route);

        EffectContainer {
            states,
            middleware,
            route: BaseRouter(route),
        }
    }
}