1use crate::errors::Result;
4use crate::tokens::AuthToken;
5use async_trait::async_trait;
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8use std::sync::{Arc, RwLock};
9use std::time::Duration;
10
11#[cfg(feature = "redis-storage")]
12use crate::errors::StorageError;
13
14#[async_trait]
76pub trait AuthStorage: Send + Sync {
77 async fn store_tokens_bulk(&self, tokens: &[AuthToken]) -> Result<()> {
79 for token in tokens {
80 self.store_token(token).await?;
81 }
82 Ok(())
83 }
84
85 async fn delete_tokens_bulk(&self, token_ids: &[String]) -> Result<()> {
87 for token_id in token_ids {
88 self.delete_token(token_id).await?;
89 }
90 Ok(())
91 }
92
93 async fn store_sessions_bulk(&self, sessions: &[(String, SessionData)]) -> Result<()> {
95 for (session_id, data) in sessions {
96 self.store_session(session_id, data).await?;
97 }
98 Ok(())
99 }
100
101 async fn delete_sessions_bulk(&self, session_ids: &[String]) -> Result<()> {
103 for session_id in session_ids {
104 self.delete_session(session_id).await?;
105 }
106 Ok(())
107 }
108 async fn store_token(&self, token: &AuthToken) -> Result<()>;
110
111 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>>;
113
114 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>>;
116
117 async fn update_token(&self, token: &AuthToken) -> Result<()>;
119
120 async fn delete_token(&self, token_id: &str) -> Result<()>;
122
123 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>>;
125
126 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()>;
128
129 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>>;
131
132 async fn delete_session(&self, session_id: &str) -> Result<()>;
134
135 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>>;
137
138 async fn count_active_sessions(&self) -> Result<u64>;
140
141 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()>;
143
144 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>>;
146
147 async fn delete_kv(&self, key: &str) -> Result<()>;
149
150 async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
156 tracing::warn!(
157 "list_kv_keys called on a storage backend that does not override it — returning empty"
158 );
159 Ok(Vec::new())
160 }
161
162 async fn cleanup_expired(&self) -> Result<()>;
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
192pub struct SessionData {
193 pub session_id: String,
195
196 pub user_id: String,
198
199 pub created_at: chrono::DateTime<chrono::Utc>,
201
202 pub expires_at: chrono::DateTime<chrono::Utc>,
204
205 pub last_activity: chrono::DateTime<chrono::Utc>,
207
208 pub ip_address: Option<String>,
210
211 pub user_agent: Option<String>,
213
214 pub data: HashMap<String, serde_json::Value>,
216}
217
218#[derive(Debug, Clone)]
233pub struct MemoryStorage {
234 inner: crate::storage::dashmap_memory::DashMapMemoryStorage,
236 roles: Arc<RwLock<HashMap<String, crate::authorization::AbacRole>>>,
238 user_roles: Arc<RwLock<Vec<crate::authorization::UserRole>>>,
239}
240
241#[cfg(feature = "redis-storage")]
243#[derive(Debug, Clone)]
244pub struct RedisStorage {
245 client: redis::Client,
246 key_prefix: String,
247}
248
249impl Default for MemoryStorage {
250 fn default() -> Self {
251 Self::new()
252 }
253}
254
255impl MemoryStorage {
256 pub fn new() -> Self {
258 Self {
259 inner: crate::storage::dashmap_memory::DashMapMemoryStorage::new(),
260 roles: Arc::new(RwLock::new(HashMap::new())),
261 user_roles: Arc::new(RwLock::new(Vec::new())),
262 }
263 }
264}
265#[async_trait::async_trait]
267impl crate::authorization::AuthorizationStorage for MemoryStorage {
268 async fn store_role(&self, role: &crate::authorization::AbacRole) -> crate::errors::Result<()> {
269 let mut roles = self.roles.write().map_err(|_| {
270 crate::errors::AuthError::internal(
271 "Lock poisoned — a prior thread panicked while holding this lock",
272 )
273 })?;
274 roles.insert(role.id.clone(), role.clone());
275 Ok(())
276 }
277
278 async fn get_role(
279 &self,
280 role_id: &str,
281 ) -> crate::errors::Result<Option<crate::authorization::AbacRole>> {
282 let roles = self.roles.read().map_err(|_| {
283 crate::errors::AuthError::internal(
284 "Lock poisoned — a prior thread panicked while holding this lock",
285 )
286 })?;
287 Ok(roles.get(role_id).cloned())
288 }
289
290 async fn update_role(
291 &self,
292 role: &crate::authorization::AbacRole,
293 ) -> crate::errors::Result<()> {
294 let mut roles = self.roles.write().map_err(|_| {
295 crate::errors::AuthError::internal(
296 "Lock poisoned — a prior thread panicked while holding this lock",
297 )
298 })?;
299 roles.insert(role.id.clone(), role.clone());
300 Ok(())
301 }
302
303 async fn delete_role(&self, role_id: &str) -> crate::errors::Result<()> {
304 let mut roles = self.roles.write().map_err(|_| {
305 crate::errors::AuthError::internal(
306 "Lock poisoned — a prior thread panicked while holding this lock",
307 )
308 })?;
309 roles.remove(role_id);
310 Ok(())
311 }
312
313 async fn list_roles(&self) -> crate::errors::Result<Vec<crate::authorization::AbacRole>> {
314 let roles = self.roles.read().map_err(|_| {
315 crate::errors::AuthError::internal(
316 "Lock poisoned — a prior thread panicked while holding this lock",
317 )
318 })?;
319 Ok(roles.values().cloned().collect())
320 }
321
322 async fn assign_role(
323 &self,
324 user_role: &crate::authorization::UserRole,
325 ) -> crate::errors::Result<()> {
326 let mut user_roles = self.user_roles.write().map_err(|_| {
327 crate::errors::AuthError::internal(
328 "Lock poisoned — a prior thread panicked while holding this lock",
329 )
330 })?;
331 user_roles.push(user_role.clone());
332 Ok(())
333 }
334
335 async fn remove_role(&self, user_id: &str, role_id: &str) -> crate::errors::Result<()> {
336 let mut user_roles = self.user_roles.write().map_err(|_| {
337 crate::errors::AuthError::internal(
338 "Lock poisoned — a prior thread panicked while holding this lock",
339 )
340 })?;
341 user_roles.retain(|ur| ur.user_id != user_id || ur.role_id != role_id);
342 Ok(())
343 }
344
345 async fn get_user_roles(
346 &self,
347 user_id: &str,
348 ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
349 let user_roles = self.user_roles.read().map_err(|_| {
350 crate::errors::AuthError::internal(
351 "Lock poisoned — a prior thread panicked while holding this lock",
352 )
353 })?;
354 Ok(user_roles
355 .iter()
356 .filter(|ur| ur.user_id == user_id)
357 .cloned()
358 .collect())
359 }
360
361 async fn get_role_users(
362 &self,
363 role_id: &str,
364 ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
365 let user_roles = self.user_roles.read().map_err(|_| {
366 crate::errors::AuthError::internal(
367 "Lock poisoned — a prior thread panicked while holding this lock",
368 )
369 })?;
370 Ok(user_roles
371 .iter()
372 .filter(|ur| ur.role_id == role_id)
373 .cloned()
374 .collect())
375 }
376}
377
378#[async_trait]
379impl AuthStorage for MemoryStorage {
380 async fn store_token(&self, token: &AuthToken) -> Result<()> {
381 self.inner.store_token(token).await
383 }
384
385 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
386 self.inner.get_token(token_id).await
388 }
389
390 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
391 self.inner.get_token_by_access_token(access_token).await
393 }
394
395 async fn update_token(&self, token: &AuthToken) -> Result<()> {
396 self.inner.update_token(token).await
398 }
399
400 async fn delete_token(&self, token_id: &str) -> Result<()> {
401 self.inner.delete_token(token_id).await
403 }
404
405 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
406 self.inner.list_user_tokens(user_id).await
408 }
409
410 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
411 self.inner.store_session(session_id, data).await
413 }
414
415 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
416 self.inner.get_session(session_id).await
418 }
419
420 async fn delete_session(&self, session_id: &str) -> Result<()> {
421 self.inner.delete_session(session_id).await
423 }
424
425 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
426 self.inner.list_user_sessions(user_id).await
428 }
429
430 async fn count_active_sessions(&self) -> Result<u64> {
431 self.inner.count_active_sessions().await
433 }
434
435 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
436 self.inner.store_kv(key, value, ttl).await
438 }
439
440 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
441 self.inner.get_kv(key).await
443 }
444
445 async fn delete_kv(&self, key: &str) -> Result<()> {
446 self.inner.delete_kv(key).await
448 }
449
450 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
451 Ok(self.inner.list_kv_keys_by_prefix(prefix))
452 }
453
454 async fn cleanup_expired(&self) -> Result<()> {
455 self.inner.cleanup_expired().await
457 }
458}
459
460#[cfg(feature = "redis-storage")]
461impl RedisStorage {
462 pub fn new(redis_url: &str, key_prefix: impl Into<String>) -> Result<Self> {
464 let client = redis::Client::open(redis_url).map_err(|e| {
465 StorageError::connection_failed(format!("Redis connection failed: {e}"))
466 })?;
467
468 Ok(Self {
469 client,
470 key_prefix: key_prefix.into(),
471 })
472 }
473
474 async fn get_connection(&self) -> Result<redis::aio::MultiplexedConnection> {
476 self.client
477 .get_multiplexed_async_connection()
478 .await
479 .map_err(|e| {
480 StorageError::connection_failed(format!("Failed to get Redis connection: {e}"))
481 .into()
482 })
483 }
484
485 fn key(&self, suffix: &str) -> String {
487 format!("{}{}", self.key_prefix, suffix)
488 }
489
490 fn access_mapping_key(&self, access_token: &str) -> String {
494 self.key(&format!(
495 "access_token_h:{}",
496 crate::storage::key_names::digest("access_token", access_token)
497 ))
498 }
499
500 fn legacy_access_mapping_key(&self, access_token: &str) -> String {
502 self.key(&format!("access_token:{access_token}"))
503 }
504
505 fn session_key(&self, session_id: &str) -> String {
507 self.key(&format!(
508 "session_h:{}",
509 crate::storage::key_names::digest("session", session_id)
510 ))
511 }
512
513 fn legacy_session_key(&self, session_id: &str) -> String {
515 self.key(&format!("session:{session_id}"))
516 }
517
518 async fn session_keys(
524 &self,
525 conn: &mut redis::aio::MultiplexedConnection,
526 ) -> Result<Vec<String>> {
527 let mut keys = Vec::new();
528 for pattern in [self.key("session_h:*"), self.key("session:*")] {
529 let found: Vec<String> = redis::cmd("KEYS")
530 .arg(&pattern)
531 .query_async(&mut *conn)
532 .await
533 .map_err(|e| {
534 StorageError::operation_failed(format!("Failed to scan sessions: {e}"))
535 })?;
536 keys.extend(found);
537 }
538 Ok(keys)
539 }
540
541 async fn get_migrating(&self, new_key: &str, legacy_key: &str) -> Result<Option<String>> {
545 let mut conn = self.get_connection().await?;
546 let value: Option<String> = redis::cmd("GET")
549 .arg(new_key)
550 .query_async(&mut conn)
551 .await
552 .map_err(|e| StorageError::operation_failed(format!("Failed to read key: {e}")))?;
553 if value.is_some() {
554 let _ = redis::cmd("DEL")
557 .arg(legacy_key)
558 .query_async::<usize>(&mut conn)
559 .await;
560 return Ok(value);
561 }
562 const MIGRATE: &str = r#"
566 local l = redis.call('GET', KEYS[2])
567 if not l then return redis.call('GET', KEYS[1]) end
568 local v = redis.call('GET', KEYS[1])
569 if v then
570 redis.call('DEL', KEYS[2])
571 return v
572 end
573 local t = redis.call('PTTL', KEYS[2])
574 if t > 0 then
575 redis.call('SET', KEYS[1], l, 'PX', t)
576 elseif t == -1 then
577 redis.call('SET', KEYS[1], l)
578 else
579 return false
580 end
581 redis.call('DEL', KEYS[2])
582 return l
583 "#;
584 match redis::Script::new(MIGRATE)
585 .key(new_key)
586 .key(legacy_key)
587 .invoke_async::<Option<String>>(&mut conn)
588 .await
589 {
590 Ok(value) => Ok(value),
591 Err(script_err) => {
592 tracing::warn!(
596 error = %script_err,
597 "legacy-name migration script failed; serving the row unmigrated"
598 );
599 let legacy: Option<String> = redis::cmd("GET")
600 .arg(legacy_key)
601 .query_async(&mut conn)
602 .await
603 .map_err(|e| {
604 StorageError::operation_failed(format!("Failed to read key: {e}"))
605 })?;
606 Ok(legacy)
607 }
608 }
609 }
610
611 async fn del_legacy(&self, legacy_key: &str) -> Result<()> {
613 let mut conn = self.get_connection().await?;
614 let _: () = redis::cmd("DEL")
615 .arg(legacy_key)
616 .query_async(&mut conn)
617 .await
618 .map_err(|e| {
619 StorageError::operation_failed(format!("Failed to remove legacy key: {e}"))
620 })?;
621 Ok(())
622 }
623}
624
625#[cfg(feature = "redis-storage")]
626#[async_trait]
627impl AuthStorage for RedisStorage {
628 async fn store_token(&self, token: &AuthToken) -> Result<()> {
629 let mut conn = self.get_connection().await?;
630 let token_json = serde_json::to_string(token)
631 .map_err(|e| StorageError::serialization(format!("Token serialization failed: {e}")))?;
632
633 let token_key = self.key(&format!("token:{}", token.token_id));
634 let access_token_key = self.access_mapping_key(&token.access_token);
635 let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
636
637 let ttl = token.time_until_expiry().as_secs().max(1);
639
640 let _: () = redis::cmd("SETEX")
642 .arg(&token_key)
643 .arg(ttl)
644 .arg(&token_json)
645 .query_async(&mut conn)
646 .await
647 .map_err(|e| StorageError::operation_failed(format!("Failed to store token: {e}")))?;
648
649 let _: () = redis::cmd("SETEX")
651 .arg(&access_token_key)
652 .arg(ttl)
653 .arg(&token.token_id)
654 .query_async(&mut conn)
655 .await
656 .map_err(|e| {
657 StorageError::operation_failed(format!("Failed to store access token mapping: {e}"))
658 })?;
659
660 self.del_legacy(&self.legacy_access_mapping_key(&token.access_token))
662 .await?;
663
664 let _: () = redis::cmd("SADD")
666 .arg(&user_tokens_key)
667 .arg(&token.token_id)
668 .query_async(&mut conn)
669 .await
670 .map_err(|e| {
671 StorageError::operation_failed(format!("Failed to add token to user set: {e}"))
672 })?;
673
674 Ok(())
675 }
676
677 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
678 let mut conn = self.get_connection().await?;
679 let token_key = self.key(&format!("token:{token_id}"));
680
681 let token_json: Option<String> = redis::cmd("GET")
682 .arg(&token_key)
683 .query_async(&mut conn)
684 .await
685 .map_err(|e| StorageError::operation_failed(format!("Failed to get token: {e}")))?;
686
687 if let Some(json) = token_json {
688 let token: AuthToken = serde_json::from_str(&json).map_err(|e| {
689 StorageError::serialization(format!("Token deserialization failed: {e}"))
690 })?;
691 Ok(Some(token))
692 } else {
693 Ok(None)
694 }
695 }
696
697 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
698 let token_id = self
699 .get_migrating(
700 &self.access_mapping_key(access_token),
701 &self.legacy_access_mapping_key(access_token),
702 )
703 .await?;
704
705 if let Some(token_id) = token_id {
706 self.get_token(&token_id).await
707 } else {
708 Ok(None)
709 }
710 }
711
712 async fn update_token(&self, token: &AuthToken) -> Result<()> {
713 self.store_token(token).await
715 }
716
717 async fn delete_token(&self, token_id: &str) -> Result<()> {
718 let mut conn = self.get_connection().await?;
719
720 if let Some(token) = self.get_token(token_id).await? {
722 let token_key = self.key(&format!("token:{token_id}"));
723 let access_token_key = self.access_mapping_key(&token.access_token);
724 let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
725 self.del_legacy(&self.legacy_access_mapping_key(&token.access_token))
726 .await?;
727
728 let _: () = redis::cmd("DEL")
730 .arg(&token_key)
731 .query_async(&mut conn)
732 .await
733 .map_err(|e| {
734 StorageError::operation_failed(format!("Failed to delete token: {e}"))
735 })?;
736
737 let _: () = redis::cmd("DEL")
739 .arg(&access_token_key)
740 .query_async(&mut conn)
741 .await
742 .map_err(|e| {
743 StorageError::operation_failed(format!(
744 "Failed to delete access token mapping: {e}"
745 ))
746 })?;
747
748 let _: () = redis::cmd("SREM")
750 .arg(&user_tokens_key)
751 .arg(token_id)
752 .query_async(&mut conn)
753 .await
754 .map_err(|e| {
755 StorageError::operation_failed(format!(
756 "Failed to remove token from user set: {e}"
757 ))
758 })?;
759 }
760
761 Ok(())
762 }
763
764 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
765 let mut conn = self.get_connection().await?;
766 let user_tokens_key = self.key(&format!("user_tokens:{user_id}"));
767
768 let token_ids: Vec<String> = redis::cmd("SMEMBERS")
769 .arg(&user_tokens_key)
770 .query_async(&mut conn)
771 .await
772 .map_err(|e| {
773 StorageError::operation_failed(format!("Failed to get user tokens: {e}"))
774 })?;
775
776 let mut tokens = Vec::new();
777 for token_id in token_ids {
778 if let Some(token) = self.get_token(&token_id).await? {
779 tokens.push(token);
780 }
781 }
782
783 Ok(tokens)
784 }
785
786 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
787 let mut conn = self.get_connection().await?;
788 let session_key = self.session_key(session_id);
789
790 let session_json = serde_json::to_string(data).map_err(|e| {
791 StorageError::serialization(format!("Session serialization failed: {e}"))
792 })?;
793
794 let ttl = (data.expires_at - chrono::Utc::now()).num_seconds().max(1);
795
796 let _: () = redis::cmd("SETEX")
797 .arg(&session_key)
798 .arg(ttl)
799 .arg(&session_json)
800 .query_async(&mut conn)
801 .await
802 .map_err(|e| StorageError::operation_failed(format!("Failed to store session: {e}")))?;
803
804 self.del_legacy(&self.legacy_session_key(session_id))
806 .await?;
807
808 Ok(())
809 }
810
811 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
812 let session_json = self
813 .get_migrating(
814 &self.session_key(session_id),
815 &self.legacy_session_key(session_id),
816 )
817 .await?;
818
819 if let Some(json) = session_json {
820 let session: SessionData = serde_json::from_str(&json).map_err(|e| {
821 StorageError::serialization(format!("Session deserialization failed: {e}"))
822 })?;
823 Ok(Some(session))
824 } else {
825 Ok(None)
826 }
827 }
828
829 async fn delete_session(&self, session_id: &str) -> Result<()> {
830 let mut conn = self.get_connection().await?;
831 let session_key = self.session_key(session_id);
832
833 self.del_legacy(&self.legacy_session_key(session_id))
836 .await?;
837 let _: () = redis::cmd("DEL")
838 .arg(&session_key)
839 .query_async(&mut conn)
840 .await
841 .map_err(|e| {
842 StorageError::operation_failed(format!("Failed to delete session: {e}"))
843 })?;
844
845 Ok(())
846 }
847
848 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
849 let mut conn = self.get_connection().await?;
850 let keys = self.session_keys(&mut conn).await?;
851
852 let mut user_sessions = Vec::new();
853 let mut seen = std::collections::HashSet::new();
854
855 let legacy_prefix = self.legacy_session_key("");
857 for key in keys {
858 let session_json = match key.strip_prefix(&legacy_prefix) {
861 Some(session_id) => self
862 .get_migrating(&self.session_key(session_id), &key)
863 .await
864 .ok()
865 .flatten(),
866 None => redis::cmd("GET")
867 .arg(&key)
868 .query_async::<Option<String>>(&mut conn)
869 .await
870 .ok()
871 .flatten(),
872 };
873 if let Some(session_json) = session_json
874 && let Ok(session) = serde_json::from_str::<SessionData>(&session_json)
875 && session.user_id == user_id
876 && !session.is_expired()
877 && seen.insert(session.session_id.clone())
878 {
879 user_sessions.push(session);
880 }
881 }
882
883 Ok(user_sessions)
884 }
885
886 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
887 let mut conn = self.get_connection().await?;
888 let storage_key = self.key(&format!("kv:{key}"));
889
890 if let Some(ttl) = ttl {
891 let _: () = redis::cmd("SETEX")
892 .arg(&storage_key)
893 .arg(ttl.as_secs())
894 .arg(value)
895 .query_async(&mut conn)
896 .await
897 .map_err(|e| {
898 StorageError::operation_failed(format!("Failed to store KV with TTL: {e}"))
899 })?;
900 } else {
901 let _: () = redis::cmd("SET")
902 .arg(&storage_key)
903 .arg(value)
904 .query_async(&mut conn)
905 .await
906 .map_err(|e| StorageError::operation_failed(format!("Failed to store KV: {e}")))?;
907 }
908
909 Ok(())
910 }
911
912 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
913 let mut conn = self.get_connection().await?;
914 let storage_key = self.key(&format!("kv:{key}"));
915
916 let value: Option<Vec<u8>> = redis::cmd("GET")
917 .arg(&storage_key)
918 .query_async(&mut conn)
919 .await
920 .map_err(|e| StorageError::operation_failed(format!("Failed to get KV: {e}")))?;
921
922 Ok(value)
923 }
924
925 async fn delete_kv(&self, key: &str) -> Result<()> {
926 let mut conn = self.get_connection().await?;
927 let storage_key = self.key(&format!("kv:{key}"));
928
929 let _: () = redis::cmd("DEL")
930 .arg(&storage_key)
931 .query_async(&mut conn)
932 .await
933 .map_err(|e| StorageError::operation_failed(format!("Failed to delete KV: {e}")))?;
934
935 Ok(())
936 }
937
938 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
939 let mut conn = self.get_connection().await?;
940 let pattern = self.key(&format!("kv:{prefix}*"));
941 let keys: Vec<String> = redis::cmd("KEYS")
942 .arg(&pattern)
943 .query_async(&mut conn)
944 .await
945 .map_err(|e| StorageError::operation_failed(format!("Failed to list KV keys: {e}")))?;
946
947 Ok(keys
948 .into_iter()
949 .filter_map(|key| key.strip_prefix(&self.key_prefix).map(str::to_string))
950 .filter_map(|key| key.strip_prefix("kv:").map(str::to_string))
951 .collect())
952 }
953
954 async fn cleanup_expired(&self) -> Result<()> {
955 Ok(())
957 }
958
959 async fn count_active_sessions(&self) -> Result<u64> {
960 let mut conn = self.get_connection().await?;
961
962 let keys = self.session_keys(&mut conn).await?;
964 let keys = crate::storage::key_names::without_shadowed_legacy(
966 keys,
967 &self.legacy_session_key(""),
968 &self.key("session_h:"),
969 "session",
970 );
971
972 let mut active_count = 0u64;
974 for key in keys {
975 let ttl: i64 = redis::cmd("TTL")
976 .arg(&key)
977 .query_async(&mut conn)
978 .await
979 .map_err(|e| StorageError::operation_failed(format!("Failed to check TTL: {e}")))?;
980
981 if ttl > 0 || ttl == -1 {
985 active_count += 1;
986 }
987 }
988
989 Ok(active_count)
990 }
991}
992
993impl SessionData {
994 pub fn new(
1007 session_id: impl Into<String>,
1008 user_id: impl Into<String>,
1009 expires_in: Duration,
1010 ) -> Self {
1011 let now = chrono::Utc::now();
1012
1013 Self {
1014 session_id: session_id.into(),
1015 user_id: user_id.into(),
1016 created_at: now,
1017 expires_at: now
1018 + chrono::Duration::from_std(expires_in).unwrap_or(chrono::Duration::hours(1)),
1019 last_activity: now,
1020 ip_address: None,
1021 user_agent: None,
1022 data: HashMap::new(),
1023 }
1024 }
1025
1026 pub fn is_expired(&self) -> bool {
1028 chrono::Utc::now() > self.expires_at
1029 }
1030
1031 pub fn time_until_expiry(&self) -> std::time::Duration {
1036 let remaining = self.expires_at - chrono::Utc::now();
1037 remaining.to_std().unwrap_or(std::time::Duration::ZERO)
1038 }
1039
1040 pub fn is_active(&self) -> bool {
1042 !self.is_expired()
1043 }
1044
1045 pub fn update_activity(&mut self) {
1047 self.last_activity = chrono::Utc::now();
1048 }
1049
1050 pub fn with_metadata(mut self, ip_address: Option<String>, user_agent: Option<String>) -> Self {
1052 self.ip_address = ip_address;
1053 self.user_agent = user_agent;
1054 self
1055 }
1056
1057 pub fn ip_address(mut self, ip: impl Into<String>) -> Self {
1059 self.ip_address = Some(ip.into());
1060 self
1061 }
1062
1063 pub fn user_agent(mut self, ua: impl Into<String>) -> Self {
1065 self.user_agent = Some(ua.into());
1066 self
1067 }
1068
1069 pub fn with_data(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
1071 self.data.insert(key.into(), value);
1072 self
1073 }
1074
1075 pub fn set_data(&mut self, key: impl Into<String>, value: serde_json::Value) {
1077 self.data.insert(key.into(), value);
1078 }
1079
1080 pub fn get_data(&self, key: &str) -> Option<&serde_json::Value> {
1082 self.data.get(key)
1083 }
1084}
1085
1086#[async_trait]
1088impl crate::audit::AuditStorage for MemoryStorage {
1089 async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1090 let json_data = serde_json::to_vec(event).map_err(|e| {
1092 crate::errors::AuthError::internal(format!("Failed to serialize audit event: {}", e))
1093 })?;
1094
1095 let key = format!("audit_event_{}", event.id);
1096 self.store_kv(&key, &json_data, None).await
1097 }
1098
1099 async fn query_events(
1100 &self,
1101 query: &crate::audit::AuditQuery,
1102 ) -> Result<Vec<crate::audit::AuditEvent>> {
1103 let all_keys = self.list_kv_keys("audit_event_").await?;
1105 let mut events = Vec::new();
1106
1107 for key in all_keys {
1108 if let Some(data) = self.get_kv(&key).await?
1109 && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1110 {
1111 let mut include = true;
1113
1114 if let Some(ref time_range) = query.time_range
1115 && (event.timestamp < time_range.start || event.timestamp > time_range.end)
1116 {
1117 include = false;
1118 }
1119
1120 if let Some(ref event_types) = query.event_types
1121 && !event_types.contains(&event.event_type)
1122 {
1123 include = false;
1124 }
1125
1126 if let Some(ref user_id) = query.user_id
1127 && event.user_id.as_ref() != Some(user_id)
1128 {
1129 include = false;
1130 }
1131
1132 if include {
1133 events.push(event);
1134 }
1135 }
1136 }
1137
1138 events.sort_by(|a, b| match query.sort_order {
1140 crate::audit::SortOrder::TimestampAsc => a.timestamp.cmp(&b.timestamp),
1141 crate::audit::SortOrder::TimestampDesc => b.timestamp.cmp(&a.timestamp),
1142 crate::audit::SortOrder::RiskLevelDesc => b.risk_level.cmp(&a.risk_level),
1143 });
1144
1145 if let Some(limit) = query.limit {
1146 events.truncate(limit as usize);
1147 }
1148 Ok(events)
1149 }
1150
1151 async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1152 let key = format!("audit_event_{}", event_id);
1153 if let Some(data) = self.get_kv(&key).await? {
1154 let event = serde_json::from_slice(&data).map_err(|e| {
1155 crate::errors::AuthError::internal(format!(
1156 "Failed to deserialize audit event: {}",
1157 e
1158 ))
1159 })?;
1160 Ok(Some(event))
1161 } else {
1162 Ok(None)
1163 }
1164 }
1165
1166 async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1167 let events = self.query_events(query).await?;
1168 Ok(events.len() as u64)
1169 }
1170
1171 async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1172 let all_keys = self.list_kv_keys("audit_event_").await?;
1173 let mut deleted_count = 0;
1174
1175 for key in all_keys {
1176 if let Some(data) = self.get_kv(&key).await?
1177 && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1178 && event.timestamp < before
1179 {
1180 self.delete_kv(&key).await?;
1181 deleted_count += 1;
1182 }
1183 }
1184
1185 Ok(deleted_count)
1186 }
1187
1188 async fn get_statistics(
1189 &self,
1190 query: &crate::audit::StatsQuery,
1191 ) -> Result<crate::audit::AuditStatistics> {
1192 use std::collections::HashMap;
1193
1194 let audit_query = crate::audit::AuditQuery::builder()
1196 .time_range(query.time_range.start, query.time_range.end)
1197 .sort_order(crate::audit::SortOrder::TimestampAsc)
1198 .build();
1199 let events = self.query_events(&audit_query).await?;
1200 let total_events = events.len() as u64;
1201
1202 let mut event_type_counts: HashMap<String, u64> = HashMap::new();
1203 let mut risk_level_counts: HashMap<String, u64> = HashMap::new();
1204 let mut outcome_counts: HashMap<String, u64> = HashMap::new();
1205
1206 for event in &events {
1207 *event_type_counts
1208 .entry(format!("{:?}", event.event_type))
1209 .or_insert(0) += 1;
1210 *risk_level_counts
1211 .entry(format!("{:?}", event.risk_level))
1212 .or_insert(0) += 1;
1213 *outcome_counts
1214 .entry(format!("{:?}", event.outcome))
1215 .or_insert(0) += 1;
1216 }
1217
1218 Ok(crate::audit::AuditStatistics {
1219 total_events,
1220 event_type_counts,
1221 risk_level_counts,
1222 outcome_counts,
1223 time_series: Vec::new(),
1224 top_users: Vec::new(),
1225 top_ips: Vec::new(),
1226 })
1227 }
1228}
1229
1230impl MemoryStorage {
1231 async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
1233 Ok(self.inner.list_kv_keys_by_prefix(_prefix))
1234 }
1235}
1236
1237#[async_trait]
1239impl crate::audit::AuditStorage for Arc<MemoryStorage> {
1240 async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1241 self.as_ref().store_event(event).await
1242 }
1243
1244 async fn query_events(
1245 &self,
1246 query: &crate::audit::AuditQuery,
1247 ) -> Result<Vec<crate::audit::AuditEvent>> {
1248 self.as_ref().query_events(query).await
1249 }
1250
1251 async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1252 self.as_ref().get_event(event_id).await
1253 }
1254
1255 async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1256 self.as_ref().count_events(query).await
1257 }
1258
1259 async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1260 self.as_ref().delete_old_events(before).await
1261 }
1262
1263 async fn get_statistics(
1264 &self,
1265 query: &crate::audit::StatsQuery,
1266 ) -> Result<crate::audit::AuditStatistics> {
1267 self.as_ref().get_statistics(query).await
1268 }
1269}
1270
1271#[cfg(test)]
1272mod tests {
1273 use super::*;
1274 use crate::tokens::AuthToken;
1275
1276 #[tokio::test]
1279 async fn test_memory_storage() {
1280 let storage = MemoryStorage::new();
1281
1282 let token = AuthToken::new("user123", "token123", Duration::from_secs(3600), "test");
1283
1284 storage.store_token(&token).await.unwrap();
1285
1286 let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1287 assert_eq!(retrieved.user_id, "user123");
1288
1289 let retrieved = storage
1290 .get_token_by_access_token(&token.access_token)
1291 .await
1292 .unwrap()
1293 .unwrap();
1294 assert_eq!(retrieved.token_id, token.token_id);
1295
1296 let user_tokens = storage.list_user_tokens("user123").await.unwrap();
1297 assert_eq!(user_tokens.len(), 1);
1298
1299 storage.delete_token(&token.token_id).await.unwrap();
1300 let retrieved = storage.get_token(&token.token_id).await.unwrap();
1301 assert!(retrieved.is_none());
1302 }
1303
1304 #[tokio::test]
1305 async fn test_token_update() {
1306 let storage = MemoryStorage::new();
1307 let mut token = AuthToken::new("user1", "access_original", Duration::from_secs(3600), "pw");
1308 storage.store_token(&token).await.unwrap();
1309
1310 token.auth_method = "mfa".to_string();
1311 storage.update_token(&token).await.unwrap();
1312
1313 let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1314 assert_eq!(retrieved.auth_method, "mfa");
1315 }
1316
1317 #[tokio::test]
1318 async fn test_token_get_nonexistent() {
1319 let storage = MemoryStorage::new();
1320 let result = storage.get_token("nonexistent").await.unwrap();
1321 assert!(result.is_none());
1322
1323 let result = storage
1324 .get_token_by_access_token("nonexistent")
1325 .await
1326 .unwrap();
1327 assert!(result.is_none());
1328 }
1329
1330 #[tokio::test]
1331 async fn test_list_user_tokens_multiple() {
1332 let storage = MemoryStorage::new();
1333 let t1 = AuthToken::new("user_a", "at1", Duration::from_secs(3600), "pw");
1334 let t2 = AuthToken::new("user_a", "at2", Duration::from_secs(3600), "pw");
1335 let t3 = AuthToken::new("user_b", "at3", Duration::from_secs(3600), "pw");
1336
1337 storage.store_token(&t1).await.unwrap();
1338 storage.store_token(&t2).await.unwrap();
1339 storage.store_token(&t3).await.unwrap();
1340
1341 let user_a_tokens = storage.list_user_tokens("user_a").await.unwrap();
1342 assert_eq!(user_a_tokens.len(), 2);
1343
1344 let user_b_tokens = storage.list_user_tokens("user_b").await.unwrap();
1345 assert_eq!(user_b_tokens.len(), 1);
1346
1347 let empty = storage.list_user_tokens("nobody").await.unwrap();
1348 assert!(empty.is_empty());
1349 }
1350
1351 #[tokio::test]
1352 async fn test_store_tokens_bulk() {
1353 let storage = MemoryStorage::new();
1354 let tokens = vec![
1355 AuthToken::new("u1", "a1", Duration::from_secs(3600), "pw"),
1356 AuthToken::new("u2", "a2", Duration::from_secs(3600), "pw"),
1357 AuthToken::new("u3", "a3", Duration::from_secs(3600), "pw"),
1358 ];
1359 let ids: Vec<String> = tokens.iter().map(|t| t.token_id.clone()).collect();
1360
1361 storage.store_tokens_bulk(&tokens).await.unwrap();
1362
1363 for id in &ids {
1364 assert!(storage.get_token(id).await.unwrap().is_some());
1365 }
1366
1367 storage.delete_tokens_bulk(&ids).await.unwrap();
1368
1369 for id in &ids {
1370 assert!(storage.get_token(id).await.unwrap().is_none());
1371 }
1372 }
1373
1374 #[tokio::test]
1377 async fn test_session_storage() {
1378 let storage = MemoryStorage::new();
1379
1380 let session = SessionData::new("session123", "user123", Duration::from_secs(3600))
1381 .with_metadata(
1382 Some("192.168.1.1".to_string()),
1383 Some("Test Agent".to_string()),
1384 );
1385
1386 storage
1387 .store_session(&session.session_id, &session)
1388 .await
1389 .unwrap();
1390
1391 let retrieved = storage
1392 .get_session(&session.session_id)
1393 .await
1394 .unwrap()
1395 .unwrap();
1396 assert_eq!(retrieved.user_id, "user123");
1397 assert_eq!(retrieved.ip_address, Some("192.168.1.1".to_string()));
1398
1399 storage.delete_session(&session.session_id).await.unwrap();
1400 let retrieved = storage.get_session(&session.session_id).await.unwrap();
1401 assert!(retrieved.is_none());
1402 }
1403
1404 #[tokio::test]
1405 async fn test_session_get_nonexistent() {
1406 let storage = MemoryStorage::new();
1407 let result = storage.get_session("no_such_session").await.unwrap();
1408 assert!(result.is_none());
1409 }
1410
1411 #[tokio::test]
1412 async fn test_list_user_sessions() {
1413 let storage = MemoryStorage::new();
1414
1415 let s1 = SessionData::new("s1", "alice", Duration::from_secs(3600));
1416 let s2 = SessionData::new("s2", "alice", Duration::from_secs(3600));
1417 let s3 = SessionData::new("s3", "bob", Duration::from_secs(3600));
1418
1419 storage.store_session("s1", &s1).await.unwrap();
1420 storage.store_session("s2", &s2).await.unwrap();
1421 storage.store_session("s3", &s3).await.unwrap();
1422
1423 let alice_sessions = storage.list_user_sessions("alice").await.unwrap();
1424 assert_eq!(alice_sessions.len(), 2);
1425
1426 let bob_sessions = storage.list_user_sessions("bob").await.unwrap();
1427 assert_eq!(bob_sessions.len(), 1);
1428 }
1429
1430 #[tokio::test]
1431 async fn test_count_active_sessions() {
1432 let storage = MemoryStorage::new();
1433
1434 let s1 = SessionData::new("cs1", "u1", Duration::from_secs(3600));
1435 let s2 = SessionData::new("cs2", "u2", Duration::from_secs(3600));
1436 storage.store_session("cs1", &s1).await.unwrap();
1437 storage.store_session("cs2", &s2).await.unwrap();
1438
1439 let count = storage.count_active_sessions().await.unwrap();
1440 assert!(count >= 2);
1441 }
1442
1443 #[tokio::test]
1444 async fn test_store_sessions_bulk() {
1445 let storage = MemoryStorage::new();
1446 let sessions = vec![
1447 (
1448 "bs1".to_string(),
1449 SessionData::new("bs1", "u1", Duration::from_secs(3600)),
1450 ),
1451 (
1452 "bs2".to_string(),
1453 SessionData::new("bs2", "u2", Duration::from_secs(3600)),
1454 ),
1455 ];
1456
1457 storage.store_sessions_bulk(&sessions).await.unwrap();
1458 assert!(storage.get_session("bs1").await.unwrap().is_some());
1459 assert!(storage.get_session("bs2").await.unwrap().is_some());
1460
1461 let ids = vec!["bs1".to_string(), "bs2".to_string()];
1462 storage.delete_sessions_bulk(&ids).await.unwrap();
1463 assert!(storage.get_session("bs1").await.unwrap().is_none());
1464 assert!(storage.get_session("bs2").await.unwrap().is_none());
1465 }
1466
1467 #[tokio::test]
1468 async fn test_session_custom_data() {
1469 let storage = MemoryStorage::new();
1470 let mut session = SessionData::new("sd1", "u1", Duration::from_secs(3600));
1471 session.set_data("theme", serde_json::json!("dark"));
1472 session.set_data("lang", serde_json::json!("en"));
1473
1474 storage.store_session("sd1", &session).await.unwrap();
1475
1476 let retrieved = storage.get_session("sd1").await.unwrap().unwrap();
1477 assert_eq!(
1478 retrieved.get_data("theme"),
1479 Some(&serde_json::json!("dark"))
1480 );
1481 assert_eq!(retrieved.get_data("lang"), Some(&serde_json::json!("en")));
1482 assert_eq!(retrieved.get_data("missing"), None);
1483 }
1484
1485 #[tokio::test]
1488 async fn test_kv_storage() {
1489 let storage = MemoryStorage::new();
1490
1491 let key = "test_key";
1492 let value = b"test_value";
1493
1494 storage
1495 .store_kv(key, value, Some(Duration::from_secs(3600)))
1496 .await
1497 .unwrap();
1498
1499 let retrieved = storage.get_kv(key).await.unwrap().unwrap();
1500 assert_eq!(retrieved, value);
1501
1502 storage.delete_kv(key).await.unwrap();
1503 let retrieved = storage.get_kv(key).await.unwrap();
1504 assert!(retrieved.is_none());
1505 }
1506
1507 #[tokio::test]
1508 async fn test_kv_no_ttl() {
1509 let storage = MemoryStorage::new();
1510 storage
1511 .store_kv("persistent", b"forever", None)
1512 .await
1513 .unwrap();
1514
1515 let retrieved = storage.get_kv("persistent").await.unwrap().unwrap();
1516 assert_eq!(retrieved, b"forever");
1517 }
1518
1519 #[tokio::test]
1520 async fn test_kv_overwrite() {
1521 let storage = MemoryStorage::new();
1522 storage
1523 .store_kv("k1", b"v1", Some(Duration::from_secs(3600)))
1524 .await
1525 .unwrap();
1526 storage
1527 .store_kv("k1", b"v2", Some(Duration::from_secs(3600)))
1528 .await
1529 .unwrap();
1530
1531 let retrieved = storage.get_kv("k1").await.unwrap().unwrap();
1532 assert_eq!(retrieved, b"v2");
1533 }
1534
1535 #[tokio::test]
1536 async fn test_kv_get_nonexistent() {
1537 let storage = MemoryStorage::new();
1538 let result = storage.get_kv("no_such_key").await.unwrap();
1539 assert!(result.is_none());
1540 }
1541
1542 #[tokio::test]
1543 async fn test_kv_list_keys_prefix() {
1544 let storage = MemoryStorage::new();
1545 storage
1546 .store_kv("user:1:name", b"alice", None)
1547 .await
1548 .unwrap();
1549 storage
1550 .store_kv("user:1:email", b"alice@x.com", None)
1551 .await
1552 .unwrap();
1553 storage.store_kv("user:2:name", b"bob", None).await.unwrap();
1554 storage
1555 .store_kv("session:abc", b"data", None)
1556 .await
1557 .unwrap();
1558
1559 let user1_keys = storage.list_kv_keys("user:1:").await.unwrap();
1560 assert_eq!(user1_keys.len(), 2);
1561
1562 let all_user_keys = storage.list_kv_keys("user:").await.unwrap();
1563 assert_eq!(all_user_keys.len(), 3);
1564
1565 let session_keys = storage.list_kv_keys("session:").await.unwrap();
1566 assert_eq!(session_keys.len(), 1);
1567
1568 let empty = storage.list_kv_keys("nonexistent:").await.unwrap();
1569 assert!(empty.is_empty());
1570 }
1571
1572 #[tokio::test]
1573 async fn test_kv_binary_data() {
1574 let storage = MemoryStorage::new();
1575 let binary = vec![0u8, 1, 2, 255, 254, 253, 0, 128];
1576 storage.store_kv("binary_key", &binary, None).await.unwrap();
1577
1578 let retrieved = storage.get_kv("binary_key").await.unwrap().unwrap();
1579 assert_eq!(retrieved, binary);
1580 }
1581
1582 #[tokio::test]
1585 async fn test_cleanup_expired() {
1586 let storage = MemoryStorage::new();
1587
1588 storage
1594 .store_kv("expire_me", b"val", Some(Duration::from_secs(0)))
1595 .await
1596 .unwrap();
1597 storage
1598 .store_kv("keep_me", b"val", Some(Duration::from_secs(3600)))
1599 .await
1600 .unwrap();
1601
1602 tokio::time::sleep(Duration::from_millis(10)).await;
1604
1605 storage.cleanup_expired().await.unwrap();
1606
1607 assert!(storage.get_kv("expire_me").await.unwrap().is_none());
1609 assert!(storage.get_kv("keep_me").await.unwrap().is_some());
1610 }
1611
1612 #[tokio::test]
1615 async fn test_session_is_expired() {
1616 let mut session = SessionData::new("exp1", "u1", Duration::from_secs(3600));
1617 assert!(!session.is_expired());
1618
1619 session.expires_at = chrono::Utc::now() - chrono::Duration::seconds(1);
1620 assert!(session.is_expired());
1621 }
1622
1623 #[tokio::test]
1624 async fn test_session_update_activity() {
1625 let mut session = SessionData::new("act1", "u1", Duration::from_secs(3600));
1626 let first_activity = session.last_activity;
1627 session.update_activity();
1629 assert!(session.last_activity >= first_activity);
1630 }
1631
1632 #[tokio::test]
1635 async fn test_token_store_twice_overwrites_primary() {
1636 let storage = MemoryStorage::new();
1637 let token = AuthToken::new("u1", "at1", Duration::from_secs(3600), "pw");
1638 let token_id = token.token_id.clone();
1639
1640 storage.store_token(&token).await.unwrap();
1641 storage.store_token(&token).await.unwrap();
1642
1643 let got = storage.get_token(&token_id).await.unwrap();
1645 assert!(got.is_some());
1646 }
1647
1648 #[tokio::test]
1651 async fn test_delete_nonexistent_token() {
1652 let storage = MemoryStorage::new();
1653 let result = storage.delete_token("nope").await;
1655 assert!(result.is_ok());
1656 }
1657
1658 #[tokio::test]
1659 async fn test_delete_nonexistent_session() {
1660 let storage = MemoryStorage::new();
1661 let result = storage.delete_session("nope").await;
1662 assert!(result.is_ok());
1663 }
1664
1665 #[tokio::test]
1666 async fn test_delete_nonexistent_kv() {
1667 let storage = MemoryStorage::new();
1668 let result = storage.delete_kv("nope").await;
1669 assert!(result.is_ok());
1670 }
1671}