use chrono::Utc;
use crate::authorization::Authorization;
use crate::db::{bind_id, quote_ident, safe_sql};
use crate::errors::{Error, Result};
use crate::http::RequestContext;
use crate::response::ResponseWriter;
use crate::session::{SESSION_COLUMNS, Session};
use crate::token::Tokens;
#[derive(Debug, Clone)]
pub struct CheckSessionResult {
pub tokens: Tokens,
pub session_id: String,
pub user_id: String,
}
impl Authorization {
pub async fn check_session(
&self,
w: &mut ResponseWriter,
r: &RequestContext<'_>,
) -> Result<CheckSessionResult> {
let refresh_token = match self.get_token_from_header(r.header("authorization")) {
Ok(token) => token,
Err(_) => body_refresh_token(r),
};
if refresh_token.is_empty() {
return Err(Error::MissingRefreshToken);
}
let claims = self
.extract_token(&refresh_token)
.map_err(|_| Error::InvalidRefreshToken)?;
if claims.session_id.is_empty() {
return Err(Error::InvalidRefreshToken);
}
self.ensure_session_active(&claims.session_id).await?;
let session = self.get_session(&claims.session_id).await.map_err(|err| {
if err.is_session_missing() {
Error::SessionNotFound
} else {
err
}
})?;
if !claims.user_id.is_empty() && claims.user_id != session.user_id {
return Err(Error::InvalidRefreshToken);
}
let access_token = self.refresh_access_token(&claims, &session, [])?;
self.set_session_id_cookie(w, r, &session.id);
Ok(CheckSessionResult {
tokens: Tokens {
access_token,
refresh_token,
},
session_id: session.id,
user_id: session.user_id,
})
}
pub async fn ensure_session_active(&self, session_id: &str) -> Result<()> {
let db = self.db()?;
let sql = safe_sql(format!(
"SELECT {SESSION_COLUMNS} FROM {} WHERE id = $1 AND is_deleted = false LIMIT 1",
quote_ident(self.sessions_table())
));
let query = sqlx::query(&sql);
let row = bind_id!(query, session_id)
.fetch_one(db)
.await
.map_err(|err| match err {
sqlx::Error::RowNotFound => Error::SessionNotFound,
other => Error::Database(other),
})?;
let session = Session::from_row(&row)?;
session_usable(Some(&session))
}
}
pub fn session_usable(s: Option<&Session>) -> Result<()> {
let Some(s) = s else {
return Err(Error::SessionNotFound);
};
if s.is_deleted {
return Err(Error::SessionNotFound);
}
if let Some(expires_at) = s.expires_at {
if Utc::now() > expires_at {
return Err(Error::SessionExpired);
}
}
Ok(())
}
pub(crate) fn body_refresh_token(r: &RequestContext<'_>) -> String {
#[derive(serde::Deserialize)]
struct Body {
#[serde(default)]
refresh_token: String,
}
serde_json::from_slice::<Body>(r.body())
.map(|body| body.refresh_token)
.unwrap_or_default()
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::Duration;
#[test]
fn session_usable_rejects_dead_sessions() {
let now = Utc::now();
let cases: Vec<(&str, Option<Session>, Option<Error>)> = vec![
("nil session", None, Some(Error::SessionNotFound)),
(
"soft-deleted session",
Some(Session {
id: "s1".into(),
is_deleted: true,
expires_at: Some(now + Duration::hours(1)),
..Session::default()
}),
Some(Error::SessionNotFound),
),
(
"expired session",
Some(Session {
id: "s1".into(),
expires_at: Some(now - Duration::minutes(1)),
..Session::default()
}),
Some(Error::SessionExpired),
),
(
"active session",
Some(Session {
id: "s1".into(),
expires_at: Some(now + Duration::hours(1)),
..Session::default()
}),
None,
),
(
"zero expiry never expires",
Some(Session {
id: "s1".into(),
..Session::default()
}),
None,
),
];
for (name, session, want) in cases {
let got = session_usable(session.as_ref());
match want {
None => assert!(got.is_ok(), "{name}: expected ok, got {got:?}"),
Some(Error::SessionNotFound) => {
assert!(
matches!(got, Err(Error::SessionNotFound)),
"{name}: got {got:?}"
);
}
Some(Error::SessionExpired) => {
assert!(
matches!(got, Err(Error::SessionExpired)),
"{name}: got {got:?}"
);
}
Some(other) => panic!("{name}: unexpected expectation {other:?}"),
}
}
}
}