sessions!

Author: jbr

Cargo.toml

@@ -24,9 +24,10 @@ features = ["docs"]
 rustdoc-args = ["--cfg", "feature=\"docs\""]
 
 [features]
-default = ["h1-server"]
+default = ["h1-server", "sessions"]
 h1-server = ["async-h1"]
 docs = ["unstable"]
+sessions = ["async-session"]
 unstable = []
 # DO NOT USE. Only exists to expose internals so they can be benchmarked.
 __internal__bench = []
@@ -44,6 +45,7 @@ route-recognizer = "0.2.0"
 logtest = "2.0.0"
 async-trait = "0.1.36"
 futures-util = "0.3.5"
+async-session  = { version = "1.0.2", optional = true }
 
 [dev-dependencies]
 async-std = { version = "1.6.0", features = ["unstable", "attributes"] }
@@ -63,3 +65,5 @@ required-features = ["unstable"]
 name = "router"
 harness = false
 
+[patch.crates-io]
+async-session = { git = "https://github.com/jbr/async-session", branch = "tide" }

examples/sessions.rs

@@ -0,0 +1,37 @@
+use tide::prelude::*;
+use tide::sessions::SessionMiddleware;
+use tide::{Body, Request, Response};
+
+#[async_std::main]
+async fn main() -> Result<(), std::io::Error> {
+    tide::log::start();
+    let mut app = tide::new();
+    app.middleware(SessionMiddleware::mem());
+
+    app.at("/")
+        .get(|req: Request<()>| async move { Ok(Body::from_json(req.session())?) });
+
+    app.at("/:key")
+        .get(|req: Request<()>| async move {
+            let key: String = req.param("key")?;
+            Ok(if let Some(value) = req.session_get(&key) {
+                Body::from_string(value.to_owned()).into()
+            } else {
+                Response::new(404)
+            })
+        })
+        .post(|mut req: Request<()>| async move {
+            let value_now = req.body_string().await?;
+            let key: String = req.param("key")?;
+            let value_before = req.session_insert(key, value_now.clone());
+
+            Ok(json!({
+                "value_before": value_before,
+                "value_now": value_now
+            }))
+        });
+
+    app.listen("127.0.0.1:8080").await?;
+
+    Ok(())
+}

src/lib.rs

@@ -215,6 +215,9 @@ pub mod security;
 pub mod sse;
 pub mod utils;
 
+#[cfg(feature = "sessions")]
+pub mod sessions;
+
 pub use endpoint::Endpoint;
 pub use middleware::{Middleware, Next};
 pub use redirect::Redirect;

src/request.rs

@@ -507,6 +507,23 @@ impl<State> Request<State> {
             .and_then(|cookie_data| cookie_data.content.read().unwrap().get(name).cloned())
     }
 
+    #[cfg(feature = "sessions")]
+    pub fn session(&self) -> &crate::sessions::Session {
+        self.ext::<crate::sessions::Session>().expect(
+            "request session not initialized, did you enable tide::sessions::SessionMiddleware?",
+        )
+    }
+
+    #[cfg(feature = "sessions")]
+    pub fn session_get(&self, key: impl AsRef<str>) -> Option<String> {
+        self.session().get(key.as_ref())
+    }
+
+    #[cfg(feature = "sessions")]
+    pub fn session_insert(&self, key: String, value: String) -> Option<String> {
+        self.session().insert(key, value)
+    }
+
     /// Get the length of the body stream, if it has been set.
     ///
     /// This value is set when passing a fixed-size object into as the body. E.g. a string, or a

src/sessions/middleware.rs

@@ -0,0 +1,51 @@
+use super::{mem::MemoryStore, SessionStore};
+use crate::{http::cookies::Cookie, utils::async_trait, Middleware, Next, Request};
+
+#[derive(Debug)]
+pub struct SessionMiddleware<Store> {
+    store: Store,
+    cookie_name: String,
+}
+
+impl<Store: SessionStore> SessionMiddleware<Store> {
+    pub fn new(store: Store) -> Self {
+        Self {
+            store,
+            cookie_name: "session_id".into(),
+        }
+    }
+
+    pub fn with_cookie_name(mut self, cookie_name: String) -> Self {
+        self.cookie_name = cookie_name;
+        self
+    }
+}
+
+impl SessionMiddleware<MemoryStore> {
+    pub fn mem() -> Self {
+        Self::new(MemoryStore::new())
+    }
+}
+
+#[async_trait]
+impl<Store, State> Middleware<State> for SessionMiddleware<Store>
+where
+    Store: SessionStore,
+    State: Send + Sync + 'static,
+{
+    async fn handle(&self, mut request: Request<State>, next: Next<'_, State>) -> crate::Result {
+        let cookie = request.cookie(&self.cookie_name);
+        let session = self.store.load_or_create(cookie).await?;
+        request.set_ext(session.clone());
+
+        let mut response = next.run(request).await;
+
+        let session_cookie_value = self.store.store_session(session).await?;
+        let session_cookie = Cookie::build(self.cookie_name.clone(), session_cookie_value)
+            .path("/")
+            .finish();
+        response.insert_cookie(session_cookie);
+
+        Ok(response)
+    }
+}

src/sessions/mod.rs

@@ -0,0 +1,4 @@
+mod middleware;
+
+pub use async_session::*;
+pub use middleware::SessionMiddleware;