Struct PgStore 

pub struct PgStore { /* private fields */ }

Available on crate feature postgres only.

Stores sessions in PostgreSQL through a sqlx PgPool. Shared safely by any number of processes; rotations are single transactions with a conditional update, and a partial unique index guarantees at most one current token per session.

Tables are named session_guard_*. Create them with PgStore::migrated, or run PgStore::migrator in your own deployment pipeline. Applied migrations are tracked in _session_guard_migrations, separate from your app’s _sqlx_migrations.

use session_guard::{Guard, PgStore};

let pool = sqlx::PgPool::connect("postgres://localhost/app").await?;
let guard = Guard::new(PgStore::migrated(pool).await?);

Implementations

impl PgStore

pub fn new(pool: PgPool) -> Self

Wraps pool without touching the schema. Run PgStore::migrator first.

pub async fn migrated(pool: PgPool) -> Result<Self, MigrateError>

Runs the embedded migrations, then wraps pool. Safe to call from many processes at once and on every start: applied migrations are skipped.

Errors

If a migration fails or the applied migrations do not match the embedded ones.

pub fn migrator() -> &'static Migrator

The embedded migrations, for running them in your own pipeline: PgStore::migrator().run(&pool).await?.

pub fn pool(&self) -> &PgPool

The underlying pool.

Trait Implementations

impl Clone for PgStore

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PgStore

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

Formats the value using the given formatter.

impl SessionStore for PgStore

async fn insert_session( &self, session: &SessionRecord, token: &TokenHash, ) -> Result<(), StoreError>

Stores a new session with token as its current token (issued_at = created_at, unused, not superseded).

async fn find_by_token( &self, token: &TokenHash, ) -> Result<Option<TokenLookup>, StoreError>

Finds the session holding token, current or superseded.

async fn apply(&self, update: &SessionUpdate) -> Result<bool, StoreError>

Applies update atomically, in this order:

async fn delete_session(&self, session_id: Uuid) -> Result<bool, StoreError>

Deletes a session and its tokens. Returns whether it existed.

async fn delete_subject_sessions( &self, subject: &str, ) -> Result<Vec<Uuid>, StoreError>

Deletes every session of subject (canonical JSON). Returns the ids it deleted.

async fn list_subject_sessions( &self, subject: &str, ) -> Result<Vec<SessionRecord>, StoreError>

Every session of subject (canonical JSON), including expired ones not yet purged.

async fn delete_expired( &self, now: DateTime<Utc>, idle_cutoff: DateTime<Utc>, ) -> Result<u64, StoreError>

Deletes sessions with expires_at <= now or last_seen_at <= idle_cutoff. Returns how many.

async fn record_event(&self, event: &SessionEvent) -> Result<(), StoreError>

Appends a security event. Stores without an event log may discard it.

async fn delete_events_before( &self, cutoff: DateTime<Utc>, ) -> Result<u64, StoreError>

Deletes events with at < cutoff. Returns how many. Also deletes event claims older than cutoff.

async fn claim_event( &self, scope: ClaimScope<'_>, kind: EventKind, now: DateTime<Utc>, window: TimeDelta, ) -> Result<bool, StoreError>

Claims the right to report a kind event for scope, for deduplication across processes. Succeeds (true) unless a claim for the same scope and kind was made after now - window, and records now as the new claim when it does. Session and subject claims are independent. Must be atomic across processes.

fn sharded(&self) -> bool

Whether the store partitions data into buckets that must be co-located.