Merge pull request #22 from jbr/make-async-std-optional

upgrade sqlx, make async_std optional

Author: jbr

.github/workflows/ci.yaml

@@ -59,13 +59,13 @@ jobs:
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: --all --features pg -- --test-threads=1
+        args: --all --features pg,async_std -- --test-threads=1
 
     - name: sqlite tests
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: --all --features sqlite
+        args: --all --features sqlite,async_std
 
   check_fmt_and_docs:
     name: Checking fmt, clippy, and docs

Cargo.toml

@@ -12,19 +12,20 @@ keywords = ["sessions", "tide", "async-session", "sqlx", "sqlite"]
 categories = ["web-programming::http-server", "web-programming", "database"]
 
 [package.metadata.docs.rs]
-features = ["pg", "sqlite"]
+features = ["pg", "sqlite", "async_std"]
 
 [features]
 default = ["native-tls"]
 sqlite = ["sqlx/sqlite"]
 pg = ["sqlx/postgres", "sqlx/json"]
 native-tls = ["sqlx/runtime-async-std-native-tls"]
 rustls = ["sqlx/runtime-async-std-rustls"]
+async_std = ["async-std"]
 
 [dependencies]
-async-session = "2.0.1"
-sqlx = { version = "0.5.1", features = ["chrono"] }
-async-std = "1.9.0"
+async-session = "3.0.0"
+sqlx = { version = "0.5.5", features = ["chrono"] }
+async-std = { version = "1.9.0", optional = true }
 
 [dev-dependencies]
 async-std = { version = "1.9.0", features = ["attributes"] }

README.md

@@ -19,15 +19,23 @@
 ### sqlite: 
 
 ```toml
-async-sqlx-session = { version = "0.2.0", features = ["sqlite"] }
+async-sqlx-session = { version = "0.3.0", features = ["sqlite"] }
 ```
 
 ### postgres: 
 
 ```toml
-async-sqlx-session = { version = "0.2.0", features = ["pg"] }
+async-sqlx-session = { version = "0.3.0", features = ["pg"] }
 ```
 
+### Optional `async_std` feature
+
+To use the `spawn_cleanup_task` function on async-std, enable the
+`async_std` feature.
+
+```toml
+async-sqlx-session = { version = "0.3.0", features = ["pg", "async_std"] }
+```
 
 
 ## Cargo Features:

src/lib.rs

@@ -1,8 +1,35 @@
-//! # async-sqlx-session
-//!
-//! This crate currently provides two session stores: [`PostgresSessionStore`] and [`SqliteSessionStore`], each of which is enabled by a feature flag.
-//! To use `SqliteSessionStore`, enable the `sqlite` feature on this crate.
-//! To use `PostgresSessionStore`, enable the `pg` feature on this crate.
+/*!
+# async-sqlx-session
+
+This crate currently provides two session stores:
+[`PostgresSessionStore`] and [`SqliteSessionStore`], each of which
+is enabled by a feature flag.
+
+To use [`SqliteSessionStore`], enable the `sqlite` feature on this
+crate.
+
+To use [`PostgresSessionStore`], enable the `pg` feature on this
+crate.
+
+To use the `spawn_cleanup_task` function for either store on
+async-std, enable the `async_std` feature. To perform session cleanup
+intermittently with a different runtime, use a function like:
+
+```rust,ignore
+fn clean_up_intermittently(store: &SqliteSessionStore, period: Duration) {
+    let store = store.clone();
+    other_runtime::spawn(async move {
+        loop {
+            other_runtime::sleep(period).await;
+            if let Err(error) = store.cleanup().await {
+                log::error!("cleanup error: {}", error);
+            }
+        }
+    });
+}
+```
+*/
+
 #![forbid(unsafe_code, future_incompatible)]
 #![deny(
     missing_debug_implementations,

src/pg.rs

@@ -1,7 +1,5 @@
 use async_session::{async_trait, chrono::Utc, log, serde_json, Result, Session, SessionStore};
-use async_std::task;
 use sqlx::{pool::PoolConnection, Executor, PgPool, Postgres};
-use std::time::Duration;
 
 /// sqlx postgres session store for async-sessions
 ///
@@ -14,7 +12,9 @@ use std::time::Duration;
 /// let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
 /// store.migrate().await?;
 /// # store.clear_store().await?;
+/// # #[cfg(feature = "async_std")] {
 /// store.spawn_cleanup_task(Duration::from_secs(60 * 60));
+/// # }
 ///
 /// let mut session = Session::new();
 /// session.insert("key", vec![1,2,3]);
@@ -174,7 +174,9 @@ impl PostgresSessionStore {
     }
 
     /// Spawns an async_std::task that clears out stale (expired)
-    /// sessions on a periodic basis.
+    /// sessions on a periodic basis. Only available with the
+    /// async_std feature enabled.
+    ///
     /// ```rust,no_run
     /// # use async_sqlx_session::PostgresSessionStore;
     /// # use async_session::{Result, SessionStore, Session};
@@ -193,7 +195,12 @@ impl PostgresSessionStore {
     /// # join_handle.cancel().await;
     /// # Ok(()) }) }
     /// ```
-    pub fn spawn_cleanup_task(&self, period: Duration) -> task::JoinHandle<()> {
+    #[cfg(feature = "async_std")]
+    pub fn spawn_cleanup_task(
+        &self,
+        period: std::time::Duration,
+    ) -> async_std::task::JoinHandle<()> {
+        use async_std::task;
         let store = self.clone();
         task::spawn(async move {
             loop {
@@ -326,6 +333,7 @@ impl SessionStore for PostgresSessionStore {
 mod tests {
     use super::*;
     use async_session::chrono::DateTime;
+    use std::time::Duration;
 
     async fn test_store() -> PostgresSessionStore {
         let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap())
@@ -458,7 +466,7 @@ mod tests {
 
         assert!(!loaded_session.is_expired());
 
-        task::sleep(Duration::from_secs(1)).await;
+        async_std::task::sleep(Duration::from_secs(1)).await;
         assert_eq!(None, store.load_session(cookie_value).await?);
 
         Ok(())

src/sqlite.rs

@@ -1,7 +1,5 @@
 use async_session::{async_trait, chrono::Utc, log, serde_json, Result, Session, SessionStore};
-use async_std::task;
 use sqlx::{pool::PoolConnection, sqlite::SqlitePool, Sqlite};
-use std::time::Duration;
 
 /// sqlx sqlite session store for async-sessions
 ///
@@ -11,8 +9,9 @@ use std::time::Duration;
 /// use std::time::Duration;
 ///
 /// # fn main() -> async_session::Result { async_std::task::block_on(async {
-/// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?;
+/// let store = SqliteSessionStore::new("sqlite::memory:").await?;
 /// store.migrate().await?;
+/// # #[cfg(feature = "async_std")]
 /// store.spawn_cleanup_task(Duration::from_secs(60 * 60));
 ///
 /// let mut session = Session::new();
@@ -39,7 +38,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::Result;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let pool = sqlx::SqlitePool::connect("sqlite:%3Amemory:").await.unwrap();
+    /// let pool = sqlx::SqlitePool::connect("sqlite::memory:").await.unwrap();
     /// let store = SqliteSessionStore::from_client(pool)
     ///     .with_table_name("custom_table_name");
     /// store.migrate().await;
@@ -66,7 +65,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::Result;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?;
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?;
     /// store.migrate().await;
     /// # Ok(()) }) }
     /// ```
@@ -85,7 +84,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::Result;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new_with_table_name("sqlite:%3Amemory:", "custom_table_name").await?;
+    /// let store = SqliteSessionStore::new_with_table_name("sqlite::memory:", "custom_table_name").await?;
     /// store.migrate().await;
     /// # Ok(()) }) }
     /// ```
@@ -99,7 +98,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::Result;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?
     ///     .with_table_name("custom_name");
     /// store.migrate().await;
     /// # Ok(()) }) }
@@ -109,7 +108,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::Result;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?
     ///     .with_table_name("johnny (); drop users;");
     /// # Ok(()) }) }
     /// ```
@@ -139,7 +138,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::{Result, SessionStore, Session};
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?;
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?;
     /// assert!(store.count().await.is_err());
     /// store.migrate().await?;
     /// store.store_session(Session::new()).await?;
@@ -177,13 +176,15 @@ impl SqliteSessionStore {
     }
 
     /// Spawns an async_std::task that clears out stale (expired)
-    /// sessions on a periodic basis.
+    /// sessions on a periodic basis. Only available with the
+    /// async_std feature enabled.
+    ///
     /// ```rust,no_run
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::{Result, SessionStore, Session};
     /// # use std::time::Duration;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?;
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?;
     /// store.migrate().await?;
     /// # let join_handle =
     /// store.spawn_cleanup_task(Duration::from_secs(1));
@@ -196,11 +197,15 @@ impl SqliteSessionStore {
     /// # join_handle.cancel().await;
     /// # Ok(()) }) }
     /// ```
-    pub fn spawn_cleanup_task(&self, period: Duration) -> task::JoinHandle<()> {
+    #[cfg(feature = "async_std")]
+    pub fn spawn_cleanup_task(
+        &self,
+        period: std::time::Duration,
+    ) -> async_std::task::JoinHandle<()> {
         let store = self.clone();
-        task::spawn(async move {
+        async_std::task::spawn(async move {
             loop {
-                task::sleep(period).await;
+                async_std::task::sleep(period).await;
                 if let Err(error) = store.cleanup().await {
                     log::error!("cleanup error: {}", error);
                 }
@@ -214,7 +219,7 @@ impl SqliteSessionStore {
     /// # use async_sqlx_session::SqliteSessionStore;
     /// # use async_session::{chrono::{Utc,Duration}, Result, SessionStore, Session};
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?;
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?;
     /// store.migrate().await?;
     /// let mut session = Session::new();
     /// session.set_expiry(Utc::now() - Duration::seconds(5));
@@ -247,7 +252,7 @@ impl SqliteSessionStore {
     /// # use async_session::{Result, SessionStore, Session};
     /// # use std::time::Duration;
     /// # fn main() -> Result { async_std::task::block_on(async {
-    /// let store = SqliteSessionStore::new("sqlite:%3Amemory:").await?;
+    /// let store = SqliteSessionStore::new("sqlite::memory:").await?;
     /// store.migrate().await?;
     /// assert_eq!(store.count().await?, 0);
     /// store.store_session(Session::new()).await?;
@@ -342,9 +347,10 @@ impl SessionStore for SqliteSessionStore {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::time::Duration;
 
     async fn test_store() -> SqliteSessionStore {
-        let store = SqliteSessionStore::new("sqlite:%3Amemory:")
+        let store = SqliteSessionStore::new("sqlite::memory:")
             .await
             .expect("building a sqlite :memory: SqliteSessionStore");
         store
@@ -468,7 +474,7 @@ mod tests {
 
         assert!(!loaded_session.is_expired());
 
-        task::sleep(Duration::from_secs(1)).await;
+        async_std::task::sleep(Duration::from_secs(1)).await;
         assert_eq!(None, store.load_session(cookie_value).await?);
 
         Ok(())