use crate::{AuthenticatedUser, Error};
use serde::{Deserialize, Serialize};
use std::time::Duration;
pub const DEFAULT_FLOW_TTL: Duration = Duration::from_secs(10 * 60);
pub const DEFAULT_SESSION_TTL: Duration = Duration::from_secs(24 * 60 * 60);
#[derive(Clone, Deserialize, Serialize)]
pub struct PendingOAuthFlow {
state: String,
pkce_verifier: String,
expires_at: u64,
}
impl std::fmt::Debug for PendingOAuthFlow {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("PendingOAuthFlow")
.field("state", &"[REDACTED]")
.field("pkce_verifier", &"[REDACTED]")
.field("expires_at", &self.expires_at)
.finish()
}
}
impl PendingOAuthFlow {
pub(crate) fn new(
state: String,
pkce_verifier: String,
created_at: u64,
ttl: Duration,
) -> Result<Self, Error> {
let expires_at = created_at
.checked_add(ttl.as_secs())
.ok_or_else(|| Error::configuration("OAuth flow lifetime is too large"))?;
Ok(Self {
state,
pkce_verifier,
expires_at,
})
}
pub fn expires_at(&self) -> u64 {
self.expires_at
}
pub(crate) fn state(&self) -> &str {
&self.state
}
pub(crate) fn pkce_verifier(&self) -> &str {
&self.pkce_verifier
}
}
pub trait SessionStore {
fn pending_flow(&self) -> Result<Option<PendingOAuthFlow>, Error>;
fn set_pending_flow(&mut self, flow: PendingOAuthFlow) -> Result<(), Error>;
fn take_pending_flow(&mut self) -> Result<Option<PendingOAuthFlow>, Error>;
fn authenticated_user(&self) -> Result<Option<AuthenticatedUser>, Error>;
fn set_authenticated_user(&mut self, user: AuthenticatedUser) -> Result<(), Error>;
fn clear_authenticated_user(&mut self) -> Result<(), Error>;
fn clear_pending_flow(&mut self) -> Result<(), Error>;
fn clear(&mut self) -> Result<(), Error> {
self.clear_pending_flow()?;
self.clear_authenticated_user()
}
}
#[cfg(test)]
#[derive(Default)]
pub(crate) struct MemorySessionStore {
pending: Option<PendingOAuthFlow>,
authenticated: Option<AuthenticatedUser>,
}
#[cfg(test)]
impl SessionStore for MemorySessionStore {
fn pending_flow(&self) -> Result<Option<PendingOAuthFlow>, Error> {
Ok(self.pending.clone())
}
fn set_pending_flow(&mut self, flow: PendingOAuthFlow) -> Result<(), Error> {
self.pending = Some(flow);
Ok(())
}
fn take_pending_flow(&mut self) -> Result<Option<PendingOAuthFlow>, Error> {
Ok(self.pending.take())
}
fn authenticated_user(&self) -> Result<Option<AuthenticatedUser>, Error> {
Ok(self.authenticated.clone())
}
fn set_authenticated_user(&mut self, user: AuthenticatedUser) -> Result<(), Error> {
self.authenticated = Some(user);
Ok(())
}
fn clear_authenticated_user(&mut self) -> Result<(), Error> {
self.authenticated = None;
Ok(())
}
fn clear_pending_flow(&mut self) -> Result<(), Error> {
self.pending = None;
Ok(())
}
}