Skip to main content

openauth_core/
session.rs

1//! Database-backed session lifecycle helpers.
2
3use time::OffsetDateTime;
4
5use crate::context::AuthContext;
6use crate::crypto::random::generate_random_string;
7use crate::db::{
8    Create, DbAdapter, DbRecord, DbValue, Delete, DeleteMany, FindMany, FindOne, Session, Update,
9    Where,
10};
11use crate::error::OpenAuthError;
12use crate::options::SecondaryStorage;
13use std::sync::Arc;
14
15const SESSION_MODEL: &str = "session";
16const SESSION_FIELDS: [&str; 8] = [
17    "id",
18    "user_id",
19    "expires_at",
20    "token",
21    "ip_address",
22    "user_agent",
23    "created_at",
24    "updated_at",
25];
26const DEFAULT_SESSION_ID_LENGTH: usize = 32;
27const DEFAULT_SESSION_TOKEN_LENGTH: usize = 32;
28
29/// Input for creating a persisted session.
30#[derive(Debug, Clone, PartialEq)]
31pub struct CreateSessionInput {
32    pub id: Option<String>,
33    pub user_id: String,
34    pub expires_at: OffsetDateTime,
35    pub token: Option<String>,
36    pub ip_address: Option<String>,
37    pub user_agent: Option<String>,
38    pub additional_fields: DbRecord,
39}
40
41impl CreateSessionInput {
42    pub fn new(user_id: impl Into<String>, expires_at: OffsetDateTime) -> Self {
43        Self {
44            id: None,
45            user_id: user_id.into(),
46            expires_at,
47            token: None,
48            ip_address: None,
49            user_agent: None,
50            additional_fields: DbRecord::new(),
51        }
52    }
53
54    #[must_use]
55    pub fn id(mut self, id: impl Into<String>) -> Self {
56        self.id = Some(id.into());
57        self
58    }
59
60    #[must_use]
61    pub fn token(mut self, token: impl Into<String>) -> Self {
62        self.token = Some(token.into());
63        self
64    }
65
66    #[must_use]
67    pub fn ip_address(mut self, ip_address: impl Into<String>) -> Self {
68        self.ip_address = Some(ip_address.into());
69        self
70    }
71
72    #[must_use]
73    pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
74        self.user_agent = Some(user_agent.into());
75        self
76    }
77
78    #[must_use]
79    pub fn additional_fields(mut self, additional_fields: DbRecord) -> Self {
80        self.additional_fields = additional_fields;
81        self
82    }
83}
84
85/// Session store backed by the OpenAuth adapter contract.
86#[derive(Clone, Copy)]
87pub struct DbSessionStore<'a> {
88    adapter: &'a dyn DbAdapter,
89}
90
91impl<'a> DbSessionStore<'a> {
92    pub fn new(adapter: &'a dyn DbAdapter) -> Self {
93        Self { adapter }
94    }
95
96    pub async fn create_session(
97        &self,
98        input: CreateSessionInput,
99    ) -> Result<Session, OpenAuthError> {
100        let now = OffsetDateTime::now_utc();
101        let id = input
102            .id
103            .unwrap_or_else(|| generate_random_string(DEFAULT_SESSION_ID_LENGTH));
104        let token = input
105            .token
106            .unwrap_or_else(|| generate_random_string(DEFAULT_SESSION_TOKEN_LENGTH));
107
108        let mut query = Create::new(SESSION_MODEL)
109            .data("id", DbValue::String(id))
110            .data("user_id", DbValue::String(input.user_id))
111            .data("expires_at", DbValue::Timestamp(input.expires_at))
112            .data("token", DbValue::String(token))
113            .data("ip_address", optional_string(input.ip_address))
114            .data("user_agent", optional_string(input.user_agent))
115            .data("created_at", DbValue::Timestamp(now))
116            .data("updated_at", DbValue::Timestamp(now))
117            .select(SESSION_FIELDS)
118            .force_allow_id();
119        for (field, value) in input.additional_fields {
120            query = query.data(field, value);
121        }
122
123        let record = self.adapter.create(query).await?;
124
125        session_from_record(record)
126    }
127
128    pub async fn find_session(&self, token: &str) -> Result<Option<Session>, OpenAuthError> {
129        let Some(session) = self.find_session_including_expired(token).await? else {
130            return Ok(None);
131        };
132
133        if session.expires_at <= OffsetDateTime::now_utc() {
134            return Ok(None);
135        }
136
137        Ok(Some(session))
138    }
139
140    pub async fn find_session_including_expired(
141        &self,
142        token: &str,
143    ) -> Result<Option<Session>, OpenAuthError> {
144        self.adapter
145            .find_one(
146                FindOne::new(SESSION_MODEL)
147                    .where_clause(token_where(token))
148                    .select(SESSION_FIELDS),
149            )
150            .await?
151            .map(session_from_record)
152            .transpose()
153    }
154
155    pub async fn update_session_expiry(
156        &self,
157        token: &str,
158        expires_at: OffsetDateTime,
159    ) -> Result<Option<Session>, OpenAuthError> {
160        let record = self
161            .adapter
162            .update(
163                Update::new(SESSION_MODEL)
164                    .where_clause(token_where(token))
165                    .data("expires_at", DbValue::Timestamp(expires_at))
166                    .data("updated_at", DbValue::Timestamp(OffsetDateTime::now_utc())),
167            )
168            .await?;
169
170        record.map(session_from_record).transpose()
171    }
172
173    pub async fn delete_session(&self, token: &str) -> Result<(), OpenAuthError> {
174        self.adapter
175            .delete(Delete::new(SESSION_MODEL).where_clause(token_where(token)))
176            .await
177    }
178
179    pub async fn delete_user_sessions(&self, user_id: &str) -> Result<u64, OpenAuthError> {
180        self.adapter
181            .delete_many(
182                DeleteMany::new(SESSION_MODEL)
183                    .where_clause(Where::new("user_id", DbValue::String(user_id.to_owned()))),
184            )
185            .await
186    }
187
188    pub async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<Session>, OpenAuthError> {
189        let now = OffsetDateTime::now_utc();
190        self.adapter
191            .find_many(
192                FindMany::new(SESSION_MODEL)
193                    .where_clause(Where::new("user_id", DbValue::String(user_id.to_owned())))
194                    .select(SESSION_FIELDS),
195            )
196            .await?
197            .into_iter()
198            .map(session_from_record)
199            .filter_map(|result| match result {
200                Ok(session) if session.expires_at > now => Some(Ok(session)),
201                Ok(_) => None,
202                Err(error) => Some(Err(error)),
203            })
204            .collect()
205    }
206}
207
208/// Session store that uses configured secondary storage when present.
209#[derive(Clone)]
210pub struct SessionStore<'a> {
211    database: DbSessionStore<'a>,
212    secondary_storage: Option<Arc<dyn SecondaryStorage>>,
213    store_session_in_database: bool,
214    preserve_session_in_database: bool,
215}
216
217impl<'a> SessionStore<'a> {
218    pub fn new(adapter: &'a dyn DbAdapter, context: &AuthContext) -> Self {
219        Self::with_storage(
220            adapter,
221            context.secondary_storage(),
222            context.options.session.store_session_in_database,
223            context.options.session.preserve_session_in_database,
224        )
225    }
226
227    pub fn with_storage(
228        adapter: &'a dyn DbAdapter,
229        secondary_storage: Option<Arc<dyn SecondaryStorage>>,
230        store_session_in_database: bool,
231        preserve_session_in_database: bool,
232    ) -> Self {
233        Self {
234            database: DbSessionStore::new(adapter),
235            secondary_storage,
236            store_session_in_database,
237            preserve_session_in_database,
238        }
239    }
240
241    pub async fn create_session(
242        &self,
243        input: CreateSessionInput,
244    ) -> Result<Session, OpenAuthError> {
245        let Some(storage) = &self.secondary_storage else {
246            return self.database.create_session(input).await;
247        };
248        let session = if self.store_session_in_database {
249            self.database.create_session(input).await?
250        } else {
251            session_from_input(input)
252        };
253        self.set_secondary_session(storage.as_ref(), &session)
254            .await?;
255        self.add_user_session_token(storage.as_ref(), &session)
256            .await?;
257        Ok(session)
258    }
259
260    pub async fn find_session(&self, token: &str) -> Result<Option<Session>, OpenAuthError> {
261        let Some(session) = self.find_session_including_expired(token).await? else {
262            return Ok(None);
263        };
264        if session.expires_at <= OffsetDateTime::now_utc() {
265            self.delete_session(token).await?;
266            return Ok(None);
267        }
268        Ok(Some(session))
269    }
270
271    pub async fn find_session_including_expired(
272        &self,
273        token: &str,
274    ) -> Result<Option<Session>, OpenAuthError> {
275        let Some(storage) = &self.secondary_storage else {
276            return self.database.find_session_including_expired(token).await;
277        };
278        match self.find_secondary_session(storage.as_ref(), token).await? {
279            Some(session) => Ok(Some(session)),
280            None if self.store_session_in_database => {
281                self.database.find_session_including_expired(token).await
282            }
283            None => Ok(None),
284        }
285    }
286
287    pub async fn update_session_expiry(
288        &self,
289        token: &str,
290        expires_at: OffsetDateTime,
291    ) -> Result<Option<Session>, OpenAuthError> {
292        let Some(storage) = &self.secondary_storage else {
293            return self.database.update_session_expiry(token, expires_at).await;
294        };
295        let Some(mut session) = self.find_session_including_expired(token).await? else {
296            return Ok(None);
297        };
298        session.expires_at = expires_at;
299        session.updated_at = OffsetDateTime::now_utc();
300        self.set_secondary_session(storage.as_ref(), &session)
301            .await?;
302        if self.store_session_in_database {
303            let _updated = self
304                .database
305                .update_session_expiry(token, expires_at)
306                .await?;
307        }
308        Ok(Some(session))
309    }
310
311    pub async fn delete_session(&self, token: &str) -> Result<(), OpenAuthError> {
312        let Some(storage) = &self.secondary_storage else {
313            return self.database.delete_session(token).await;
314        };
315        if let Some(session) = self.find_secondary_session(storage.as_ref(), token).await? {
316            self.remove_user_session_token(storage.as_ref(), &session.user_id, token)
317                .await?;
318        }
319        storage.delete(&session_key(token)).await?;
320        if self.store_session_in_database && !self.preserve_session_in_database {
321            self.database.delete_session(token).await?;
322        }
323        Ok(())
324    }
325
326    pub async fn delete_user_sessions(&self, user_id: &str) -> Result<u64, OpenAuthError> {
327        let Some(storage) = &self.secondary_storage else {
328            return self.database.delete_user_sessions(user_id).await;
329        };
330        let tokens = self.user_session_tokens(storage.as_ref(), user_id).await?;
331        let mut deleted = 0;
332        for token in &tokens {
333            if self
334                .find_secondary_session(storage.as_ref(), token)
335                .await?
336                .is_some()
337            {
338                deleted += 1;
339            }
340            storage.delete(&session_key(token)).await?;
341        }
342        storage.delete(&user_sessions_key(user_id)).await?;
343        if self.store_session_in_database && !self.preserve_session_in_database {
344            self.database.delete_user_sessions(user_id).await?;
345        }
346        Ok(deleted)
347    }
348
349    pub async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<Session>, OpenAuthError> {
350        let Some(storage) = &self.secondary_storage else {
351            return self.database.list_user_sessions(user_id).await;
352        };
353        let tokens = self.user_session_tokens(storage.as_ref(), user_id).await?;
354        let now = OffsetDateTime::now_utc();
355        let mut sessions = Vec::new();
356        let mut active_tokens = Vec::new();
357        for token in tokens {
358            let Some(session) = self
359                .find_secondary_session(storage.as_ref(), &token)
360                .await?
361            else {
362                continue;
363            };
364            if session.expires_at > now {
365                active_tokens.push(token);
366                sessions.push(session);
367            } else {
368                storage.delete(&session_key(&token)).await?;
369            }
370        }
371        self.set_user_session_tokens(storage.as_ref(), user_id, &active_tokens)
372            .await?;
373        if sessions.is_empty() && self.store_session_in_database {
374            return self.database.list_user_sessions(user_id).await;
375        }
376        Ok(sessions)
377    }
378
379    async fn set_secondary_session(
380        &self,
381        storage: &dyn SecondaryStorage,
382        session: &Session,
383    ) -> Result<(), OpenAuthError> {
384        storage
385            .set(
386                &session_key(&session.token),
387                serialize_session(session)?,
388                ttl_seconds(session.expires_at),
389            )
390            .await
391    }
392
393    async fn find_secondary_session(
394        &self,
395        storage: &dyn SecondaryStorage,
396        token: &str,
397    ) -> Result<Option<Session>, OpenAuthError> {
398        storage
399            .get(&session_key(token))
400            .await?
401            .map(|value| deserialize_session(&value))
402            .transpose()
403    }
404
405    async fn add_user_session_token(
406        &self,
407        storage: &dyn SecondaryStorage,
408        session: &Session,
409    ) -> Result<(), OpenAuthError> {
410        let mut tokens = self
411            .user_session_tokens(storage, &session.user_id)
412            .await?
413            .into_iter()
414            .filter(|token| token != &session.token)
415            .collect::<Vec<_>>();
416        tokens.push(session.token.clone());
417        self.set_user_session_tokens(storage, &session.user_id, &tokens)
418            .await
419    }
420
421    async fn remove_user_session_token(
422        &self,
423        storage: &dyn SecondaryStorage,
424        user_id: &str,
425        token: &str,
426    ) -> Result<(), OpenAuthError> {
427        let tokens = self
428            .user_session_tokens(storage, user_id)
429            .await?
430            .into_iter()
431            .filter(|stored| stored != token)
432            .collect::<Vec<_>>();
433        self.set_user_session_tokens(storage, user_id, &tokens)
434            .await
435    }
436
437    async fn user_session_tokens(
438        &self,
439        storage: &dyn SecondaryStorage,
440        user_id: &str,
441    ) -> Result<Vec<String>, OpenAuthError> {
442        storage
443            .get(&user_sessions_key(user_id))
444            .await?
445            .map(|value| deserialize_user_session_tokens(&value))
446            .transpose()
447            .map(|tokens| tokens.unwrap_or_default())
448    }
449
450    async fn set_user_session_tokens(
451        &self,
452        storage: &dyn SecondaryStorage,
453        user_id: &str,
454        tokens: &[String],
455    ) -> Result<(), OpenAuthError> {
456        if tokens.is_empty() {
457            return storage.delete(&user_sessions_key(user_id)).await;
458        }
459        storage
460            .set(
461                &user_sessions_key(user_id),
462                serialize_user_session_tokens(tokens)?,
463                None,
464            )
465            .await
466    }
467}
468
469fn optional_string(value: Option<String>) -> DbValue {
470    value.map(DbValue::String).unwrap_or(DbValue::Null)
471}
472
473fn session_from_input(input: CreateSessionInput) -> Session {
474    let now = OffsetDateTime::now_utc();
475    Session {
476        id: input
477            .id
478            .unwrap_or_else(|| generate_random_string(DEFAULT_SESSION_ID_LENGTH)),
479        user_id: input.user_id,
480        expires_at: input.expires_at,
481        token: input
482            .token
483            .unwrap_or_else(|| generate_random_string(DEFAULT_SESSION_TOKEN_LENGTH)),
484        ip_address: input.ip_address,
485        user_agent: input.user_agent,
486        created_at: now,
487        updated_at: now,
488    }
489}
490
491fn session_key(token: &str) -> String {
492    format!("session:{token}")
493}
494
495fn user_sessions_key(user_id: &str) -> String {
496    format!("session:user:{user_id}")
497}
498
499fn serialize_session(session: &Session) -> Result<String, OpenAuthError> {
500    serde_json::to_string(session).map_err(|error| OpenAuthError::Serialization {
501        context: "serializing session",
502        message: error.to_string(),
503    })
504}
505
506fn deserialize_session(value: &str) -> Result<Session, OpenAuthError> {
507    serde_json::from_str(value).map_err(|error| OpenAuthError::Serialization {
508        context: "deserializing session",
509        message: error.to_string(),
510    })
511}
512
513fn serialize_user_session_tokens(tokens: &[String]) -> Result<String, OpenAuthError> {
514    serde_json::to_string(tokens).map_err(|error| OpenAuthError::Serialization {
515        context: "serializing user session index",
516        message: error.to_string(),
517    })
518}
519
520fn deserialize_user_session_tokens(value: &str) -> Result<Vec<String>, OpenAuthError> {
521    serde_json::from_str(value).map_err(|error| OpenAuthError::Serialization {
522        context: "deserializing user session index",
523        message: error.to_string(),
524    })
525}
526
527fn ttl_seconds(expires_at: OffsetDateTime) -> Option<u64> {
528    let seconds = (expires_at - OffsetDateTime::now_utc()).whole_seconds();
529    Some(u64::try_from(seconds.max(0)).unwrap_or(0))
530}
531
532fn token_where(token: &str) -> Where {
533    Where::new("token", DbValue::String(token.to_owned()))
534}
535
536fn session_from_record(record: DbRecord) -> Result<Session, OpenAuthError> {
537    Ok(Session {
538        id: required_string(&record, "id")?.to_owned(),
539        user_id: required_string(&record, "user_id")?.to_owned(),
540        expires_at: required_timestamp(&record, "expires_at")?,
541        token: required_string(&record, "token")?.to_owned(),
542        ip_address: optional_string_field(&record, "ip_address")?,
543        user_agent: optional_string_field(&record, "user_agent")?,
544        created_at: required_timestamp(&record, "created_at")?,
545        updated_at: required_timestamp(&record, "updated_at")?,
546    })
547}
548
549fn required_string<'a>(record: &'a DbRecord, field: &str) -> Result<&'a str, OpenAuthError> {
550    match record.get(field) {
551        Some(DbValue::String(value)) => Ok(value),
552        Some(_) => Err(invalid_field(field, "string")),
553        None => Err(missing_field(field)),
554    }
555}
556
557fn optional_string_field(record: &DbRecord, field: &str) -> Result<Option<String>, OpenAuthError> {
558    match record.get(field) {
559        Some(DbValue::String(value)) => Ok(Some(value.to_owned())),
560        Some(DbValue::Null) | None => Ok(None),
561        Some(_) => Err(invalid_field(field, "string or null")),
562    }
563}
564
565fn required_timestamp(record: &DbRecord, field: &str) -> Result<OffsetDateTime, OpenAuthError> {
566    match record.get(field) {
567        Some(DbValue::Timestamp(value)) => Ok(*value),
568        Some(_) => Err(invalid_field(field, "timestamp")),
569        None => Err(missing_field(field)),
570    }
571}
572
573fn missing_field(field: &str) -> OpenAuthError {
574    OpenAuthError::MissingRecordField {
575        record: "session",
576        field: field.to_owned(),
577    }
578}
579
580fn invalid_field(field: &str, expected: &'static str) -> OpenAuthError {
581    OpenAuthError::InvalidRecordField {
582        record: "session",
583        field: field.to_owned(),
584        expected,
585    }
586}