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

use std::future::IntoFuture;
use std::sync::Arc;

use crate::{
    prepare_behave::traits::{
        prepare_middleware::PrepareMiddlewareEffect, prepare_route::PrepareRouteEffect,
        prepare_state::PrepareStateEffect, Prepare,
    },
    PrepareDecorator, PrepareError,
};
use futures::TryFutureExt;
use tap::Pipe;
use tower::layer::util::Stack;

use super::{BaseRouter, EffectContainer};

impl<R, L> EffectContainer<BaseRouter<R>, L> {
    pub(crate) async fn then_route<D, S, C, P>(
        self,
        prepare: P,
        configure: Arc<C>,
        decorator: Arc<D>,
    ) -> Result<EffectContainer<BaseRouter<(P::Effect, R)>, L>, PrepareError>
    where
        D: PrepareDecorator,
        C: 'static,
        P: Prepare<C>,
        P::Effect: PrepareRouteEffect<S>,
        S: Clone + Send + 'static + Sync,
    {
        Ok(self.set_route(
            prepare
                .prepare(configure)
                .into_future()
                .map_err(|err| PrepareError::to_prepare_error::<P, _>(err))
                .pipe(|fut| decorator.prepare_decorator::<C, P, _>(fut))
                .await?,
        ))
    }
}

impl<R, L> EffectContainer<R, L> {
    pub(crate) async fn then_state<D, C, P>(
        self,
        prepare: P,
        configure: Arc<C>,
        decorator: Arc<D>,
    ) -> Result<Self, PrepareError>
    where
        D: PrepareDecorator,
        C: 'static,
        P: Prepare<C>,
        P::Effect: PrepareStateEffect,
    {
        Ok(self.set_state(
            prepare
                .prepare(configure)
                .into_future()
                .map_err(PrepareError::to_prepare_error::<P, _>)
                .pipe(|fut| decorator.prepare_decorator::<C, P, _>(fut))
                .await?,
        ))
    }

    pub(crate) async fn then_middleware<D, S, C, P>(
        self,
        prepare: P,
        configure: Arc<C>,
        decorator: Arc<D>,
    ) -> Result<
        EffectContainer<R, Stack<<P::Effect as PrepareMiddlewareEffect<S>>::Middleware, L>>,
        PrepareError,
    >
    where
        D: PrepareDecorator,
        C: 'static,
        P: Prepare<C>,
        P::Effect: PrepareMiddlewareEffect<S>,
    {
        Ok(self.set_middleware(
            prepare
                .prepare(configure)
                .into_future()
                .map_err(PrepareError::to_prepare_error::<P, _>)
                .pipe(|fut| decorator.prepare_decorator::<C, P, _>(fut))
                .await?,
        ))
    }
}