Struct SqlxPostgresStorage 

pub struct SqlxPostgresStorage { /* private fields */ }

Available on crate feature sqlx_postgres and (crate features sqlx_postgres or sqlx_sqlite) only.

Session store using PostgreSQL via sqlx.

Requirements

• You must pass in an initialized sqlx Postgres connection pool.
• Your session data type must implement SessionSqlx to configure how to convert & store session data.
• Your session data type must implement SessionIdentifier. The SessionIdentifier’s Id type must be a type supported by sqlx.
• Expects a table to already exist with the following columns:

Name	Type
id	text PRIMARY KEY
data	text NOT NULL (or jsonb)
user_id	SQL type of SessionIdentifier::Id
expires	timestamptz NOT NULL

The name of the session index column (“user_id”) can be customized when building the storage.

Session storage

Sessions are stored in the table specified by table_name, along with the optional identifier (typically a user ID) and the session’s expiration time. You can enable automatic deletion of expired sessions by setting the cleanup_interval option. This storage provider does not create any table or index for you, so you’ll need to do that in your existing migration flow.

Example

Initialize the sqlx pool, then use the builder pattern to create a new instance of SqlxPostgresStorage:

use rocket_flex_session::storage::sqlx::SqlxPostgresStorage;
use std::time::Duration;

async fn create_storage() -> SqlxPostgresStorage {
    let url = "postgres://...";
    let pool = sqlx::PgPool::connect(url).await.unwrap();
    SqlxPostgresStorage::builder()
        .pool(pool.clone())
        .table_name("sessions")
        // name of the column used to group sessions
        .index_column("user_id")
        // optional auto-deletion of expired sessions
        .cleanup_interval(Duration::from_secs(600))
        .build()
}

Implementations

impl SqlxPostgresStorage

pub fn builder() -> SqlxPostgresStorageBuilder

Trait Implementations

impl<T> SessionStorage<T> for SqlxPostgresStorage

where T: SessionSqlx<Postgres>, <T as SessionIdentifier>::Id: for<'q> Encode<'q, Postgres> + Type<Postgres>,

fn as_indexed_storage(&self) -> Option<&dyn SessionStorageIndexed<T>>

Storages that support indexing (by implementing SessionStorageIndexed) must also implement this. Implementation should be trivial: Some(self)

fn load<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, ttl: Option<u32>, _cookie_jar: &'life2 CookieJar<'_>, ) -> Pin<Box<dyn Future<Output = SessionResult<(T, u32)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load session data and TTL (time-to-live in seconds) from storage. If a TTL value is provided, it should be set upon retreiving the session. If session is already expired or otherwise invalid, a SessionError should be returned instead.

fn save<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, data: T, ttl: u32, ) -> Pin<Box<dyn Future<Output = SessionResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save or update a session in storage. This will be performed at the end of the request lifecycle.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, _data: T, ) -> Pin<Box<dyn Future<Output = SessionResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a session in storage. This will be performed at the end of the request lifecycle.

fn setup<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = SessionResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Optional setup of resources that will be called on server startup

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = SessionResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Optional teardown of resources that will be called on server shutdown

fn save_cookie( &self, id: &str, data: Option<&T>, ttl: u32, cookie_jar: &CookieJar<'_>, ) -> SessionResult<()>

Optional callback when there’s a pending change to the session data. A data value of None indicates a deleted session. This callback can be used by cookie-based session stores to update the cookie jar during the request.

impl<T> SessionStorageIndexed<T> for SqlxPostgresStorage

where T: SessionSqlx<Postgres>, <T as SessionIdentifier>::Id: for<'q> Encode<'q, Postgres> + Type<Postgres>,

fn get_session_ids_by_identifier<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 T::Id, ) -> Pin<Box<dyn Future<Output = SessionResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve all tracked session IDs associated with the given identifier.

fn get_sessions_by_identifier<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 T::Id, ) -> Pin<Box<dyn Future<Output = SessionResult<Vec<(String, T, u32)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve all tracked session IDs, data, and TTL for the given identifier.

fn invalidate_sessions_by_identifier<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 T::Id, excluded_session_id: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = SessionResult<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Invalidate all tracked sessions associated with the given identifier, optionally excluding one session ID. Returns the number of sessions invalidated.