Struct Session

pub struct Session<S: SessionStore = RedisStore> { /* private fields */ }

A parsed on-demand session store.

The default store is the RedisStore

Implementations

impl<S> Session<S>

where S: SessionStore,

pub fn new(inner: Arc<Inner<S>>) -> Self

Creates a new Session instance.

pub async fn get<T>(&self, field: &str) -> Result<Option<T>, Error>

where T: Clone + Send + Sync + DeserializeOwned,

Retrieves the value of a field from the session store.

Example

use ruts::{Session};
use fred::clients::Client;
use serde::Deserialize;
use ruts::store::redis::RedisStore;

#[derive(Clone, Deserialize)]
struct User {
    id: i64,
    name: String,
}

#[derive(Clone, Deserialize)]
enum Theme {
    Light,
    Dark,
}

#[derive(Clone, Deserialize)]
struct AppSession {
    user: User,
    theme: Option<Theme>,
}

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    session.get::<AppSession>("app").await.unwrap();
}

pub async fn get_all<T>(&self) -> Result<Option<T>, Error>

where T: Clone + Send + Sync + DeserializeOwned,

Retrieves values for all fields from the session store.

pub async fn insert<T>( &self, field: &str, value: &T, field_expire: Option<i64>, ) -> Result<bool, Error>

where T: Send + Sync + Serialize,

Inserts a value into the session store.

Returns true if the value was successfully inserted.

Example

use ruts::{Session};
use fred::clients::Client;
use serde::Serialize;
use ruts::store::redis::RedisStore;

#[derive(Serialize)]
struct User {
    id: i64,
    name: String,
}

#[derive(Serialize)]
enum Theme {
    Light,
    Dark,
}

#[derive(Serialize)]
struct AppSession {
    user: User,
    theme: Option<Theme>,
}

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    let app = AppSession {
            user: User {
            id: 34895634,
            name: String::from("John Doe"),
        },
        theme: Some(Theme::Dark),
    };

    session.insert("app", &app, Some(5)).await.unwrap();
}

pub async fn update<T>( &self, field: &str, value: &T, field_expire: Option<i64>, ) -> Result<bool, Error>

where T: Send + Sync + Serialize,

Updates a value in the session store.

If the key doesn’t exist, it will be inserted.

Returns true if the value was successfully updated or inserted.

Example

use ruts::{Session};
use fred::clients::Client;
use serde::Serialize;
use ruts::store::redis::RedisStore;

#[derive(Serialize)]
struct User {
    id: i64,
    name: String,
}

#[derive(Serialize)]
enum Theme {
    Light,
    Dark,
}

#[derive(Serialize)]
struct AppSession {
    user: User,
    theme: Option<Theme>,
}

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    let app = AppSession {
        user: User {
            id: 21342365,
            name: String::from("Jane Doe"),
        },
        theme: Some(Theme::Light),
    };

    let updated = session.update("app", &app, Some(5)).await.unwrap();
}

pub async fn remove(&self, field: &str) -> Result<i8, Error>

Removes a field along with its value from the session store.

Returns true if the field was successfully removed.

Example

use ruts::{Session};
use fred::clients::Client;
use ruts::store::redis::RedisStore;

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    let removed = session.remove("app").await.unwrap();
}

pub async fn delete(&self) -> Result<bool, Error>

Deletes the entire session from the store.

Returns true if the session was successfully deleted.

Example

use ruts::{Session};
use fred::clients::Client;
use ruts::store::redis::RedisStore;

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    let deleted = session.delete().await.unwrap();
}

pub async fn expire(&self, seconds: i64) -> Result<bool, Error>

Updates the cookie’s max-age and session expiry time in the store.

A value of -1 or 0 immediately expires the session and deletes it.

Returns true if the expiry was successfully updated.

Example

use ruts::{Session};
use fred::clients::Client;
use ruts::store::redis::RedisStore;

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    session.expire(30).await.unwrap();
}

pub fn set_expiration(&self, seconds: i64)

Updates the cookie max-age.

Any subsequent call to insert, update or regenerate within this request cycle will use this value.

NOTE: This does not change the max-age value set in the CookieOptions.

pub async fn regenerate(&self) -> Result<Option<Id>, Error>

Regenerates the session with a new ID.

Returns the new session ID if successful.

Example

use ruts::{Session};
use fred::clients::Client;
use ruts::store::redis::RedisStore;

async fn some_handler_could_be_axum(session: Session<RedisStore<Client>>) {
    let id = session.regenerate().await.unwrap();
}

pub fn id(&self) -> Option<Id>

Returns the session ID, if it exists.

Trait Implementations

impl<S: Debug + SessionStore> Debug for Session<S>

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

Formats the value using the given formatter.

impl<S, T> FromRequestParts<S> for Session<T>

where S: Sync + Send, T: SessionStore,

axum extractor for Session.

type Rejection = (StatusCode, &'static str)

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<Self, Self::Rejection>

Perform the extraction.