Remove State and for<'a> as requirements from Middleware and Request

README.md

@@ -81,7 +81,7 @@ async fn main() -> tide::Result<()> {
     Ok(())
 }
 
-async fn order_shoes(mut req: Request<()>) -> tide::Result {
+async fn order_shoes(mut req: Request) -> tide::Result {
     let Animal { name, legs } = req.body_json().await?;
     Ok(format!("Hello, {}! I've put in an order for {} shoes", name, legs).into())
 }

examples/concurrent_listeners.rs

@@ -6,7 +6,7 @@ async fn main() -> Result<(), std::io::Error> {
     let mut app = tide::new();
     app.with(tide::log::LogMiddleware::new());
 
-    app.at("/").get(|request: Request<_>| async move {
+    app.at("/").get(|request: Request| async move {
         Ok(format!(
             "Hi! You reached this app through: {}",
             request.local_addr().unwrap_or("an unknown port")

examples/cookies.rs

@@ -3,17 +3,17 @@ use tide::{Request, Response, StatusCode};
 
 /// Tide will use the the `Cookies`'s `Extract` implementation to build this parameter.
 ///
-async fn retrieve_cookie(req: Request<()>) -> tide::Result<String> {
+async fn retrieve_cookie(req: Request) -> tide::Result<String> {
     Ok(format!("hello cookies: {:?}", req.cookie("hello").unwrap()))
 }
 
-async fn insert_cookie(_req: Request<()>) -> tide::Result {
+async fn insert_cookie(_req: Request) -> tide::Result {
     let mut res = Response::new(StatusCode::Ok);
     res.insert_cookie(Cookie::new("hello", "world"));
     Ok(res)
 }
 
-async fn remove_cookie(_req: Request<()>) -> tide::Result {
+async fn remove_cookie(_req: Request) -> tide::Result {
     let mut res = Response::new(StatusCode::Ok);
     res.remove_cookie(Cookie::named("hello"));
     Ok(res)

examples/error_handling.rs

@@ -23,7 +23,7 @@ async fn main() -> Result<()> {
     }));
 
     app.at("/")
-        .get(|_req: Request<_>| async { Ok(Body::from_file("./does-not-exist").await?) });
+        .get(|_req: Request| async { Ok(Body::from_file("./does-not-exist").await?) });
 
     app.listen("127.0.0.1:8080").await?;
 

examples/fib.rs

@@ -8,7 +8,7 @@ fn fib(n: usize) -> usize {
     }
 }
 
-async fn fibsum(req: Request<()>) -> tide::Result<String> {
+async fn fibsum(req: Request) -> tide::Result<String> {
     use std::time::Instant;
     let n: usize = req.param("n")?.parse().unwrap_or(0);
     // Start a stopwatch

examples/graphql.rs

@@ -2,7 +2,7 @@ use std::sync::{Arc, RwLock};
 
 use juniper::{http::graphiql, http::GraphQLRequest, RootNode};
 use lazy_static::lazy_static;
-use tide::{http::mime, Body, Redirect, Request, Response, Server, StatusCode};
+use tide::{http::mime, Body, Redirect, Request, Response, StatusCode};
 
 #[derive(Clone)]
 struct User {
@@ -74,9 +74,9 @@ lazy_static! {
     static ref SCHEMA: Schema = Schema::new(QueryRoot {}, MutationRoot {});
 }
 
-async fn handle_graphql(mut request: Request<State>) -> tide::Result {
+async fn handle_graphql(mut request: Request) -> tide::Result {
     let query: GraphQLRequest = request.body_json().await?;
-    let response = query.execute(&SCHEMA, request.state());
+    let response = query.execute(&SCHEMA, request.state::<State>());
     let status = if response.is_ok() {
         StatusCode::Ok
     } else {
@@ -88,15 +88,15 @@ async fn handle_graphql(mut request: Request<State>) -> tide::Result {
         .build())
 }
 
-async fn handle_graphiql(_: Request<State>) -> tide::Result<impl Into<Response>> {
+async fn handle_graphiql(_: Request) -> tide::Result<impl Into<Response>> {
     Ok(Response::builder(200)
         .body(graphiql::graphiql_source("/graphql"))
         .content_type(mime::HTML))
 }
 
 #[async_std::main]
 async fn main() -> std::io::Result<()> {
-    let mut app = Server::with_state(State {
+    let mut app = tide::with_state(State {
         users: Arc::new(RwLock::new(Vec::new())),
     });
     app.at("/").get(Redirect::permanent("/graphiql"));

examples/json.rs

@@ -13,7 +13,7 @@ async fn main() -> tide::Result<()> {
     let mut app = tide::new();
     app.with(tide::log::LogMiddleware::new());
 
-    app.at("/submit").post(|mut req: Request<()>| async move {
+    app.at("/submit").post(|mut req: Request| async move {
         let cat: Cat = req.body_json().await?;
         println!("cat name: {}", cat.name);
 

examples/middleware.rs

@@ -1,5 +1,3 @@
-use std::future::Future;
-use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -26,22 +24,17 @@ impl UserDatabase {
 // This is an example of a function middleware that uses the
 // application state. Because it depends on a specific request state,
 // it would likely be closely tied to a specific application
-fn user_loader<'a>(
-    mut request: Request<UserDatabase>,
-    next: Next<'a, UserDatabase>,
-) -> Pin<Box<dyn Future<Output = Result> + Send + 'a>> {
-    Box::pin(async {
-        if let Some(user) = request.state().find_user().await {
-            trace!("user loaded", {user: user.name});
-            request.set_ext(user);
-            Ok(next.run(request).await)
-        // this middleware only needs to run before the endpoint, so
-        // it just passes through the result of Next
-        } else {
-            // do not run endpoints, we could not find a user
-            Ok(Response::new(StatusCode::Unauthorized))
-        }
-    })
+async fn user_loader(mut request: Request, next: Next) -> Result {
+    if let Some(user) = request.state::<UserDatabase>().find_user().await {
+        trace!("user loaded", {user: user.name});
+        request.set_ext(user);
+        Ok(next.run(request).await)
+    // this middleware only needs to run before the endpoint, so
+    // it just passes through the result of Next
+    } else {
+        // do not run endpoints, we could not find a user
+        Ok(Response::new(StatusCode::Unauthorized))
+    }
 }
 
 // This is an example of middleware that keeps its own state and could
@@ -62,8 +55,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<State>, 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);
         trace!("request counter", { count: count });
         req.set_ext(RequestCount(count));
@@ -115,12 +108,12 @@ async fn main() -> Result<()> {
 
     app.with(user_loader);
     app.with(RequestCounterMiddleware::new(0));
-    app.with(Before(|mut request: Request<UserDatabase>| async move {
+    app.with(Before(|mut request: Request| async move {
         request.set_ext(std::time::Instant::now());
         request
     }));
 
-    app.at("/").get(|req: Request<_>| async move {
+    app.at("/").get(|req: Request| async move {
         let count: &RequestCount = req.ext().unwrap();
         let user: &User = req.ext().unwrap();
 

examples/sessions.rs

@@ -15,24 +15,23 @@ async fn main() -> Result<(), std::io::Error> {
     ));
 
     app.with(tide::utils::Before(
-        |mut request: tide::Request<()>| async move {
+        |mut request: tide::Request| async move {
             let session = request.session_mut();
             let visits: usize = session.get("visits").unwrap_or_default();
             session.insert("visits", visits + 1).unwrap();
             request
         },
     ));
 
-    app.at("/").get(|req: tide::Request<()>| async move {
+    app.at("/").get(|req: tide::Request| async move {
         let visits: usize = req.session().get("visits").unwrap();
         Ok(format!("you have visited this website {} times", visits))
     });
 
-    app.at("/reset")
-        .get(|mut req: tide::Request<()>| async move {
-            req.session_mut().destroy();
-            Ok(tide::Redirect::new("/"))
-        });
+    app.at("/reset").get(|mut req: tide::Request| async move {
+        req.session_mut().destroy();
+        Ok(tide::Redirect::new("/"))
+    });
 
     app.listen("127.0.0.1:8080").await?;
 

examples/state.rs

@@ -19,13 +19,13 @@ async fn main() -> tide::Result<()> {
     femme::start();
     let mut app = tide::with_state(State::new());
     app.with(tide::log::LogMiddleware::new());
-    app.at("/").get(|req: tide::Request<State>| async move {
-        let state = req.state();
+    app.at("/").get(|req: tide::Request| async move {
+        let state = req.state::<State>();
         let value = state.value.load(Ordering::Relaxed);
         Ok(format!("{}\n", value))
     });
-    app.at("/inc").get(|req: tide::Request<State>| async move {
-        let state = req.state();
+    app.at("/inc").get(|req: tide::Request| async move {
+        let state = req.state::<State>();
         let value = state.value.fetch_add(1, Ordering::Relaxed) + 1;
         Ok(format!("{}\n", value))
     });

examples/upload.rs

@@ -37,9 +37,10 @@ async fn main() -> Result<(), IoError> {
     // $ curl localhost:8080/README.md # this reads the file from the same temp directory
 
     app.at(":file")
-        .put(|req: Request<TempDirState>| async move {
+        .put(|req: Request| async move {
             let path = req.param("file")?;
-            let fs_path = req.state().path().join(path);
+            let state = req.state::<TempDirState>();
+            let fs_path = state.path().join(path);
 
             let file = OpenOptions::new()
                 .create(true)
@@ -56,9 +57,9 @@ async fn main() -> Result<(), IoError> {
 
             Ok(json!({ "bytes": bytes_written }))
         })
-        .get(|req: Request<TempDirState>| async move {
+        .get(|req: Request| async move {
             let path = req.param("file")?;
-            let fs_path = req.state().path().join(path);
+            let fs_path = req.state::<TempDirState>().path().join(path);
 
             if let Ok(body) = Body::from_file(fs_path).await {
                 Ok(body.into())

src/cookies/middleware.rs

@@ -15,7 +15,7 @@ use std::sync::{Arc, RwLock};
 /// # use tide::{Request, Response, StatusCode};
 /// # use tide::http::cookies::Cookie;
 /// let mut app = tide::Server::new();
-/// app.at("/get").get(|req: Request<()>| async move {
+/// app.at("/get").get(|req: Request| async move {
 ///     Ok(req.cookie("testCookie").unwrap().value().to_string())
 /// });
 /// app.at("/set").get(|_| async {
@@ -35,8 +35,8 @@ impl CookiesMiddleware {
 }
 
 #[async_trait]
-impl<State: Clone + Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
-    async fn handle(&self, mut ctx: Request<State>, next: Next<'_, State>) -> crate::Result {
+impl Middleware for CookiesMiddleware {
+    async fn handle(&self, mut ctx: Request, next: Next) -> crate::Result {
         let cookie_jar = if let Some(cookie_data) = ctx.ext::<CookieData>() {
             cookie_data.content.clone()
         } else {
@@ -112,7 +112,7 @@ impl LazyJar {
 }
 
 impl CookieData {
-    pub(crate) fn from_request<S>(req: &Request<S>) -> Self {
+    pub(crate) fn from_request(req: &Request) -> Self {
         let jar = if let Some(cookie_headers) = req.header(&headers::COOKIE) {
             let mut jar = CookieJar::new();
             for cookie_header in cookie_headers {