improve handling of cleanup, initial docs

Author: jbr

Cargo.toml

@@ -11,6 +11,7 @@ sqlite = ["sqlx/sqlite"]
 [dependencies]
 async-session = "1.0.2"
 sqlx = { version = "0.3.5" }
+async-std = "1.6.2"
 
 [patch.crates-io]
 async-session = { git = "https://github.com/jbr/async-session", branch = "tide" }

src/sqlite.rs

@@ -1,7 +1,27 @@
 use async_session::{async_trait, chrono::Utc, log, serde_json, Result, Session, SessionStore};
+use async_std::task;
 use sqlx::prelude::*;
 use sqlx::{pool::PoolConnection, sqlite::SqlitePool, SqliteConnection};
-
+use std::time::Duration;
+
+/// sqlx sqlite session store for async-sessions
+///
+/// ```rust
+/// use async_sqlx_session::SqliteStore;
+/// use async_session::SessionStore;
+/// # fn main() -> async_session::Result { async_std::task::block_on(async {
+/// let store = SqliteStore::new("sqlite:%3Amemory:").await?;
+/// store.migrate().await?;
+/// store.spawn_cleanup_task(std::time::Duration::from_secs(60 * 60));
+///
+/// let mut session = async_session::Session::new();
+/// session.insert("key".into(), "value".into());
+///
+/// let cookie_value = store.store_session(session).await.unwrap();
+/// let session = store.load_session(cookie_value).await.unwrap();
+/// assert_eq!(session.get("key"), Some("value".to_owned()));
+/// # Ok(()) }) }
+///
 #[derive(Clone, Debug)]
 pub struct SqliteStore {
     client: SqlitePool,
@@ -20,15 +40,24 @@ impl SqliteStore {
         Ok(Self::from_client(SqlitePool::new(database_url).await?))
     }
 
-    pub fn with_table_name(mut self, table_name: String) -> Self {
-        if table_name.chars().any(|c| !c.is_ascii_alphanumeric()) {
+    pub async fn new_with_table_name(database_url: &str, table_name: &str) -> sqlx::Result<Self> {
+        Ok(Self::from_client(SqlitePool::new(database_url).await?).with_table_name(table_name))
+    }
+
+    pub fn with_table_name(mut self, table_name: impl AsRef<str>) -> Self {
+        let table_name = table_name.as_ref();
+        if table_name.is_empty()
+            || !table_name
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
+        {
             panic!(
-                "table name must be alphanumeric, but {} was not",
+                "table name must be [a-zA-Z0-9_-]+, but {} was not",
                 table_name
             );
         }
 
-        self.table_name = table_name;
+        self.table_name = table_name.to_owned();
         self
     }
 
@@ -40,7 +69,7 @@ impl SqliteStore {
             r#"
             CREATE TABLE IF NOT EXISTS %%TABLE_NAME%% (
                 id TEXT PRIMARY KEY NOT NULL,
-                expires DATETIME NOT NULL,
+                expires INTEGER NULL,
                 session TEXT NOT NULL
             )
             "#,
@@ -57,6 +86,33 @@ impl SqliteStore {
     async fn connection(&self) -> sqlx::Result<PoolConnection<SqliteConnection>> {
         self.client.acquire().await
     }
+
+    pub fn spawn_cleanup_task(&self, period: Duration) -> task::JoinHandle<()> {
+        let store = self.clone();
+        task::spawn(async move {
+            loop {
+                task::sleep(period).await;
+                if let Err(error) = store.cleanup().await {
+                    log::error!("cleanup error: {}", error);
+                }
+            }
+        })
+    }
+
+    pub async fn cleanup(&self) -> sqlx::Result<()> {
+        let mut connection = self.connection().await?;
+        sqlx::query(&self.substitute_table_name(
+            r#"
+            DELETE FROM %%TABLE_NAME%%
+            WHERE expires < ?
+            "#,
+        ))
+        .bind(Utc::now().timestamp())
+        .execute(&mut connection)
+        .await?;
+
+        Ok(())
+    }
 }
 
 #[async_trait]
@@ -68,7 +124,7 @@ impl SessionStore for SqliteStore {
         let (session,): (String,) = sqlx::query_as(&self.substitute_table_name(
             r#"
             SELECT session FROM %%TABLE_NAME%%
-              WHERE id = ? AND expires > ?
+              WHERE id = ? AND (expires IS NULL || expires > ?)
             "#,
         ))
         .bind(&id)
@@ -85,23 +141,27 @@ impl SessionStore for SqliteStore {
         let string = serde_json::to_string(&session).ok()?;
         let mut connection = self.connection().await.ok()?;
 
-        sqlx::query(&self.substitute_table_name(
+        let result = sqlx::query(&self.substitute_table_name(
             r#"
             INSERT INTO %%TABLE_NAME%%
-              (id, expires, session) VALUES (?, ?, ?)
+              (id, session, expires) VALUES (?, ?, ?)
             ON CONFLICT(id) DO UPDATE SET
               expires = excluded.expires,
               session = excluded.session
             "#,
         ))
         .bind(&id)
-        .bind(&session.expiry().map(|expiry| expiry.timestamp()))
         .bind(&string)
+        .bind(&session.expiry().map(|expiry| expiry.timestamp()))
         .execute(&mut connection)
-        .await
-        .unwrap();
+        .await;
 
-        session.into_cookie_value()
+        if let Err(e) = result {
+            dbg!(e);
+            None
+        } else {
+            session.into_cookie_value()
+        }
     }
 
     async fn destroy_session(&self, session: Session) -> Result {
@@ -131,19 +191,4 @@ impl SessionStore for SqliteStore {
 
         Ok(())
     }
-
-    async fn cleanup(&self) -> Result {
-        let mut connection = self.connection().await?;
-        sqlx::query(&self.substitute_table_name(
-            r#"
-            DELETE FROM %%TABLE_NAME%%
-            WHERE expires < ?
-            "#,
-        ))
-        .bind(Utc::now().timestamp())
-        .execute(&mut connection)
-        .await?;
-
-        Ok(())
-    }
 }