Remove state from next/middleware layer

Author: nyxtom

examples/middleware.rs

@@ -27,7 +27,7 @@ impl UserDatabase {
 // it would likely be closely tied to a specific application
 fn user_loader<'a>(
     mut request: Request,
-    next: Next<'a, UserDatabase>,
+    next: Next<'a>,
 ) -> Pin<Box<dyn Future<Output = Result> + Send + 'a>> {
     Box::pin(async {
         if let Some(user) = request.state().find_user().await {
@@ -61,8 +61,8 @@ impl RequestCounterMiddleware {
 struct RequestCount(usize);
 
 #[tide::utils::async_trait]
-impl<State: Clone + Send + Sync + 'static> Middleware<State> for RequestCounterMiddleware {
-    async fn handle(&self, mut req: Request, next: Next<'_, State>) -> Result {
+impl Middleware for RequestCounterMiddleware {
+    async fn handle(&self, mut req: Request, next: Next<'_>) -> Result {
         let count = self.requests_counted.fetch_add(1, Ordering::Relaxed);
         tide::log::trace!("request counter", { count: count });
         req.set_ext(RequestCount(count));

src/endpoint.rs

@@ -66,12 +66,12 @@ where
     }
 }
 
-pub(crate) struct MiddlewareEndpoint<E, State> {
+pub(crate) struct MiddlewareEndpoint<E> {
     endpoint: E,
-    middleware: Vec<Arc<dyn Middleware<State>>>,
+    middleware: Vec<Arc<dyn Middleware>>,
 }
 
-impl<E: Clone, State> Clone for MiddlewareEndpoint<E, State> {
+impl<E: Clone> Clone for MiddlewareEndpoint<E> {
     fn clone(&self) -> Self {
         Self {
             endpoint: self.endpoint.clone(),
@@ -80,7 +80,7 @@ impl<E: Clone, State> Clone for MiddlewareEndpoint<E, State> {
     }
 }
 
-impl<E, State> std::fmt::Debug for MiddlewareEndpoint<E, State> {
+impl<E> std::fmt::Debug for MiddlewareEndpoint<E> {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             fmt,
@@ -90,14 +90,13 @@ impl<E, State> std::fmt::Debug for MiddlewareEndpoint<E, State> {
     }
 }
 
-impl<E, State> MiddlewareEndpoint<E, State>
+impl<E> MiddlewareEndpoint<E>
 where
-    State: Clone + Send + Sync + 'static,
     E: Endpoint,
 {
     pub(crate) fn wrap_with_middleware(
         ep: E,
-        middleware: &[Arc<dyn Middleware<State>>],
+        middleware: &[Arc<dyn Middleware>],
     ) -> Box<dyn Endpoint + Send + Sync + 'static> {
         if middleware.is_empty() {
             Box::new(ep)
@@ -111,9 +110,8 @@ where
 }
 
 #[async_trait]
-impl<E, State> Endpoint for MiddlewareEndpoint<E, State>
+impl<E> Endpoint for MiddlewareEndpoint<E>
 where
-    State: Clone + Send + Sync + 'static,
     E: Endpoint,
 {
     async fn call(&self, req: Request) -> crate::Result {

src/log/middleware.rs

@@ -26,11 +26,7 @@ impl LogMiddleware {
     }
 
     /// Log a request and a response.
-    async fn log<'a, State: Clone + Send + Sync + 'static>(
-        &'a self,
-        mut req: Request,
-        next: Next<'a, State>,
-    ) -> crate::Result {
+    async fn log<'a>(&'a self, mut req: Request, next: Next<'a>) -> crate::Result {
         if req.ext::<LogMiddlewareHasBeenRun>().is_some() {
             return Ok(next.run(req).await);
         }
@@ -94,8 +90,8 @@ impl LogMiddleware {
 }
 
 #[async_trait::async_trait]
-impl<State: Clone + Send + Sync + 'static> Middleware<State> for LogMiddleware {
-    async fn handle(&self, req: Request, next: Next<'_, State>) -> crate::Result {
+impl Middleware for LogMiddleware {
+    async fn handle(&self, req: Request, next: Next<'_>) -> crate::Result {
         self.log(req, next).await
     }
 }

src/middleware.rs

@@ -10,9 +10,9 @@ use std::pin::Pin;
 
 /// Middleware that wraps around the remaining middleware chain.
 #[async_trait]
-pub trait Middleware<State>: Send + Sync + 'static {
+pub trait Middleware: Send + Sync + 'static {
     /// Asynchronously handle the request, and return a response.
-    async fn handle(&self, request: Request, next: Next<'_, State>) -> crate::Result;
+    async fn handle(&self, request: Request, next: Next<'_>) -> crate::Result;
 
     /// Set the middleware's name. By default it uses the type signature.
     fn name(&self) -> &str {
@@ -21,30 +21,26 @@ pub trait Middleware<State>: Send + Sync + 'static {
 }
 
 #[async_trait]
-impl<State, F> Middleware<State> for F
+impl<F> Middleware for F
 where
-    State: Clone + Send + Sync + 'static,
     F: Send
         + Sync
         + 'static
-        + for<'a> Fn(
-            Request,
-            Next<'a, State>,
-        ) -> Pin<Box<dyn Future<Output = crate::Result> + 'a + Send>>,
+        + for<'a> Fn(Request, Next<'a>) -> Pin<Box<dyn Future<Output = crate::Result> + 'a + Send>>,
 {
-    async fn handle(&self, req: Request, next: Next<'_, State>) -> crate::Result {
+    async fn handle(&self, req: Request, next: Next<'_>) -> crate::Result {
         (self)(req, next).await
     }
 }
 
 /// The remainder of a middleware chain, including the endpoint.
 #[allow(missing_debug_implementations)]
-pub struct Next<'a, State> {
+pub struct Next<'a> {
     pub(crate) endpoint: &'a DynEndpoint,
-    pub(crate) next_middleware: &'a [Arc<dyn Middleware<State>>],
+    pub(crate) next_middleware: &'a [Arc<dyn Middleware>],
 }
 
-impl<State: Clone + Send + Sync + 'static> Next<'_, State> {
+impl Next<'_> {
     /// Asynchronously execute the remaining middleware chain.
     pub async fn run(mut self, req: Request) -> Response {
         if let Some((current, next)) = self.next_middleware.split_first() {

src/route.rs

@@ -17,19 +17,19 @@ use crate::{router::Router, Endpoint, Middleware};
 ///
 /// [`Server::at`]: ./struct.Server.html#method.at
 #[allow(missing_debug_implementations)]
-pub struct Route<'a, State> {
+pub struct Route<'a> {
     router: &'a mut Router,
     path: String,
-    middleware: Vec<Arc<dyn Middleware<State>>>,
+    middleware: Vec<Arc<dyn Middleware>>,
     /// Indicates whether the path of current route is treated as a prefix. Set by
     /// [`strip_prefix`].
     ///
     /// [`strip_prefix`]: #method.strip_prefix
     prefix: bool,
 }
 
-impl<'a, State: Clone + Send + Sync + 'static> Route<'a, State> {
-    pub(crate) fn new(router: &'a mut Router, path: String) -> Route<'a, State> {
+impl<'a> Route<'a> {
+    pub(crate) fn new(router: &'a mut Router, path: String) -> Route<'a> {
         Route {
             router,
             path,
@@ -39,7 +39,7 @@ impl<'a, State: Clone + Send + Sync + 'static> Route<'a, State> {
     }
 
     /// Extend the route with the given `path`.
-    pub fn at<'b>(&'b mut self, path: &str) -> Route<'b, State> {
+    pub fn at<'b>(&'b mut self, path: &str) -> Route<'b> {
         let mut p = self.path.clone();
 
         if !p.ends_with('/') && !path.starts_with('/') {
@@ -79,7 +79,7 @@ impl<'a, State: Clone + Send + Sync + 'static> Route<'a, State> {
     /// Apply the given middleware to the current route.
     pub fn with<M>(&mut self, middleware: M) -> &mut Self
     where
-        M: Middleware<State>,
+        M: Middleware,
     {
         log::trace!(
             "Adding middleware {} to route {:?}",
@@ -126,7 +126,6 @@ impl<'a, State: Clone + Send + Sync + 'static> Route<'a, State> {
     /// [`Server`]: struct.Server.html
     pub fn nest<InnerState>(&mut self, service: crate::Server<InnerState>) -> &mut Self
     where
-        State: Clone + Send + Sync + 'static,
         InnerState: Clone + Send + Sync + 'static,
     {
         let prefix = self.prefix;

src/security/cors.rs

@@ -136,8 +136,8 @@ impl CorsMiddleware {
 }
 
 #[async_trait::async_trait]
-impl<State: Clone + Send + Sync + 'static> Middleware<State> for CorsMiddleware {
-    async fn handle(&self, req: Request, next: Next<'_, State>) -> Result {
+impl Middleware for CorsMiddleware {
+    async fn handle(&self, req: Request, next: Next<'_>) -> Result {
         // TODO: how should multiple origin values be handled?
         let origins = req.header(&headers::ORIGIN).cloned();
 

src/server.rs

@@ -37,7 +37,7 @@ pub struct Server<State> {
     /// The inner Arc-s allow MiddlewareEndpoint-s to be cloned internally.
     /// We don't use a Mutex around the Vec here because adding a middleware during execution should be an error.
     #[allow(clippy::rc_buffer)]
-    middleware: Arc<Vec<Arc<dyn Middleware<State>>>>,
+    middleware: Arc<Vec<Arc<dyn Middleware>>>,
 }
 
 impl Server<()> {
@@ -166,7 +166,7 @@ where
     /// There is no fallback route matching, i.e. either a resource is a full
     /// match or not, which means that the order of adding resources has no
     /// effect.
-    pub fn at<'a>(&'a mut self, path: &str) -> Route<'a, State> {
+    pub fn at<'a>(&'a mut self, path: &str) -> Route<'a> {
         let router = Arc::get_mut(&mut self.router)
             .expect("Registering routes is not possible after the Server has started");
         Route::new(router, path.to_owned())
@@ -183,7 +183,7 @@ where
     /// order in which it is applied.
     pub fn with<M>(&mut self, middleware: M) -> &mut Self
     where
-        M: Middleware<State>,
+        M: Middleware,
     {
         log::trace!("Adding middleware {}", middleware.name());
         let m = Arc::get_mut(&mut self.middleware)

src/utils.rs

@@ -25,13 +25,12 @@ use std::future::Future;
 pub struct Before<F>(pub F);
 
 #[async_trait]
-impl<State, F, Fut> Middleware<State> for Before<F>
+impl<F, Fut> Middleware for Before<F>
 where
-    State: Clone + Send + Sync + 'static,
     F: Fn(Request) -> Fut + Send + Sync + 'static,
     Fut: Future<Output = Request> + Send + Sync + 'static,
 {
-    async fn handle(&self, request: Request, next: Next<'_, State>) -> crate::Result {
+    async fn handle(&self, request: Request, next: Next<'_>) -> crate::Result {
         let request = (self.0)(request).await;
         Ok(next.run(request).await)
     }
@@ -59,13 +58,12 @@ where
 #[derive(Debug)]
 pub struct After<F>(pub F);
 #[async_trait]
-impl<State, F, Fut> Middleware<State> for After<F>
+impl<F, Fut> Middleware for After<F>
 where
-    State: Clone + Send + Sync + 'static,
     F: Fn(Response) -> Fut + Send + Sync + 'static,
     Fut: Future<Output = crate::Result> + Send + Sync + 'static,
 {
-    async fn handle(&self, request: Request, next: Next<'_, State>) -> crate::Result {
+    async fn handle(&self, request: Request, next: Next<'_>) -> crate::Result {
         let response = next.run(request).await;
         (self.0)(response).await
     }

tests/function_middleware.rs

@@ -6,7 +6,7 @@ mod test_utils;
 
 fn auth_middleware<'a>(
     request: tide::Request,
-    next: tide::Next<'a, ()>,
+    next: tide::Next<'a>,
 ) -> Pin<Box<dyn Future<Output = tide::Result> + 'a + Send>> {
     let authenticated = match request.header("X-Auth") {
         Some(header) => header == "secret_key",

tests/route_middleware.rs

@@ -14,11 +14,11 @@ impl TestMiddleware {
 }
 
 #[async_trait::async_trait]
-impl<State: Clone + Send + Sync + 'static> Middleware<State> for TestMiddleware {
+impl Middleware for TestMiddleware {
     async fn handle(
         &self,
         req: tide::Request,
-        next: tide::Next<'_, State>,
+        next: tide::Next<'_>,
     ) -> tide::Result<tide::Response> {
         let mut res = next.run(req).await;
         res.insert_header(self.0.clone(), self.1);