Struct ValkeySessionStore 

pub struct ValkeySessionStore { /* private fields */ }

Available on crate feature valkey only.

Valkey-backed session store with optional AES-256-GCM encryption at rest.

Session data is serialized with MessagePack and optionally encrypted before storage. TTL is managed by Valkey-native key expiry. Clone is cheap: the inner client and keys are Arc-based.

Implementations

impl ValkeySessionStore

pub fn new(client: Client, key: [u8; 32]) -> Self

Create an encrypted store using AES-256-GCM (recommended for production).

All session data is encrypted before writing to Valkey and decrypted on read. The 32-byte key should be loaded from a secret store and persisted across restarts.

pub fn plaintext(client: Client) -> Self

Create a plaintext store (development/testing only).

Session data is stored unencrypted in Valkey. Do not use in production.

pub fn encrypted(client: Client, key: [u8; 32]) -> Self

Create an encrypted store using AES-256-GCM.

Alias for new.

pub fn encrypted_with_rotation( client: Client, current_key: [u8; 32], previous_key: [u8; 32], ) -> Self

Create an encrypted store with key rotation support.

Writes always use current_key. Reads try current_key first; if decryption fails, they retry with previous_key. This allows zero-downtime key rotation: deploy the new key as current, keep the old key as previous until all sessions have been naturally refreshed (i.e. one full TTL window), then remove the previous key.

pub fn with_prefix(self, prefix: impl Into<Arc<str>>) -> Self

Override the key prefix (default: "axess").

Use this to namespace sessions per tenant or application when multiple services share the same Valkey instance. For multi-tenant setups, include the tenant ID in the prefix (e.g. "axess:tenant_abc").

pub fn with_max_payload(self, max_bytes: usize) -> Self

Override the maximum encoded payload size (default: 64 KiB).

Encoded size is checked after serialization (and encryption, if enabled) but before writing to Valkey. This protects against unbounded growth of SessionData.custom.

Trait Implementations

impl Clone for ValkeySessionStore

fn clone(&self) -> ValkeySessionStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl HealthCheck for ValkeySessionStore

fn check(&self) -> Pin<Box<dyn Future<Output = HealthStatus> + Send + '_>>

Probe the component and return its current health.

impl SessionStore for ValkeySessionStore

async fn prune_expired(&self) -> Result<u64, Self::Error>

Valkey/Redis evicts expired keys natively (active + passive expiry, see Redis docs §EXPIRE). There is nothing for the application to sweep; the server already does it. This returns Ok(0) deliberately, not as the “unsupported” sentinel the trait once defaulted to.

type Error = ValkeyStoreError

The error type returned by storage operations.

async fn load(&self, id: &SessionId) -> Result<Option<SessionData>, Self::Error>

Load the session data for the given ID. Returns None if the session does not exist or has expired.

async fn save( &self, id: &SessionId, data: &SessionData, ttl: Duration, ) -> Result<(), Self::Error>

Persist session data with a time-to-live.

async fn delete(&self, id: &SessionId) -> Result<(), Self::Error>

Delete the session. Idempotent; does not error if the session is absent.

async fn cycle( &self, old_id: &SessionId, new_id: &SessionId, data: &SessionData, ttl: Duration, ) -> Result<(), Self::Error>

Atomically delete the old session row and store the data under the caller-supplied new id.

fn find_sessions_for_user( &self, user_id: &UserId, limit: usize, ) -> impl Future<Output = Result<Vec<(SessionId, SessionData)>, Self::Error>> + Send

Return active (non-expired) sessions for the given user, newest first.

impl Store<SessionId, SessionData> for ValkeySessionStore

type Error = ValkeyStoreError

Backend-specific error. Use the shared StoreError enum for new backends; legacy wrappers may continue to surface SqlStoreError / ValkeyStoreError / PostgresStoreError until each is consolidated.

fn get( &self, key: &SessionId, ) -> impl Future<Output = Result<Option<SessionData>, Self::Error>> + Send

Fetch the value for key. Ok(None) when the key is absent (including TTL-expired); Err only on backend failure.

fn put( &self, key: &SessionId, value: &SessionData, ttl: Duration, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Insert or replace the value at key with the given TTL.

fn delete( &self, key: &SessionId, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Remove the entry at key. Idempotent; does not error if absent.

fn prune_expired(&self) -> impl Future<Output = Result<u64, Self::Error>> + Send

Bulk-evict every TTL-expired entry. Returns the number reclaimed. Backends with native TTL eviction (Valkey/Redis) may implement this as a no-op returning Ok(0); backends owning their own row table (SQLite, Postgres, in-memory) actually delete.