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