provide readme per crate

moka-store/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["axum", "sessions", "cookie", "tower", "moka"]
 categories = ["asynchronous", "network-programming", "web-programming"]
 repository = "https://github.com/maxcountryman/tower-sessions-stores"
 documentation = "https://docs.rs/tower-sessions-moka-store"
-readme = "../README.md"
+readme = "README.md"
 
 [dependencies]
 async-trait = "0.1.77"
@@ -27,4 +27,4 @@ tokio-test = "0.4.3"
 serde = "1"
 
 [[example]]
-name = "basic"
+name = "moka"

moka-store/README.md

@@ -0,0 +1,54 @@
+<h1 align="center">
+    tower-sessions-moka-store
+</h1>
+
+<p align="center">
+    Moka session store for `tower-sessions`.
+</p>
+
+## 🤸 Usage
+
+```rust
+use std::net::SocketAddr;
+
+use axum::{response::IntoResponse, routing::get, Router};
+use serde::{Deserialize, Serialize};
+use time::Duration;
+use tower_sessions::{CachingSessionStore, Expiry, Session, SessionManagerLayer};
+use tower_sessions_moka_store::MokaStore;
+use tower_sessions_sqlx_store::{sqlx::SqlitePool, SqliteStore};
+
+const COUNTER_KEY: &str = "counter";
+
+#[derive(Serialize, Deserialize, Default)]
+struct Counter(usize);
+
+async fn handler(session: Session) -> impl IntoResponse {
+    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
+    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
+    format!("Current count: {}", counter.0)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let pool = SqlitePool::connect(":memory:").await?;
+
+    let sqlite_store = SqliteStore::new(pool);
+    sqlite_store.migrate().await?;
+
+    let moka_store = MokaStore::new(Some(2000));
+    let caching_store = CachingSessionStore::new(moka_store, sqlite_store);
+
+    let session_layer = SessionManagerLayer::new(caching_store)
+        .with_secure(false)
+        .with_expiry(Expiry::OnInactivity(Duration::seconds(10)));
+
+    let app = Router::new().route("/", get(handler)).layer(session_layer);
+
+    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    axum::serve(listener, app.into_make_service()).await?;
+
+    Ok(())
+}
+```

moka-store/examples/basic.rs → moka-store/examples/moka.rs

@@ -12,6 +12,12 @@ const COUNTER_KEY: &str = "counter";
 #[derive(Serialize, Deserialize, Default)]
 struct Counter(usize);
 
+async fn handler(session: Session) -> impl IntoResponse {
+    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
+    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
+    format!("Current count: {}", counter.0)
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let pool = SqlitePool::connect(":memory:").await?;
@@ -34,9 +40,3 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
-
-async fn handler(session: Session) -> impl IntoResponse {
-    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
-    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
-    format!("Current count: {}", counter.0)
-}

mongodb-store/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["axum", "sessions", "cookie", "tower", "mongodb"]
 categories = ["asynchronous", "network-programming", "web-programming"]
 repository = "https://github.com/maxcountryman/tower-sessions-stores"
 documentation = "https://docs.rs/tower-sessions-mongodb-store"
-readme = "../README.md"
+readme = "README.md"
 
 [dependencies]
 async-trait = "0.1.77"
@@ -30,4 +30,4 @@ tokio-test = "0.4.3"
 serde = "1"
 
 [[example]]
-name = "basic"
+name = "mongodb"

mongodb-store/README.md

@@ -0,0 +1,48 @@
+<h1 align="center">
+    tower-sessions-mongodb-store
+</h1>
+
+<p align="center">
+    MongoDB session store for `tower-sessions`.
+</p>
+
+## 🤸 Usage
+
+```rust
+use std::net::SocketAddr;
+
+use axum::{response::IntoResponse, routing::get, Router};
+use serde::{Deserialize, Serialize};
+use time::Duration;
+use tower_sessions::{Expiry, Session, SessionManagerLayer};
+use tower_sessions_mongodb_store::{mongodb::Client, MongoDBStore};
+
+const COUNTER_KEY: &str = "counter";
+
+#[derive(Serialize, Deserialize, Default)]
+struct Counter(usize);
+
+async fn handler(session: Session) -> impl IntoResponse {
+    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
+    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
+    format!("Current count: {}", counter.0)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let database_url = std::option_env!("DATABASE_URL").expect("Missing DATABASE_URL.");
+    let client = Client::with_uri_str(database_url).await?;
+    let session_store = MongoDBStore::new(client, "tower-sessions".to_string());
+    let session_layer = SessionManagerLayer::new(session_store)
+        .with_secure(false)
+        .with_expiry(Expiry::OnInactivity(Duration::seconds(10)));
+
+    let app = Router::new().route("/", get(handler)).layer(session_layer);
+
+    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    axum::serve(listener, app.into_make_service()).await?;
+
+    Ok(())
+}
+```

mongodb-store/examples/basic.rs → mongodb-store/examples/mongodb.rs

@@ -11,6 +11,12 @@ const COUNTER_KEY: &str = "counter";
 #[derive(Serialize, Deserialize, Default)]
 struct Counter(usize);
 
+async fn handler(session: Session) -> impl IntoResponse {
+    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
+    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
+    format!("Current count: {}", counter.0)
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let database_url = std::option_env!("DATABASE_URL").expect("Missing DATABASE_URL.");
@@ -28,9 +34,3 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
-
-async fn handler(session: Session) -> impl IntoResponse {
-    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
-    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
-    format!("Current count: {}", counter.0)
-}

redis-store/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["axum", "sessions", "cookie", "tower", "redis"]
 categories = ["asynchronous", "network-programming", "web-programming"]
 repository = "https://github.com/maxcountryman/tower-sessions-stores"
 documentation = "https://docs.rs/tower-sessions-redis-store"
-readme = "../README.md"
+readme = "README.md"
 
 [dependencies]
 async-trait = "0.1.77"
@@ -28,4 +28,4 @@ tokio-test = "0.4.3"
 serde = "1"
 
 [[example]]
-name = "basic"
+name = "redis"

redis-store/README.md

@@ -0,0 +1,53 @@
+<h1 align="center">
+    tower-sessions-redis-store
+</h1>
+
+<p align="center">
+    Redis via `fred` session store for `tower-sessions`.
+</p>
+
+## 🤸 Usage
+
+```rust
+use std::net::SocketAddr;
+
+use axum::{response::IntoResponse, routing::get, Router};
+use serde::{Deserialize, Serialize};
+use time::Duration;
+use tower_sessions::{Expiry, Session, SessionManagerLayer};
+use tower_sessions_redis_store::{fred::prelude::*, RedisStore};
+
+const COUNTER_KEY: &str = "counter";
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+struct Counter(usize);
+
+async fn handler(session: Session) -> impl IntoResponse {
+    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
+    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
+    format!("Current count: {}", counter.0)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let pool = RedisPool::new(RedisConfig::default(), None, None, None, 6)?;
+
+    let redis_conn = pool.connect();
+    pool.wait_for_connect().await?;
+
+    let session_store = RedisStore::new(pool);
+    let session_layer = SessionManagerLayer::new(session_store)
+        .with_secure(false)
+        .with_expiry(Expiry::OnInactivity(Duration::seconds(10)));
+
+    let app = Router::new().route("/", get(handler)).layer(session_layer);
+
+    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    axum::serve(listener, app.into_make_service()).await?;
+
+    redis_conn.await??;
+
+    Ok(())
+}
+```

redis-store/examples/basic.rs → redis-store/examples/redis.rs

@@ -11,6 +11,12 @@ const COUNTER_KEY: &str = "counter";
 #[derive(Debug, Serialize, Deserialize, Default)]
 struct Counter(usize);
 
+async fn handler(session: Session) -> impl IntoResponse {
+    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
+    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
+    format!("Current count: {}", counter.0)
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let pool = RedisPool::new(RedisConfig::default(), None, None, None, 6)?;
@@ -33,9 +39,3 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
-
-async fn handler(session: Session) -> impl IntoResponse {
-    let counter: Counter = session.get(COUNTER_KEY).await.unwrap().unwrap_or_default();
-    session.insert(COUNTER_KEY, counter.0 + 1).await.unwrap();
-    format!("Current count: {}", counter.0)
-}

sqlx-store/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["axum", "sessions", "cookie", "tower", "sqlx"]
 categories = ["asynchronous", "network-programming", "web-programming"]
 repository = "https://github.com/maxcountryman/tower-sessions-stores"
 documentation = "https://docs.rs/tower-sessions-sqlx-store"
-readme = "../README.md"
+readme = "README.md"
 
 [features]
 sqlite = ["sqlx/sqlite"]