1use 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#[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#[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#[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}