Skip to main content

auth_framework/storage/
dashmap_memory.rs

1use crate::audit::{
2    ActorInfo, AuditEvent, AuditEventType, EventOutcome, RequestMetadata, ResourceInfo, RiskLevel,
3};
4/// DashMap-based storage implementation with deadlock-safe patterns
5///
6/// This implementation replaces RwLock<HashMap> with DashMap to provide:
7/// - Lock-free concurrent access
8/// - Deadlock-free operations
9/// - Better performance under high concurrency
10///
11/// Key safety principles:
12/// 1. Never hold multiple DashMap references simultaneously
13/// 2. Always extract values immediately rather than holding references
14/// 3. Use atomic operations for cross-map updates
15/// 4. Scope all operations to prevent reference leaks
16use crate::errors::Result;
17use crate::storage::core::{AuthStorage, SessionData};
18use crate::tokens::AuthToken;
19use async_trait::async_trait;
20use dashmap::DashMap;
21use std::time::Duration;
22
23/// Wrapper for tokens with expiration tracking
24#[derive(Debug, Clone)]
25struct TimestampedToken {
26    token: AuthToken,
27    created_at: chrono::DateTime<chrono::Utc>,
28    expires_at: Option<chrono::DateTime<chrono::Utc>>,
29}
30
31/// Wrapper for sessions with expiration tracking
32#[derive(Debug, Clone)]
33struct TimestampedSession {
34    session: SessionData,
35    created_at: chrono::DateTime<chrono::Utc>,
36}
37
38/// Wrapper for KV values with expiration
39#[derive(Debug, Clone)]
40struct TimestampedValue {
41    data: Vec<u8>,
42    created_at: chrono::DateTime<chrono::Utc>,
43    expires_at: Option<chrono::DateTime<chrono::Utc>>,
44}
45
46impl TimestampedToken {
47    fn new(token: AuthToken, ttl: Option<Duration>) -> Self {
48        let now = chrono::Utc::now();
49        let expires_at = ttl.map(|d| now + chrono::Duration::from_std(d).unwrap());
50
51        Self {
52            token,
53            created_at: now,
54            expires_at,
55        }
56    }
57
58    fn is_expired(&self) -> bool {
59        self.expires_at
60            .map(|exp| chrono::Utc::now() > exp)
61            .unwrap_or(false)
62    }
63}
64
65impl TimestampedSession {
66    fn new(session: SessionData) -> Self {
67        Self {
68            session,
69            created_at: chrono::Utc::now(),
70        }
71    }
72
73    fn is_expired(&self) -> bool {
74        self.session.is_expired()
75    }
76}
77
78impl TimestampedValue {
79    fn new(data: Vec<u8>, ttl: Option<Duration>) -> Self {
80        let now = chrono::Utc::now();
81        let expires_at = ttl.map(|d| now + chrono::Duration::from_std(d).unwrap());
82
83        Self {
84            data,
85            created_at: now,
86            expires_at,
87        }
88    }
89
90    fn is_expired(&self) -> bool {
91        self.expires_at
92            .map(|exp| chrono::Utc::now() > exp)
93            .unwrap_or(false)
94    }
95}
96
97/// DashMap-based storage with deadlock-safe patterns
98#[derive(Debug, Clone)]
99pub struct DashMapMemoryStorage {
100    // Core storage maps
101    tokens: DashMap<String, TimestampedToken>,
102    sessions: DashMap<String, TimestampedSession>,
103    kv_store: DashMap<String, TimestampedValue>,
104
105    // Index maps for efficient lookups
106    access_token_to_id: DashMap<String, String>,
107    user_to_tokens: DashMap<String, Vec<String>>,
108    user_to_sessions: DashMap<String, Vec<String>>,
109
110    // Configuration
111    default_ttl: Option<Duration>,
112}
113
114impl Default for DashMapMemoryStorage {
115    fn default() -> Self {
116        Self::new()
117    }
118}
119
120impl DashMapMemoryStorage {
121    /// Create a new DashMap-based storage
122    pub fn new() -> Self {
123        Self {
124            tokens: DashMap::new(),
125            sessions: DashMap::new(),
126            kv_store: DashMap::new(),
127            access_token_to_id: DashMap::new(),
128            user_to_tokens: DashMap::new(),
129            user_to_sessions: DashMap::new(),
130            default_ttl: None,
131        }
132    }
133
134    /// Create storage with default TTL for all stored items
135    pub fn with_ttl(ttl: Duration) -> Self {
136        Self {
137            tokens: DashMap::new(),
138            sessions: DashMap::new(),
139            kv_store: DashMap::new(),
140            access_token_to_id: DashMap::new(),
141            user_to_tokens: DashMap::new(),
142            user_to_sessions: DashMap::new(),
143            default_ttl: Some(ttl),
144        }
145    }
146
147    /// Generate audit event for storage operations
148    fn create_audit_event(
149        &self,
150        event_type: AuditEventType,
151        user_id: &str,
152        resource_id: &str,
153        resource_type: &str,
154        outcome: EventOutcome,
155        details_str: Option<&str>,
156    ) -> AuditEvent {
157        let mut details = std::collections::HashMap::new();
158        if let Some(detail) = details_str {
159            details.insert("operation_details".to_string(), detail.to_string());
160        }
161        details.insert("resource_type".to_string(), resource_type.to_string());
162        details.insert("resource_id".to_string(), resource_id.to_string());
163
164        AuditEvent {
165            id: uuid::Uuid::new_v4().to_string(),
166            event_type: event_type.clone(),
167            timestamp: std::time::SystemTime::now(),
168            user_id: Some(user_id.to_string()),
169            session_id: None,
170            outcome,
171            risk_level: match &event_type {
172                AuditEventType::TokenRevoked | AuditEventType::TokenExpired => RiskLevel::Medium,
173                AuditEventType::SuspiciousActivity => RiskLevel::High,
174                _ => RiskLevel::Low,
175            },
176            description: format!(
177                "{:?} operation on {} {}",
178                event_type, resource_type, resource_id
179            ),
180            details,
181            request_metadata: RequestMetadata {
182                ip_address: None,
183                user_agent: None,
184                request_id: None,
185                endpoint: Some("storage".to_string()),
186                http_method: None,
187                geolocation: None,
188                device_info: None,
189            },
190            resource: Some(ResourceInfo {
191                resource_type: resource_type.to_string(),
192                resource_id: resource_id.to_string(),
193                resource_name: None,
194                attributes: std::collections::HashMap::new(),
195            }),
196            actor: ActorInfo {
197                actor_type: "storage_system".to_string(),
198                actor_id: user_id.to_string(),
199                actor_name: Some(user_id.to_string()),
200                roles: vec!["storage_user".to_string()],
201            },
202            correlation_id: None,
203        }
204    }
205
206    /// Log storage operation with lifecycle information
207    async fn log_storage_operation(
208        &self,
209        event_type: AuditEventType,
210        user_id: &str,
211        resource_id: &str,
212        resource_type: &str,
213        created_at: Option<chrono::DateTime<chrono::Utc>>,
214        outcome: EventOutcome,
215    ) {
216        let details = if let Some(created) = created_at {
217            let age = chrono::Utc::now().signed_duration_since(created);
218            format!(
219                "{:?} operation on {} {} (age: {} seconds)",
220                event_type,
221                resource_type,
222                resource_id,
223                age.num_seconds()
224            )
225        } else {
226            format!(
227                "{:?} operation on {} {}",
228                event_type, resource_type, resource_id
229            )
230        };
231
232        let audit_event = self.create_audit_event(
233            event_type,
234            user_id,
235            resource_id,
236            resource_type,
237            outcome,
238            Some(&details),
239        );
240
241        // Log the audit event - in production this would go to the audit logger
242        log::info!(
243            "STORAGE AUDIT: {}",
244            serde_json::to_string(&audit_event).unwrap_or_default()
245        );
246    }
247
248    /// Get storage statistics for audit reporting
249    pub fn get_storage_statistics(&self) -> std::collections::HashMap<String, serde_json::Value> {
250        let mut stats = std::collections::HashMap::new();
251        stats.insert(
252            "total_tokens".to_string(),
253            serde_json::Value::from(self.tokens.len()),
254        );
255        stats.insert(
256            "total_sessions".to_string(),
257            serde_json::Value::from(self.sessions.len()),
258        );
259        stats.insert(
260            "total_kv_pairs".to_string(),
261            serde_json::Value::from(self.kv_store.len()),
262        );
263        stats.insert(
264            "total_users_with_tokens".to_string(),
265            serde_json::Value::from(self.user_to_tokens.len()),
266        );
267        stats.insert(
268            "total_users_with_sessions".to_string(),
269            serde_json::Value::from(self.user_to_sessions.len()),
270        );
271        stats.insert(
272            "timestamp".to_string(),
273            serde_json::Value::from(chrono::Utc::now().to_rfc3339()),
274        );
275        stats
276    }
277
278    /// Audit tokens by age - find old tokens for security review
279    pub fn audit_token_ages(&self) -> Vec<(String, String, i64)> {
280        let mut aged_tokens = Vec::new();
281        let now = chrono::Utc::now();
282
283        for entry in self.tokens.iter() {
284            let age_seconds = now.signed_duration_since(entry.created_at).num_seconds();
285            aged_tokens.push((
286                entry.key().clone(),
287                entry.token.user_id.clone(),
288                age_seconds,
289            ));
290        }
291
292        aged_tokens.sort_by_key(|t| std::cmp::Reverse(t.2)); // Sort by age descending
293        aged_tokens
294    }
295
296    /// Audit sessions by age - find old sessions for security review
297    pub fn audit_session_ages(&self) -> Vec<(String, String, i64)> {
298        let mut aged_sessions = Vec::new();
299        let now = chrono::Utc::now();
300
301        for entry in self.sessions.iter() {
302            let age_seconds = now.signed_duration_since(entry.created_at).num_seconds();
303            aged_sessions.push((
304                entry.key().clone(),
305                entry.session.user_id.clone(),
306                age_seconds,
307            ));
308        }
309
310        aged_sessions.sort_by_key(|t| std::cmp::Reverse(t.2)); // Sort by age descending
311        aged_sessions
312    }
313
314    /// Generate comprehensive audit report
315    pub fn generate_audit_report(&self) -> std::collections::HashMap<String, serde_json::Value> {
316        let mut report = self.get_storage_statistics();
317
318        let token_ages = self.audit_token_ages();
319        let session_ages = self.audit_session_ages();
320
321        // Add age analysis
322        if !token_ages.is_empty() {
323            report.insert(
324                "oldest_token_age_seconds".to_string(),
325                serde_json::Value::from(token_ages[0].2),
326            );
327            report.insert(
328                "tokens_older_than_24h".to_string(),
329                serde_json::Value::from(
330                    token_ages.iter().filter(|(_, _, age)| *age > 86400).count(),
331                ),
332            );
333        }
334
335        if !session_ages.is_empty() {
336            report.insert(
337                "oldest_session_age_seconds".to_string(),
338                serde_json::Value::from(session_ages[0].2),
339            );
340            report.insert(
341                "sessions_older_than_24h".to_string(),
342                serde_json::Value::from(
343                    session_ages
344                        .iter()
345                        .filter(|(_, _, age)| *age > 86400)
346                        .count(),
347                ),
348            );
349        }
350
351        report
352    }
353
354    /// DEADLOCK-SAFE: Add token to user index
355    /// Uses atomic operations to prevent cross-map deadlocks
356    fn add_token_to_user_index(&self, user_id: &str, token_id: &str) {
357        // SAFE: Scoped operation that doesn't hold references across map operations
358        self.user_to_tokens
359            .entry(user_id.to_string())
360            .and_modify(|tokens| tokens.push(token_id.to_string()))
361            .or_insert_with(|| vec![token_id.to_string()]);
362    }
363
364    /// DEADLOCK-SAFE: Remove token from user index
365    fn remove_token_from_user_index(&self, user_id: &str, token_id: &str) {
366        // SAFE: Scoped operation with immediate value extraction
367        if let Some(mut entry) = self.user_to_tokens.get_mut(user_id) {
368            entry.retain(|id| id != token_id);
369            if entry.is_empty() {
370                drop(entry); // Release the entry before removal
371                self.user_to_tokens.remove(user_id);
372            }
373        }
374    }
375
376    /// DEADLOCK-SAFE: Add session to user index
377    fn add_session_to_user_index(&self, user_id: &str, session_id: &str) {
378        self.user_to_sessions
379            .entry(user_id.to_string())
380            .and_modify(|sessions| sessions.push(session_id.to_string()))
381            .or_insert_with(|| vec![session_id.to_string()]);
382    }
383
384    /// DEADLOCK-SAFE: Remove session from user index
385    fn remove_session_from_user_index(&self, user_id: &str, session_id: &str) {
386        if let Some(mut entry) = self.user_to_sessions.get_mut(user_id) {
387            entry.retain(|id| id != session_id);
388            if entry.is_empty() {
389                drop(entry);
390                self.user_to_sessions.remove(user_id);
391            }
392        }
393    }
394
395    /// Return all KV keys that start with `prefix`.
396    pub fn list_kv_keys_by_prefix(&self, prefix: &str) -> Vec<String> {
397        self.kv_store
398            .iter()
399            .filter_map(|entry| {
400                if entry.key().starts_with(prefix) {
401                    Some(entry.key().clone())
402                } else {
403                    None
404                }
405            })
406            .collect()
407    }
408}
409
410#[async_trait]
411impl AuthStorage for DashMapMemoryStorage {
412    async fn store_token(&self, token: &AuthToken) -> Result<()> {
413        let timestamped = TimestampedToken::new(token.clone(), self.default_ttl);
414        let created_at = timestamped.created_at;
415
416        // SAFE: Store in primary map first
417        self.tokens.insert(token.token_id.clone(), timestamped);
418
419        // SAFE: Update access token index (no cross-map references)
420        self.access_token_to_id
421            .insert(token.access_token.clone(), token.token_id.clone());
422
423        // SAFE: Update user index (atomic operation)
424        self.add_token_to_user_index(&token.user_id, &token.token_id);
425
426        // Log storage operation with creation timestamp
427        self.log_storage_operation(
428            AuditEventType::LoginSuccess, // Token storage represents successful authentication
429            &token.user_id,
430            &token.token_id,
431            "token",
432            Some(created_at),
433            EventOutcome::Success,
434        )
435        .await;
436
437        Ok(())
438    }
439
440    async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
441        // SAFE: Immediate value extraction, no reference holding
442        if let Some(timestamped) = self.tokens.get(token_id) {
443            let created_at = timestamped.created_at;
444            let user_id = timestamped.token.user_id.clone();
445
446            if timestamped.is_expired() {
447                drop(timestamped); // Release reference
448                self.tokens.remove(token_id); // Cleanup expired
449
450                // Log expired token access attempt
451                self.log_storage_operation(
452                    AuditEventType::TokenExpired,
453                    &user_id,
454                    token_id,
455                    "token",
456                    Some(created_at),
457                    EventOutcome::Failure,
458                )
459                .await;
460
461                return Ok(None);
462            }
463
464            let token = timestamped.token.clone();
465            drop(timestamped); // Release reference
466
467            // Log successful token access
468            self.log_storage_operation(
469                AuditEventType::LoginSuccess, // Token access represents authentication validation
470                &user_id,
471                token_id,
472                "token",
473                Some(created_at),
474                EventOutcome::Success,
475            )
476            .await;
477
478            Ok(Some(token))
479        } else {
480            Ok(None)
481        }
482    }
483
484    async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
485        // SAFE: Two-step lookup with immediate value extraction
486        if let Some(token_id_entry) = self.access_token_to_id.get(access_token) {
487            let token_id = token_id_entry.clone(); // Extract value immediately
488            drop(token_id_entry); // Release first map reference
489            self.get_token(&token_id).await // Use extracted value
490        } else {
491            Ok(None)
492        }
493    }
494
495    async fn update_token(&self, token: &AuthToken) -> Result<()> {
496        // SAFE: Update is same as store for this implementation
497        self.store_token(token).await
498    }
499
500    async fn delete_token(&self, token_id: &str) -> Result<()> {
501        // SAFE: Extract token info before removal to avoid reference issues
502        let token_info = if let Some(timestamped) = self.tokens.get(token_id) {
503            Some((
504                timestamped.token.user_id.clone(),
505                timestamped.token.access_token.clone(),
506                timestamped.created_at,
507            ))
508        } else {
509            None
510        };
511
512        if let Some((user_id, access_token, created_at)) = token_info {
513            // SAFE: All operations use extracted values, no cross-map references
514            self.tokens.remove(token_id);
515            self.access_token_to_id.remove(&access_token);
516            self.remove_token_from_user_index(&user_id, token_id);
517
518            // Log token deletion with creation timestamp for audit trail
519            self.log_storage_operation(
520                AuditEventType::TokenRevoked,
521                &user_id,
522                token_id,
523                "token",
524                Some(created_at),
525                EventOutcome::Success,
526            )
527            .await;
528        }
529
530        Ok(())
531    }
532
533    async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
534        // SAFE: Extract token IDs first, then lookup individually
535        let token_ids = if let Some(ids) = self.user_to_tokens.get(user_id) {
536            ids.clone() // Immediate extraction
537        } else {
538            return Ok(Vec::new());
539        };
540
541        let mut tokens = Vec::new();
542        let mut expired_tokens = Vec::new();
543
544        // SAFE: Iterate over extracted IDs, no cross-map reference holding
545        for token_id in token_ids {
546            if let Some(timestamped) = self.tokens.get(&token_id) {
547                if timestamped.is_expired() {
548                    expired_tokens.push(token_id);
549                } else {
550                    tokens.push(timestamped.token.clone());
551                }
552            } else {
553                expired_tokens.push(token_id); // Token was removed elsewhere
554            }
555        }
556
557        // SAFE: Cleanup expired tokens (uses extracted IDs)
558        for token_id in expired_tokens {
559            self.delete_token(&token_id).await?;
560        }
561
562        Ok(tokens)
563    }
564
565    async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
566        let timestamped = TimestampedSession::new(data.clone());
567        let created_at = timestamped.created_at;
568
569        // SAFE: Store in primary map first
570        self.sessions.insert(session_id.to_string(), timestamped);
571
572        // SAFE: Update user index (atomic operation)
573        self.add_session_to_user_index(&data.user_id, session_id);
574
575        // Log session storage with creation timestamp
576        self.log_storage_operation(
577            AuditEventType::LoginSuccess, // Session creation represents successful login
578            &data.user_id,
579            session_id,
580            "session",
581            Some(created_at),
582            EventOutcome::Success,
583        )
584        .await;
585
586        Ok(())
587    }
588
589    async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
590        // SAFE: Immediate value extraction
591        if let Some(timestamped) = self.sessions.get(session_id) {
592            let created_at = timestamped.created_at;
593            let user_id = timestamped.session.user_id.clone();
594
595            if timestamped.is_expired() {
596                drop(timestamped);
597                self.sessions.remove(session_id);
598
599                // Log expired session access
600                self.log_storage_operation(
601                    AuditEventType::TokenExpired, // Session expiration
602                    &user_id,
603                    session_id,
604                    "session",
605                    Some(created_at),
606                    EventOutcome::Failure,
607                )
608                .await;
609
610                return Ok(None);
611            }
612
613            let session = timestamped.session.clone();
614            drop(timestamped);
615
616            // Log successful session access
617            self.log_storage_operation(
618                AuditEventType::LoginSuccess, // Session access represents continued authentication
619                &user_id,
620                session_id,
621                "session",
622                Some(created_at),
623                EventOutcome::Success,
624            )
625            .await;
626
627            Ok(Some(session))
628        } else {
629            Ok(None)
630        }
631    }
632
633    async fn delete_session(&self, session_id: &str) -> Result<()> {
634        // SAFE: Extract session info before removal
635        let session_info = if let Some(timestamped) = self.sessions.get(session_id) {
636            Some((timestamped.session.user_id.clone(), timestamped.created_at))
637        } else {
638            None
639        };
640
641        if let Some((user_id, created_at)) = session_info {
642            self.sessions.remove(session_id);
643            self.remove_session_from_user_index(&user_id, session_id);
644
645            // Log session deletion with creation timestamp
646            self.log_storage_operation(
647                AuditEventType::Logout,
648                &user_id,
649                session_id,
650                "session",
651                Some(created_at),
652                EventOutcome::Success,
653            )
654            .await;
655        }
656
657        Ok(())
658    }
659
660    async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
661        // SAFE: Extract session IDs first
662        let session_ids = if let Some(ids) = self.user_to_sessions.get(user_id) {
663            ids.clone()
664        } else {
665            return Ok(Vec::new());
666        };
667
668        let mut sessions = Vec::new();
669        let mut expired_sessions = Vec::new();
670
671        // SAFE: Iterate over extracted IDs
672        for session_id in session_ids {
673            if let Some(timestamped) = self.sessions.get(&session_id) {
674                if timestamped.is_expired() {
675                    expired_sessions.push(session_id);
676                } else {
677                    sessions.push(timestamped.session.clone());
678                }
679            } else {
680                expired_sessions.push(session_id);
681            }
682        }
683
684        // SAFE: Cleanup expired sessions
685        for session_id in expired_sessions {
686            self.delete_session(&session_id).await?;
687        }
688
689        Ok(sessions)
690    }
691
692    async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
693        let timestamped = TimestampedValue::new(value.to_vec(), ttl.or(self.default_ttl));
694        let created_at = timestamped.created_at;
695
696        self.kv_store.insert(key.to_string(), timestamped);
697
698        // Log KV storage operation with creation timestamp
699        self.log_storage_operation(
700            AuditEventType::ConfigurationChanged, // KV operations represent configuration/data changes
701            "system",                             // KV operations are typically system-level
702            key,
703            "kv_pair",
704            Some(created_at),
705            EventOutcome::Success,
706        )
707        .await;
708
709        Ok(())
710    }
711
712    async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
713        // SAFE: Immediate value extraction
714        if let Some(timestamped) = self.kv_store.get(key) {
715            let created_at = timestamped.created_at;
716
717            if timestamped.is_expired() {
718                drop(timestamped);
719                self.kv_store.remove(key);
720
721                // Log expired KV access
722                self.log_storage_operation(
723                    AuditEventType::TokenExpired, // Data expiration
724                    "system",
725                    key,
726                    "kv_pair",
727                    Some(created_at),
728                    EventOutcome::Failure,
729                )
730                .await;
731
732                return Ok(None);
733            }
734
735            let data = timestamped.data.clone();
736            drop(timestamped);
737
738            // Log successful KV access
739            self.log_storage_operation(
740                AuditEventType::ConfigurationChanged, // KV access
741                "system",
742                key,
743                "kv_pair",
744                Some(created_at),
745                EventOutcome::Success,
746            )
747            .await;
748
749            Ok(Some(data))
750        } else {
751            Ok(None)
752        }
753    }
754
755    async fn delete_kv(&self, key: &str) -> Result<()> {
756        // SAFE: Extract creation timestamp before removal
757        let created_at = if let Some(timestamped) = self.kv_store.get(key) {
758            Some(timestamped.created_at)
759        } else {
760            None
761        };
762
763        self.kv_store.remove(key);
764
765        if let Some(created_at) = created_at {
766            // Log KV deletion with creation timestamp
767            self.log_storage_operation(
768                AuditEventType::ConfigurationChanged, // KV deletion
769                "system",
770                key,
771                "kv_pair",
772                Some(created_at),
773                EventOutcome::Success,
774            )
775            .await;
776        }
777
778        Ok(())
779    }
780
781    async fn cleanup_expired(&self) -> Result<()> {
782        // SAFE: Collect expired keys first, then remove them
783        let mut expired_tokens = Vec::new();
784        let mut expired_sessions = Vec::new();
785        let mut expired_kvs = Vec::new();
786
787        // SAFE: Scan for expired items (no cross-map operations)
788        for entry in self.tokens.iter() {
789            if entry.is_expired() {
790                expired_tokens.push(entry.key().clone());
791            }
792        }
793
794        for entry in self.sessions.iter() {
795            if entry.is_expired() {
796                expired_sessions.push(entry.key().clone());
797            }
798        }
799
800        for entry in self.kv_store.iter() {
801            if entry.is_expired() {
802                expired_kvs.push(entry.key().clone());
803            }
804        }
805
806        // SAFE: Remove expired items using extracted keys
807        for token_id in expired_tokens {
808            self.delete_token(&token_id).await?;
809        }
810
811        for session_id in expired_sessions {
812            self.delete_session(&session_id).await?;
813        }
814
815        for key in expired_kvs {
816            self.delete_kv(&key).await?;
817        }
818
819        Ok(())
820    }
821
822    async fn count_active_sessions(&self) -> Result<u64> {
823        let mut count = 0;
824
825        // Count all non-expired sessions
826        for entry in self.sessions.iter() {
827            if !entry.is_expired() {
828                count += 1;
829            }
830        }
831
832        Ok(count)
833    }
834}
835
836#[cfg(test)]
837mod tests {
838    use super::*;
839    use crate::{testing::test_infrastructure::TestEnvironmentGuard, tokens::TokenMetadata};
840    use std::collections::HashMap;
841    use tokio::task::JoinSet;
842
843    #[tokio::test]
844    async fn test_basic_token_operations() {
845        let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-test");
846        let storage = DashMapMemoryStorage::new();
847
848        let token = AuthToken {
849            token_id: "test-token".to_string(),
850            user_id: "test-user".to_string(),
851            access_token: "access-123".to_string(),
852            token_type: Some("bearer".to_string()),
853            subject: Some("test-user".to_string()),
854            issuer: Some("test-issuer".to_string()),
855            refresh_token: None,
856            issued_at: chrono::Utc::now(),
857            expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
858            scopes: vec!["read".to_string()],
859            auth_method: "password".to_string(),
860            client_id: Some("test-client".to_string()),
861            user_profile: None,
862            permissions: vec!["read:data".to_string()],
863            roles: vec!["user".to_string()],
864            metadata: TokenMetadata::default(),
865        };
866
867        // Store token
868        storage.store_token(&token).await.unwrap();
869
870        // Get token by ID
871        let retrieved = storage.get_token("test-token").await.unwrap().unwrap();
872        assert_eq!(retrieved.user_id, "test-user");
873
874        // Get token by access token
875        let retrieved = storage
876            .get_token_by_access_token("access-123")
877            .await
878            .unwrap()
879            .unwrap();
880        assert_eq!(retrieved.token_id, "test-token");
881
882        // List user tokens
883        let user_tokens = storage.list_user_tokens("test-user").await.unwrap();
884        assert_eq!(user_tokens.len(), 1);
885
886        // Delete token
887        storage.delete_token("test-token").await.unwrap();
888        let retrieved = storage.get_token("test-token").await.unwrap();
889        assert!(retrieved.is_none());
890    }
891
892    #[tokio::test]
893    async fn test_session_operations() {
894        let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-session-test");
895        let storage = DashMapMemoryStorage::new();
896
897        let session = SessionData {
898            session_id: "test-session".to_string(),
899            user_id: "test-user".to_string(),
900            created_at: chrono::Utc::now(),
901            last_activity: chrono::Utc::now(),
902            expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
903            ip_address: Some("192.168.1.1".to_string()),
904            user_agent: Some("test-agent".to_string()),
905            data: HashMap::new(),
906        };
907
908        // Store session
909        storage
910            .store_session("test-session", &session)
911            .await
912            .unwrap();
913
914        // Get session
915        let retrieved = storage.get_session("test-session").await.unwrap().unwrap();
916        assert_eq!(retrieved.user_id, "test-user");
917
918        // List user sessions
919        let user_sessions = storage.list_user_sessions("test-user").await.unwrap();
920        assert_eq!(user_sessions.len(), 1);
921
922        // Delete session
923        storage.delete_session("test-session").await.unwrap();
924        let retrieved = storage.get_session("test-session").await.unwrap();
925        assert!(retrieved.is_none());
926    }
927
928    #[tokio::test]
929    async fn test_kv_operations() {
930        let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-kv-test");
931        let storage = DashMapMemoryStorage::new();
932
933        let key = "test-key";
934        let value = b"test-value";
935
936        // Store KV
937        storage
938            .store_kv(key, value, Some(Duration::from_secs(3600)))
939            .await
940            .unwrap();
941
942        // Get KV
943        let retrieved = storage.get_kv(key).await.unwrap().unwrap();
944        assert_eq!(retrieved, value);
945
946        // Delete KV
947        storage.delete_kv(key).await.unwrap();
948        let retrieved = storage.get_kv(key).await.unwrap();
949        assert!(retrieved.is_none());
950    }
951
952    #[tokio::test]
953    async fn test_concurrent_operations_no_deadlock() {
954        let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-concurrent-test");
955        let storage = std::sync::Arc::new(DashMapMemoryStorage::new());
956
957        let mut join_set = JoinSet::new();
958
959        // Spawn multiple tasks doing concurrent operations
960        for i in 0..10 {
961            let storage = storage.clone();
962            join_set.spawn(async move {
963                for j in 0..50 {
964                    let token = AuthToken {
965                        token_id: format!("token-{}-{}", i, j),
966                        user_id: format!("user-{}", i % 3), // Multiple users per task
967                        access_token: format!("access-{}-{}", i, j),
968                        token_type: Some("bearer".to_string()),
969                        subject: Some(format!("user-{}", i % 3)),
970                        issuer: Some("test-issuer".to_string()),
971                        refresh_token: None,
972                        issued_at: chrono::Utc::now(),
973                        expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
974                        scopes: vec!["read".to_string()],
975                        auth_method: "password".to_string(),
976                        client_id: Some("test-client".to_string()),
977                        user_profile: None,
978                        permissions: vec!["read:data".to_string()],
979                        roles: vec!["user".to_string()],
980                        metadata: TokenMetadata::default(),
981                    };
982
983                    // Store token
984                    storage.store_token(&token).await.unwrap();
985
986                    // Immediately list user tokens (tests cross-map operations)
987                    let _user_tokens = storage.list_user_tokens(&token.user_id).await.unwrap();
988
989                    // Get by access token
990                    let _retrieved = storage
991                        .get_token_by_access_token(&token.access_token)
992                        .await
993                        .unwrap();
994                }
995            });
996        }
997
998        // Wait for all tasks to complete (should not deadlock)
999        while join_set.join_next().await.is_some() {}
1000
1001        println!("✅ Concurrent operations test passed - no deadlocks detected!");
1002    }
1003
1004    #[tokio::test]
1005    async fn test_ttl_expiration() {
1006        let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-ttl-test");
1007        let storage = DashMapMemoryStorage::with_ttl(Duration::from_millis(100));
1008
1009        // Store a KV that should expire
1010        storage
1011            .store_kv("expiring-key", b"expiring-value", None)
1012            .await
1013            .unwrap();
1014
1015        // Should be available immediately
1016        let retrieved = storage.get_kv("expiring-key").await.unwrap();
1017        assert!(retrieved.is_some());
1018
1019        // Wait for expiration
1020        tokio::time::sleep(Duration::from_millis(150)).await;
1021
1022        // Should be expired and cleaned up
1023        let retrieved = storage.get_kv("expiring-key").await.unwrap();
1024        assert!(retrieved.is_none());
1025    }
1026
1027    #[tokio::test]
1028    async fn test_cleanup_expired() {
1029        let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-cleanup-test");
1030        let storage = DashMapMemoryStorage::with_ttl(Duration::from_millis(50));
1031
1032        // Store multiple items that will expire
1033        for i in 0..10 {
1034            storage
1035                .store_kv(&format!("key-{}", i), b"value", None)
1036                .await
1037                .unwrap();
1038        }
1039
1040        // Wait for expiration
1041        tokio::time::sleep(Duration::from_millis(100)).await;
1042
1043        // Run cleanup
1044        storage.cleanup_expired().await.unwrap();
1045
1046        // Verify all items are cleaned up
1047        for i in 0..10 {
1048            let retrieved = storage.get_kv(&format!("key-{}", i)).await.unwrap();
1049            assert!(retrieved.is_none());
1050        }
1051    }
1052}