Struct SessionLayer 

pub struct SessionLayer { /* private fields */ }

Session middleware over a SessionStore.

Cookie load/save stays here. App logic (hydrate user, ACL, …) goes in SessionLayer::hook.

Implementations

impl SessionLayer

pub fn new(kv: Arc<dyn KvStore>) -> Self

Wrap a KvStore (typically namespace(store, "sess")) in KvSessionStore.

pub fn from_store(store: Arc<dyn SessionStore>) -> Self

Use an arbitrary SessionStore (e.g. [SqlSessionStore]).

pub fn from_app_store(app: &App) -> Self

Sessions on an installed sova_store::AppStore (namespaced sess).

pub fn cookie_name(self, name: impl Into<String>) -> Self

pub fn secure(self, secure: bool) -> Self

pub fn http_only(self, on: bool) -> Self

pub fn same_site(self, same_site: SameSite) -> Self

pub fn path(self, path: impl Into<String>) -> Self

pub fn ttl(self, ttl: Duration) -> Self

pub fn rolling(self, on: bool) -> Self

Refresh store TTL and Set-Cookie on every response.

pub fn save_uninitialized(self, on: bool) -> Self

Persist empty new sessions (Express default false).

pub fn hook<F, Fut>(self, f: F) -> Self

where F: Fn(Session, Request) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Request>> + Send + 'static,

After cookie session is loaded (and set on req), run app logic.

Clone Arcs from req before async move. Return the (possibly mutated) request:

SessionLayer::new(store).hook(|sess, mut req| async move {
    if let Some(id) = sess.get("user_id") {
        let db = req.state::<Db>().clone();
        if let Some(u) = find_user(&db, &id).await? {
            req.set(u);
        }
    }
    Ok(req)
})

Trait Implementations

impl Plugin for SessionLayer

fn id(&self) -> &'static str

Stable plugin identifier used for dependency checks and crate::App::has_plugin.

fn meta(&self) -> PluginMeta

Display name, description, and declared PluginMeta::sdk version.

fn install(self, app: &mut App)

Register middleware, state, routes, and hooks on app.

fn requires(&self) -> &'static [&'static str]

Required plugin ids that must be installed beforehand.