boluo_core/middleware/
simple.rs

1use crate::middleware::Middleware;
2use crate::service::Service;
3
4/// 将给定的异步函数转换为[`Middleware`]，并可以携带状态。
5///
6/// # 例子
7///
8/// ```
9/// use boluo_core::handler::handler_fn;
10/// use boluo_core::middleware::simple_middleware_fn_with_state;
11/// use boluo_core::request::Request;
12/// use boluo_core::service::{Service, ServiceExt};
13///
14/// // 日志中间件
15/// async fn log<S>(prefix: &&str, req: Request, service: &S) -> Result<S::Response, S::Error>
16/// where
17///     S: Service<Request>,
18/// {
19///     println!("{prefix}: {} {}", req.method(), req.uri().path());
20///     service.call(req).await
21/// }
22///
23/// let service = handler_fn(|| async {});
24/// let service = service.with(simple_middleware_fn_with_state("HTTP", log));
25/// ```
26pub fn simple_middleware_fn_with_state<T, F>(state: T, f: F) -> SimpleMiddlewareFnWithState<T, F> {
27    SimpleMiddlewareFnWithState { state, f }
28}
29
30/// 详情查看[`simple_middleware_fn_with_state`]。
31#[derive(Clone, Copy)]
32pub struct SimpleMiddlewareFnWithState<T, F> {
33    state: T,
34    f: F,
35}
36
37impl<T, F, S> Middleware<S> for SimpleMiddlewareFnWithState<T, F> {
38    type Service = SimpleMiddlewareFnWithStateService<T, F, S>;
39
40    fn transform(self, service: S) -> Self::Service {
41        SimpleMiddlewareFnWithStateService {
42            state: self.state,
43            f: self.f,
44            service,
45        }
46    }
47}
48
49impl<T, F> std::fmt::Debug for SimpleMiddlewareFnWithState<T, F>
50where
51    T: std::fmt::Debug,
52{
53    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54        f.debug_struct("SimpleMiddlewareFnWithState")
55            .field("state", &self.state)
56            .field("f", &std::any::type_name::<F>())
57            .finish()
58    }
59}
60
61/// 中间件[`SimpleMiddlewareFnWithState`]返回的服务。
62#[derive(Clone, Copy)]
63pub struct SimpleMiddlewareFnWithStateService<T, F, S> {
64    state: T,
65    f: F,
66    service: S,
67}
68
69impl<T, F, S, Req, Res, Err> Service<Req> for SimpleMiddlewareFnWithStateService<T, F, S>
70where
71    for<'a> F: SimpleMiddlewareWithState<'a, T, S, Req, Res = Res, Err = Err>,
72    Self: Send + Sync,
73{
74    type Response = Res;
75    type Error = Err;
76
77    fn call(&self, req: Req) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
78        self.f.call(&self.state, req, &self.service)
79    }
80}
81
82impl<T, F, S> std::fmt::Debug for SimpleMiddlewareFnWithStateService<T, F, S>
83where
84    T: std::fmt::Debug,
85    S: std::fmt::Debug,
86{
87    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
88        f.debug_struct("SimpleMiddlewareFnWithStateService")
89            .field("state", &self.state)
90            .field("f", &std::any::type_name::<F>())
91            .field("service", &self.service)
92            .finish()
93    }
94}
95
96trait SimpleMiddlewareWithState<'a, T, S, R>
97where
98    T: ?Sized,
99    S: ?Sized,
100{
101    type Res;
102    type Err;
103
104    fn call(
105        &self,
106        state: &'a T,
107        req: R,
108        service: &'a S,
109    ) -> impl Future<Output = Result<Self::Res, Self::Err>> + Send;
110}
111
112impl<'a, T, S, F, Fut, Req, Res, Err> SimpleMiddlewareWithState<'a, T, S, Req> for F
113where
114    T: ?Sized + 'a,
115    S: ?Sized + 'a,
116    F: Fn(&'a T, Req, &'a S) -> Fut,
117    Fut: Future<Output = Result<Res, Err>> + Send + 'a,
118{
119    type Res = Res;
120    type Err = Err;
121
122    fn call(
123        &self,
124        state: &'a T,
125        req: Req,
126        service: &'a S,
127    ) -> impl Future<Output = Result<Self::Res, Self::Err>> + Send {
128        self(state, req, service)
129    }
130}
131
132/// 将给定的异步函数转换为[`Middleware`]。
133///
134/// # 例子
135///
136/// ```
137/// use boluo_core::handler::handler_fn;
138/// use boluo_core::middleware::simple_middleware_fn;
139/// use boluo_core::request::Request;
140/// use boluo_core::service::{Service, ServiceExt};
141///
142/// // 日志中间件
143/// async fn log<S>(req: Request, service: &S) -> Result<S::Response, S::Error>
144/// where
145///     S: Service<Request>,
146/// {
147///     println!("HTTP: {} {}", req.method(), req.uri().path());
148///     service.call(req).await
149/// }
150///
151/// let service = handler_fn(|| async {});
152/// let service = service.with(simple_middleware_fn(log));
153/// ```
154pub fn simple_middleware_fn<F>(f: F) -> SimpleMiddlewareFn<F> {
155    SimpleMiddlewareFn { f }
156}
157
158/// 详情查看[`simple_middleware_fn`]。
159#[derive(Clone, Copy)]
160pub struct SimpleMiddlewareFn<F> {
161    f: F,
162}
163
164impl<F, S> Middleware<S> for SimpleMiddlewareFn<F> {
165    type Service = SimpleMiddlewareFnService<F, S>;
166
167    fn transform(self, service: S) -> Self::Service {
168        SimpleMiddlewareFnService { f: self.f, service }
169    }
170}
171
172impl<F> std::fmt::Debug for SimpleMiddlewareFn<F> {
173    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
174        f.debug_struct("SimpleMiddlewareFn")
175            .field("f", &std::any::type_name::<F>())
176            .finish()
177    }
178}
179
180/// 中间件[`SimpleMiddlewareFn`]返回的服务。
181#[derive(Clone, Copy)]
182pub struct SimpleMiddlewareFnService<F, S> {
183    f: F,
184    service: S,
185}
186
187impl<F, S, Req, Res, Err> Service<Req> for SimpleMiddlewareFnService<F, S>
188where
189    for<'a> F: SimpleMiddleware<'a, S, Req, Res = Res, Err = Err>,
190    Self: Send + Sync,
191{
192    type Response = Res;
193    type Error = Err;
194
195    fn call(&self, req: Req) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
196        self.f.call(req, &self.service)
197    }
198}
199
200impl<F, S> std::fmt::Debug for SimpleMiddlewareFnService<F, S>
201where
202    S: std::fmt::Debug,
203{
204    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
205        f.debug_struct("SimpleMiddlewareFnService")
206            .field("f", &std::any::type_name::<F>())
207            .field("service", &self.service)
208            .finish()
209    }
210}
211
212trait SimpleMiddleware<'a, S, R>
213where
214    S: ?Sized,
215{
216    type Res;
217    type Err;
218
219    fn call(
220        &self,
221        req: R,
222        service: &'a S,
223    ) -> impl Future<Output = Result<Self::Res, Self::Err>> + Send;
224}
225
226impl<'a, S, F, Fut, Req, Res, Err> SimpleMiddleware<'a, S, Req> for F
227where
228    S: ?Sized + 'a,
229    F: Fn(Req, &'a S) -> Fut,
230    Fut: Future<Output = Result<Res, Err>> + Send + 'a,
231{
232    type Res = Res;
233    type Err = Err;
234
235    fn call(
236        &self,
237        req: Req,
238        service: &'a S,
239    ) -> impl Future<Output = Result<Self::Res, Self::Err>> + Send {
240        self(req, service)
241    }
242}
boluo_core/middleware/simple.rs

boluo_core/middleware/
simple.rs
