Struct async_sqlx_session::PostgresSessionStore

pub struct PostgresSessionStore { /* fields omitted */ }

sqlx postgres session store for async-sessions

use async_sqlx_session::PostgresSessionStore;
use async_session::{Session, SessionStore};
use std::time::Duration;

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
store.migrate().await?;
store.spawn_cleanup_task(Duration::from_secs(60 * 60));

let mut session = Session::new();
session.insert("key", vec![1,2,3]);

let cookie_value = store.store_session(session).await?.unwrap();
let session = store.load_session(cookie_value).await?.unwrap();
assert_eq!(session.get::<Vec<i8>>("key").unwrap(), vec![1,2,3]);

Implementations

impl PostgresSessionStore

pub fn from_client(client: PgPool) -> Self

constructs a new PostgresSessionStore from an existing sqlx::PgPool. the default table name for this session store will be "async_sessions". To override this, chain this with with_table_name.

let pool = sqlx::PgPool::connect(&std::env::var("PG_TEST_DB_URL").unwrap()).await.unwrap();
let store = PostgresSessionStore::from_client(pool)
    .with_table_name("custom_table_name");
store.migrate().await;

pub async fn new(database_url: &str) -> Result<Self>

Constructs a new PostgresSessionStore from a postgres:// database url. The default table name for this session store will be "async_sessions". To override this, either chain with with_table_name or use new_with_table_name

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
store.migrate().await;

pub async fn new_with_table_name(
    database_url: &str,
    table_name: &str
) -> Result<Self>

constructs a new PostgresSessionStore from a postgres:// url. the default table name for this session store will be "async_sessions". To override this, either chain with with_table_name or use new_with_table_name

let store = PostgresSessionStore::new_with_table_name(&std::env::var("PG_TEST_DB_URL").unwrap(), "custom_table_name").await?;
store.migrate().await;

pub fn with_table_name(mut self: Self, table_name: impl AsRef<str>) -> Self

Chainable method to add a custom table name. This will panic if the table name is not [a-zA-Z0-9_-]+.

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?
    .with_table_name("custom_name");
store.migrate().await;

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?
    .with_table_name("johnny (); drop users;");

pub async fn migrate(&self) -> Result<()>

Creates a session table if it does not already exist. If it does, this will noop, making it safe to call repeatedly on store initialization. In the future, this may make exactly-once modifications to the schema of the session table on breaking releases.

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
store.migrate().await?;
store.store_session(Session::new()).await?;
store.migrate().await?; // calling it a second time is safe
assert_eq!(store.count().await?, 1);

pub fn spawn_cleanup_task(&self, period: Duration) -> JoinHandle<()>

Spawns an async_std::task that clears out stale (expired) sessions on a periodic basis.

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
store.migrate().await?;
store.spawn_cleanup_task(Duration::from_secs(1));
let mut session = Session::new();
session.expire_in(Duration::from_secs(0));
store.store_session(session).await?;
assert_eq!(store.count().await?, 1);
async_std::task::sleep(Duration::from_secs(2)).await;
assert_eq!(store.count().await?, 0);

pub async fn cleanup(&self) -> Result<()>

Performs a one-time cleanup task that clears out stale (expired) sessions. You may want to call this from cron.

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
store.migrate().await?;
let mut session = Session::new();
session.set_expiry(Utc::now() - Duration::seconds(5));
store.store_session(session).await?;
assert_eq!(store.count().await?, 1);
store.cleanup().await?;
assert_eq!(store.count().await?, 0);

pub async fn count(&self) -> Result<i64>

retrieves the number of sessions currently stored, including expired sessions

let store = PostgresSessionStore::new(&std::env::var("PG_TEST_DB_URL").unwrap()).await?;
store.migrate().await?;
assert_eq!(store.count().await?, 0);
store.store_session(Session::new()).await?;
assert_eq!(store.count().await?, 1);

Trait Implementations

impl Clone for PostgresSessionStore

fn clone(&self) -> PostgresSessionStore

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PostgresSessionStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl SessionStore for PostgresSessionStore

fn load_session<'life0, 'async_trait>(
    &'life0 self,
    cookie_value: String
) -> Pin<Box<dyn Future<Output = Result<Option<Session>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get a session from the storage backend.

fn store_session<'life0, 'async_trait>(
    &'life0 self,
    session: Session
) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Store a session on the storage backend.

fn destroy_session<'life0, 'async_trait>(
    &'life0 self,
    session: Session
) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Remove a session from the session store

fn clear_store<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Empties the entire store, destroying all sessions