service_layer_rs/
lib.rs

1//! Service Layer
2//!
3
4//! # Example
5//!
6//! ```rust
7//! use service_layer_rs::util::FnService;
8//! use service_layer_rs::{Layer, Service, ServiceBuilder};
9//! use std::convert::Infallible;
10//!
11//! pub struct LogService<S> {
12//!     inner: S,
13//!     name: String,
14//! }
15//!
16//! impl<S, Request> Service<Request> for LogService<S>
17//! where
18//!     S: Service<Request>,
19//!     Request: Send + 'static,
20//! {
21//!     type Response = S::Response;
22//!     type Error = S::Error;
23//!
24//!     async fn call(
25//!         &self,
26//!         request: Request,
27//!     ) -> Result<Self::Response, Self::Error> {
28//!         println!("LogService<{}> start", self.name);
29//!         let res = self.inner.call(request).await;
30//!         println!("LogService<{}> end", self.name);
31//!         res
32//!     }
33//! }
34//!
35//! pub struct LogLayer(pub String);
36//!
37//! impl<S> Layer<S> for LogLayer
38//! where
39//!     S: Send + Sync + 'static
40//! {
41//!     type Service = LogService<S>;
42//!
43//!     fn layer(self, inner: S) -> Self::Service {
44//!         LogService { inner, name: self.0 }
45//!     }
46//! }
47//!
48//! async fn main() {
49//!     let svc = FnService::new(|request: String| async move {
50//!         println!("handle: {}", request);
51//!         Ok::<_, Infallible>(request)
52//!     });
53//!
54//!     let svc = ServiceBuilder::service(svc)
55//!         .layer(LogLayer("Test".to_string()))
56//!         .build();
57//!
58//!     let ss = svc.boxed();
59//!     let res: Result<String, Infallible> = ss.call("hello".to_owned()).await;
60//!     println!("{:?}", res);
61//! }
62//! ```
63
64pub mod service;
65pub mod util;
66
67pub use service::{BoxService, Service};
68
69/// Decorates a Service
70pub trait Layer<S> {
71    /// The wrapped service
72    type Service;
73    /// Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.
74    fn layer(self, inner: S) -> Self::Service;
75}
76
77/// Builder types to compose layers and services
78pub struct ServiceBuilder<S> {
79    inner: S,
80}
81
82impl<S> ServiceBuilder<S> {
83    pub fn service<Request>(inner: S) -> Self
84    where
85        S: Service<Request>,
86    {
87        ServiceBuilder { inner }
88    }
89
90    pub fn layer<L, T, Request>(self, l: L) -> ServiceBuilder<T>
91    where
92        S: Service<Request>,
93        T: Service<Request>,
94        L: Layer<S, Service=T>,
95    {
96        let inner = l.layer(self.inner);
97        ServiceBuilder { inner }
98    }
99
100    pub fn build<Request>(self) -> S
101    where
102        S: Service<Request>,
103    {
104        self.inner
105    }
106
107    pub async fn call<Request>(self, request: Request) -> Result<S::Response, S::Error>
108    where
109        S: Service<Request>,
110    {
111        self.inner.call(request).await
112    }
113}
service_layer_rs/lib.rs

service_layer_rs/
lib.rs
