Skip to main content

auth_framework/storage/
core.rs

1//! Storage backends for authentication data.
2
3use 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/// Trait for authentication data storage backends.
15///
16/// All persistence in `AuthFramework` goes through this trait — tokens,
17/// sessions, and arbitrary key-value data.  Implement it to plug in a
18/// custom database while keeping the rest of the framework unchanged.
19///
20/// # Provided Implementations
21///
22/// | Backend | Type | Feature flag |
23/// |---------|------|-------------|
24/// | In-memory (DashMap) | [`MemoryStorage`] | *(always available)* |
25/// | PostgreSQL | [`PostgresStorage`](crate::storage::postgres::PostgresStorage) | `postgres-storage` |
26/// | Redis | [`RedisStorage`] | `redis-storage` |
27/// | SQLite | [`SqliteStorage`](crate::storage::sqlite::SqliteStorage) | `sqlite-storage` |
28/// | Encrypted wrapper | [`EncryptedStorage`](crate::storage::encryption::EncryptedStorage) | *(always available)* |
29///
30/// # Implementing This Trait
31///
32/// Custom storage backends must:
33///
34/// 1. **Be thread-safe** — the trait requires `Send + Sync`.
35/// 2. **Handle concurrent access** — multiple tasks will read/write
36///    simultaneously. Use connection pooling or interior mutability.
37/// 3. **Honour TTL** — [`store_kv`](Self::store_kv) accepts an optional TTL.
38///    Expired entries must not be returned by [`get_kv`](Self::get_kv).
39/// 4. **Override `list_kv_keys`** — the default returns an empty `Vec`.
40///    Analytics, compliance, and RBAC queries depend on real data.
41/// 5. **Implement `cleanup_expired`** — periodically called to prune stale
42///    tokens and sessions.
43///
44/// # Example (skeleton)
45///
46/// ```rust,no_run
47/// use auth_framework::storage::{AuthStorage, SessionData};
48/// use auth_framework::tokens::AuthToken;
49/// use auth_framework::errors::Result;
50/// use async_trait::async_trait;
51/// use std::time::Duration;
52///
53/// struct MyStorage { /* ... */ }
54///
55/// #[async_trait]
56/// impl AuthStorage for MyStorage {
57///     async fn store_token(&self, token: &AuthToken) -> Result<()> { todo!() }
58///     async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> { todo!() }
59///     async fn get_token_by_access_token(&self, _: &str) -> Result<Option<AuthToken>> { todo!() }
60///     async fn update_token(&self, token: &AuthToken) -> Result<()> { todo!() }
61///     async fn delete_token(&self, token_id: &str) -> Result<()> { todo!() }
62///     async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> { todo!() }
63///     async fn store_session(&self, id: &str, data: &SessionData) -> Result<()> { todo!() }
64///     async fn get_session(&self, id: &str) -> Result<Option<SessionData>> { todo!() }
65///     async fn delete_session(&self, id: &str) -> Result<()> { todo!() }
66///     async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> { todo!() }
67///     async fn count_active_sessions(&self) -> Result<u64> { todo!() }
68///     async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> { todo!() }
69///     async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> { todo!() }
70///     async fn delete_kv(&self, key: &str) -> Result<()> { todo!() }
71///     async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> { todo!() }
72///     async fn cleanup_expired(&self) -> Result<()> { todo!() }
73/// }
74/// ```
75#[async_trait]
76pub trait AuthStorage: Send + Sync {
77    /// Bulk store tokens.
78    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    /// Bulk delete tokens by ID.
86    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    /// Bulk store sessions.
94    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    /// Bulk delete sessions by ID.
102    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    /// Store a token.
109    async fn store_token(&self, token: &AuthToken) -> Result<()>;
110
111    /// Retrieve a token by ID.
112    async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>>;
113
114    /// Retrieve a token by access token string.
115    async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>>;
116
117    /// Update a token.
118    async fn update_token(&self, token: &AuthToken) -> Result<()>;
119
120    /// Delete a token.
121    async fn delete_token(&self, token_id: &str) -> Result<()>;
122
123    /// List all tokens for a user.
124    async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>>;
125
126    /// Store session data.
127    async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()>;
128
129    /// Retrieve session data.
130    async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>>;
131
132    /// Delete session data.
133    async fn delete_session(&self, session_id: &str) -> Result<()>;
134
135    /// List all sessions for a user.
136    async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>>;
137
138    /// Count currently active sessions (non-expired)
139    async fn count_active_sessions(&self) -> Result<u64>;
140
141    /// Store arbitrary key-value data with expiration.
142    async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()>;
143
144    /// Store `value` under `key` only if no live entry exists. Returns whether it was stored.
145    ///
146    /// This is a compare-and-set: of several simultaneous callers exactly one gets `true`.
147    /// The default implementation is a `get_kv` followed by `store_kv` and is **not**
148    /// atomic. The memory, SQLite (both crates), PostgreSQL, Redis, unified and encrypted-wrapper
149    /// backends override it with an atomic operation; a custom backend (and the test-only
150    /// `MockStorage`) that does not gives single-use markers no atomicity.
151    async fn store_kv_if_absent(
152        &self,
153        key: &str,
154        value: &[u8],
155        ttl: Option<Duration>,
156    ) -> Result<bool> {
157        if self.get_kv(key).await?.is_some() {
158            return Ok(false);
159        }
160        self.store_kv(key, value, ttl).await?;
161        Ok(true)
162    }
163
164    /// Retrieve arbitrary key-value data.
165    async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>>;
166
167    /// Remaining time-to-live of a key-value entry.
168    ///
169    /// Returns `Ok(None)` when the key is absent, has no expiry, **or the
170    /// backend does not track TTLs** (the default). Callers that must carry
171    /// an entry's lifetime across a copy (backup/restore, migration) use
172    /// this together with [`get_kv`](Self::get_kv); a backend that honours
173    /// the TTL passed to [`store_kv`](Self::store_kv) should override it so
174    /// those entries do not silently become non-expiring. An entry that
175    /// `get_kv` would still return but that expires within the backend's
176    /// time resolution reports `Some(Duration::ZERO)`, never `None`.
177    async fn get_kv_ttl(&self, _key: &str) -> Result<Option<Duration>> {
178        Ok(None)
179    }
180
181    /// Whether [`get_kv_ttl`](Self::get_kv_ttl) reports the TTLs given to
182    /// [`store_kv`](Self::store_kv). `false` (the default) means a TTL is
183    /// invisible to callers, so anything that copies entries (migration,
184    /// backup/restore) cannot preserve expiry. A backend that overrides
185    /// [`get_kv_ttl`](Self::get_kv_ttl) must override this too (return
186    /// `true`), otherwise it is treated as TTL-blind.
187    fn tracks_kv_ttl(&self) -> bool {
188        false
189    }
190
191    /// Whether this storage encrypts KV values at rest itself (i.e. it is,
192    /// or wraps, an [`EncryptedStorage`](crate::storage::encryption::EncryptedStorage)).
193    /// `false` (the default) means values reach the backend as given. A
194    /// wrapper around an `EncryptedStorage` must forward this, or startup
195    /// will wrongly report its values as unencrypted.
196    fn encrypts_kv_at_rest(&self) -> bool {
197        false
198    }
199
200    /// Delete arbitrary key-value data.
201    async fn delete_kv(&self, key: &str) -> Result<()>;
202
203    /// List keys with a specific prefix.
204    ///
205    /// **Important:** All storage backends must override this method to return
206    /// real key data. The default returns an empty `Vec` for backward compatibility
207    /// but will cause analytics, compliance, and RBAC queries to operate on empty data.
208    async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
209        tracing::warn!(
210            "list_kv_keys called on a storage backend that does not override it — returning empty"
211        );
212        Ok(Vec::new())
213    }
214
215    /// Clean up expired data.
216    async fn cleanup_expired(&self) -> Result<()>;
217}
218
219/// Lets a boxed `Arc<dyn AuthStorage>` coming out of the storage factory be
220/// wrapped in [`crate::storage::encryption::EncryptedStorage`] without
221/// downcasting to a concrete backend type first.
222///
223/// Deliberately scoped to the trait-object case only (`Arc<dyn
224/// AuthStorage>`), not a generic `impl<T: AuthStorage + ?Sized> AuthStorage
225/// for Arc<T>`: a generic impl would apply to every `Arc<ConcreteBackend>`
226/// too, and Rust's method resolution prefers an exact-type impl over
227/// autoderef -- so `some_arc.get_session(..)` would resolve to this impl's
228/// `(**self).get_session(..)` indirection instead of calling
229/// `ConcreteBackend::get_session` directly, adding an extra `async_trait`
230/// boxed-future hop to every storage call made through an `Arc<Concrete>`
231/// anywhere in the crate (including benchmarks and tests), not just the
232/// one factory path that actually needs this. Measured: this cost a real
233/// ~20-30% regression on the `session_operations/get_session` benchmark
234/// before being scoped down to `dyn AuthStorage` here.
235#[async_trait]
236impl AuthStorage for Arc<dyn AuthStorage> {
237    async fn store_tokens_bulk(&self, tokens: &[AuthToken]) -> Result<()> {
238        (**self).store_tokens_bulk(tokens).await
239    }
240
241    async fn delete_tokens_bulk(&self, token_ids: &[String]) -> Result<()> {
242        (**self).delete_tokens_bulk(token_ids).await
243    }
244
245    async fn store_sessions_bulk(&self, sessions: &[(String, SessionData)]) -> Result<()> {
246        (**self).store_sessions_bulk(sessions).await
247    }
248
249    async fn delete_sessions_bulk(&self, session_ids: &[String]) -> Result<()> {
250        (**self).delete_sessions_bulk(session_ids).await
251    }
252
253    async fn store_token(&self, token: &AuthToken) -> Result<()> {
254        (**self).store_token(token).await
255    }
256
257    async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
258        (**self).get_token(token_id).await
259    }
260
261    async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
262        (**self).get_token_by_access_token(access_token).await
263    }
264
265    async fn update_token(&self, token: &AuthToken) -> Result<()> {
266        (**self).update_token(token).await
267    }
268
269    async fn delete_token(&self, token_id: &str) -> Result<()> {
270        (**self).delete_token(token_id).await
271    }
272
273    async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
274        (**self).list_user_tokens(user_id).await
275    }
276
277    async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
278        (**self).store_session(session_id, data).await
279    }
280
281    async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
282        (**self).get_session(session_id).await
283    }
284
285    async fn delete_session(&self, session_id: &str) -> Result<()> {
286        (**self).delete_session(session_id).await
287    }
288
289    async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
290        (**self).list_user_sessions(user_id).await
291    }
292
293    async fn count_active_sessions(&self) -> Result<u64> {
294        (**self).count_active_sessions().await
295    }
296
297    async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
298        (**self).store_kv(key, value, ttl).await
299    }
300
301    async fn store_kv_if_absent(
302        &self,
303        key: &str,
304        value: &[u8],
305        ttl: Option<Duration>,
306    ) -> Result<bool> {
307        (**self).store_kv_if_absent(key, value, ttl).await
308    }
309
310    async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
311        (**self).get_kv(key).await
312    }
313
314    async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
315        (**self).get_kv_ttl(key).await
316    }
317
318    fn tracks_kv_ttl(&self) -> bool {
319        (**self).tracks_kv_ttl()
320    }
321
322    async fn delete_kv(&self, key: &str) -> Result<()> {
323        (**self).delete_kv(key).await
324    }
325
326    fn encrypts_kv_at_rest(&self) -> bool {
327        (**self).encrypts_kv_at_rest()
328    }
329
330    async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
331        (**self).list_kv_keys(prefix).await
332    }
333
334    async fn cleanup_expired(&self) -> Result<()> {
335        (**self).cleanup_expired().await
336    }
337}
338
339/// Session data stored in the backend.
340///
341/// All fields are public for serialization flexibility. When constructing
342/// a new session prefer [`SessionData::new`] which initialises timestamps
343/// consistently.
344///
345/// # Chainable construction
346///
347/// ```rust,ignore
348/// let session = SessionData::new("sess-1", "user-1", Duration::from_secs(3600))
349///     .ip_address("127.0.0.1")
350///     .user_agent("Mozilla/5.0")
351///     .with_data("role", json!("admin"));
352/// ```
353///
354/// The older [`SessionData::with_metadata`] helper sets both IP and
355/// user-agent in a single call and remains available.
356///
357/// # Invariants (not enforced at the type level)
358///
359/// * `created_at <= last_activity`
360/// * `created_at < expires_at`
361/// * `last_activity` is updated on every authenticated access.
362/// * `data` may contain arbitrary application-specific key/value pairs
363///   — the framework never reads them.
364#[derive(Debug, Clone, Serialize, Deserialize)]
365pub struct SessionData {
366    /// Session ID
367    pub session_id: String,
368
369    /// User ID associated with this session
370    pub user_id: String,
371
372    /// When the session was created
373    pub created_at: chrono::DateTime<chrono::Utc>,
374
375    /// When the session expires
376    pub expires_at: chrono::DateTime<chrono::Utc>,
377
378    /// Last activity timestamp
379    pub last_activity: chrono::DateTime<chrono::Utc>,
380
381    /// IP address of the session
382    pub ip_address: Option<String>,
383
384    /// User agent
385    pub user_agent: Option<String>,
386
387    /// Custom session data
388    pub data: HashMap<String, serde_json::Value>,
389}
390
391/// In-memory storage implementation (for development/testing only).
392///
393/// # ⚠️ Production Unsuitability
394///
395/// This implementation is NOT recommended for production use:
396/// - **Data Loss**: All stored tokens and sessions are lost on process restart
397/// - **Memory Growth**: No automatic cleanup; memory usage grows unbounded
398/// - **TTL Ignored**: Expiration times are not enforced; expired tokens may be returned
399/// - **Single Instance**: Cannot be used in multi-instance deployments
400/// - **No Persistence**: No option to back up or export data
401///
402/// Use `PostgresStorage`, `RedisStorage`, or `SqliteStorage` for production.
403///
404/// SECURITY UPDATE: Now uses DashMap for deadlock-free concurrent operations
405#[derive(Debug, Clone)]
406pub struct MemoryStorage {
407    // Primary storage using DashMap for deadlock-free operations
408    inner: crate::storage::dashmap_memory::DashMapMemoryStorage,
409    // RBAC storage still uses RwLock for compatibility (lower concurrency requirements)
410    roles: Arc<RwLock<HashMap<String, crate::authorization::AbacRole>>>,
411    user_roles: Arc<RwLock<Vec<crate::authorization::UserRole>>>,
412}
413
414/// Redis storage implementation.
415#[cfg(feature = "redis-storage")]
416#[derive(Debug, Clone)]
417pub struct RedisStorage {
418    client: redis::Client,
419    key_prefix: String,
420}
421
422impl Default for MemoryStorage {
423    fn default() -> Self {
424        Self::new()
425    }
426}
427
428impl MemoryStorage {
429    /// Create a new in-memory storage.
430    pub fn new() -> Self {
431        Self {
432            inner: crate::storage::dashmap_memory::DashMapMemoryStorage::new(),
433            roles: Arc::new(RwLock::new(HashMap::new())),
434            user_roles: Arc::new(RwLock::new(Vec::new())),
435        }
436    }
437}
438// In-memory AuthorizationStorage implementation for RBAC examples
439#[async_trait::async_trait]
440impl crate::authorization::AuthorizationStorage for MemoryStorage {
441    async fn store_role(&self, role: &crate::authorization::AbacRole) -> crate::errors::Result<()> {
442        let mut roles = self.roles.write().map_err(|_| {
443            crate::errors::AuthError::internal(
444                "Lock poisoned — a prior thread panicked while holding this lock",
445            )
446        })?;
447        roles.insert(role.id.clone(), role.clone());
448        Ok(())
449    }
450
451    async fn get_role(
452        &self,
453        role_id: &str,
454    ) -> crate::errors::Result<Option<crate::authorization::AbacRole>> {
455        let roles = self.roles.read().map_err(|_| {
456            crate::errors::AuthError::internal(
457                "Lock poisoned — a prior thread panicked while holding this lock",
458            )
459        })?;
460        Ok(roles.get(role_id).cloned())
461    }
462
463    async fn update_role(
464        &self,
465        role: &crate::authorization::AbacRole,
466    ) -> crate::errors::Result<()> {
467        let mut roles = self.roles.write().map_err(|_| {
468            crate::errors::AuthError::internal(
469                "Lock poisoned — a prior thread panicked while holding this lock",
470            )
471        })?;
472        roles.insert(role.id.clone(), role.clone());
473        Ok(())
474    }
475
476    async fn delete_role(&self, role_id: &str) -> crate::errors::Result<()> {
477        let mut roles = self.roles.write().map_err(|_| {
478            crate::errors::AuthError::internal(
479                "Lock poisoned — a prior thread panicked while holding this lock",
480            )
481        })?;
482        roles.remove(role_id);
483        Ok(())
484    }
485
486    async fn list_roles(&self) -> crate::errors::Result<Vec<crate::authorization::AbacRole>> {
487        let roles = self.roles.read().map_err(|_| {
488            crate::errors::AuthError::internal(
489                "Lock poisoned — a prior thread panicked while holding this lock",
490            )
491        })?;
492        Ok(roles.values().cloned().collect())
493    }
494
495    async fn assign_role(
496        &self,
497        user_role: &crate::authorization::UserRole,
498    ) -> crate::errors::Result<()> {
499        let mut user_roles = self.user_roles.write().map_err(|_| {
500            crate::errors::AuthError::internal(
501                "Lock poisoned — a prior thread panicked while holding this lock",
502            )
503        })?;
504        user_roles.push(user_role.clone());
505        Ok(())
506    }
507
508    async fn remove_role(&self, user_id: &str, role_id: &str) -> crate::errors::Result<()> {
509        let mut user_roles = self.user_roles.write().map_err(|_| {
510            crate::errors::AuthError::internal(
511                "Lock poisoned — a prior thread panicked while holding this lock",
512            )
513        })?;
514        user_roles.retain(|ur| ur.user_id != user_id || ur.role_id != role_id);
515        Ok(())
516    }
517
518    async fn get_user_roles(
519        &self,
520        user_id: &str,
521    ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
522        let user_roles = self.user_roles.read().map_err(|_| {
523            crate::errors::AuthError::internal(
524                "Lock poisoned — a prior thread panicked while holding this lock",
525            )
526        })?;
527        Ok(user_roles
528            .iter()
529            .filter(|ur| ur.user_id == user_id)
530            .cloned()
531            .collect())
532    }
533
534    async fn get_role_users(
535        &self,
536        role_id: &str,
537    ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
538        let user_roles = self.user_roles.read().map_err(|_| {
539            crate::errors::AuthError::internal(
540                "Lock poisoned — a prior thread panicked while holding this lock",
541            )
542        })?;
543        Ok(user_roles
544            .iter()
545            .filter(|ur| ur.role_id == role_id)
546            .cloned()
547            .collect())
548    }
549}
550
551#[async_trait]
552impl AuthStorage for MemoryStorage {
553    async fn store_token(&self, token: &AuthToken) -> Result<()> {
554        // Delegate to DashMap implementation for deadlock-free operations
555        self.inner.store_token(token).await
556    }
557
558    async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
559        // Delegate to DashMap implementation for deadlock-free operations
560        self.inner.get_token(token_id).await
561    }
562
563    async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
564        // Delegate to DashMap implementation for deadlock-free operations
565        self.inner.get_token_by_access_token(access_token).await
566    }
567
568    async fn update_token(&self, token: &AuthToken) -> Result<()> {
569        // Delegate to DashMap implementation for deadlock-free operations
570        self.inner.update_token(token).await
571    }
572
573    async fn delete_token(&self, token_id: &str) -> Result<()> {
574        // Delegate to DashMap implementation for deadlock-free operations
575        self.inner.delete_token(token_id).await
576    }
577
578    async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
579        // Delegate to DashMap implementation for deadlock-free operations
580        self.inner.list_user_tokens(user_id).await
581    }
582
583    async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
584        // Delegate to DashMap implementation for deadlock-free operations
585        self.inner.store_session(session_id, data).await
586    }
587
588    async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
589        // Delegate to DashMap implementation for deadlock-free operations
590        self.inner.get_session(session_id).await
591    }
592
593    async fn delete_session(&self, session_id: &str) -> Result<()> {
594        // Delegate to DashMap implementation for deadlock-free operations
595        self.inner.delete_session(session_id).await
596    }
597
598    async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
599        // Delegate to DashMap implementation for deadlock-free operations
600        self.inner.list_user_sessions(user_id).await
601    }
602
603    async fn count_active_sessions(&self) -> Result<u64> {
604        // Delegate to DashMap implementation for deadlock-free operations
605        self.inner.count_active_sessions().await
606    }
607
608    async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
609        // Delegate to DashMap implementation for deadlock-free operations
610        self.inner.store_kv(key, value, ttl).await
611    }
612
613    async fn store_kv_if_absent(
614        &self,
615        key: &str,
616        value: &[u8],
617        ttl: Option<Duration>,
618    ) -> Result<bool> {
619        self.inner.store_kv_if_absent(key, value, ttl).await
620    }
621
622    async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
623        // Delegate to DashMap implementation for deadlock-free operations
624        self.inner.get_kv(key).await
625    }
626
627    async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
628        self.inner.get_kv_ttl(key).await
629    }
630
631    fn tracks_kv_ttl(&self) -> bool {
632        self.inner.tracks_kv_ttl()
633    }
634
635    async fn delete_kv(&self, key: &str) -> Result<()> {
636        // Delegate to DashMap implementation for deadlock-free operations
637        self.inner.delete_kv(key).await
638    }
639
640    async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
641        Ok(self.inner.list_kv_keys_by_prefix(prefix))
642    }
643
644    async fn cleanup_expired(&self) -> Result<()> {
645        // Delegate to DashMap implementation for deadlock-free operations
646        self.inner.cleanup_expired().await
647    }
648}
649
650#[cfg(feature = "redis-storage")]
651impl RedisStorage {
652    /// Create a new Redis storage.
653    pub fn new(redis_url: &str, key_prefix: impl Into<String>) -> Result<Self> {
654        let client = redis::Client::open(redis_url).map_err(|e| {
655            StorageError::connection_failed(format!("Redis connection failed: {e}"))
656        })?;
657
658        Ok(Self {
659            client,
660            key_prefix: key_prefix.into(),
661        })
662    }
663
664    /// Get a Redis connection.
665    async fn get_connection(&self) -> Result<redis::aio::MultiplexedConnection> {
666        self.client
667            .get_multiplexed_async_connection()
668            .await
669            .map_err(|e| {
670                StorageError::connection_failed(format!("Failed to get Redis connection: {e}"))
671                    .into()
672            })
673    }
674
675    /// Generate a key with the configured prefix.
676    fn key(&self, suffix: &str) -> String {
677        format!("{}{}", self.key_prefix, suffix)
678    }
679}
680
681#[cfg(feature = "redis-storage")]
682#[async_trait]
683impl AuthStorage for RedisStorage {
684    async fn store_token(&self, token: &AuthToken) -> Result<()> {
685        let mut conn = self.get_connection().await?;
686        let token_json = serde_json::to_string(token)
687            .map_err(|e| StorageError::serialization(format!("Token serialization failed: {e}")))?;
688
689        let token_key = self.key(&format!("token:{}", token.token_id));
690        let access_token_key = self.key(&format!("access_token:{}", token.access_token));
691        let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
692
693        // Calculate TTL
694        let ttl = token.time_until_expiry().as_secs().max(1);
695
696        // Store token data
697        let _: () = redis::cmd("SETEX")
698            .arg(&token_key)
699            .arg(ttl)
700            .arg(&token_json)
701            .query_async(&mut conn)
702            .await
703            .map_err(|e| StorageError::operation_failed(format!("Failed to store token: {e}")))?;
704
705        // Store access token mapping
706        let _: () = redis::cmd("SETEX")
707            .arg(&access_token_key)
708            .arg(ttl)
709            .arg(&token.token_id)
710            .query_async(&mut conn)
711            .await
712            .map_err(|e| {
713                StorageError::operation_failed(format!("Failed to store access token mapping: {e}"))
714            })?;
715
716        // Add to user tokens set
717        let _: () = redis::cmd("SADD")
718            .arg(&user_tokens_key)
719            .arg(&token.token_id)
720            .query_async(&mut conn)
721            .await
722            .map_err(|e| {
723                StorageError::operation_failed(format!("Failed to add token to user set: {e}"))
724            })?;
725
726        Ok(())
727    }
728
729    async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
730        let mut conn = self.get_connection().await?;
731        let token_key = self.key(&format!("token:{token_id}"));
732
733        let token_json: Option<String> = redis::cmd("GET")
734            .arg(&token_key)
735            .query_async(&mut conn)
736            .await
737            .map_err(|e| StorageError::operation_failed(format!("Failed to get token: {e}")))?;
738
739        if let Some(json) = token_json {
740            let token: AuthToken = serde_json::from_str(&json).map_err(|e| {
741                StorageError::serialization(format!("Token deserialization failed: {e}"))
742            })?;
743            Ok(Some(token))
744        } else {
745            Ok(None)
746        }
747    }
748
749    async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
750        let mut conn = self.get_connection().await?;
751        let access_token_key = self.key(&format!("access_token:{access_token}"));
752
753        let token_id: Option<String> = redis::cmd("GET")
754            .arg(&access_token_key)
755            .query_async(&mut conn)
756            .await
757            .map_err(|e| {
758                StorageError::operation_failed(format!("Failed to get access token mapping: {e}"))
759            })?;
760
761        if let Some(token_id) = token_id {
762            self.get_token(&token_id).await
763        } else {
764            Ok(None)
765        }
766    }
767
768    async fn update_token(&self, token: &AuthToken) -> Result<()> {
769        // Same as store_token for Redis
770        self.store_token(token).await
771    }
772
773    async fn delete_token(&self, token_id: &str) -> Result<()> {
774        let mut conn = self.get_connection().await?;
775
776        // Get token first to get access token and user ID
777        if let Some(token) = self.get_token(token_id).await? {
778            let token_key = self.key(&format!("token:{token_id}"));
779            let access_token_key = self.key(&format!("access_token:{}", token.access_token));
780            let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
781
782            // Delete token data
783            let _: () = redis::cmd("DEL")
784                .arg(&token_key)
785                .query_async(&mut conn)
786                .await
787                .map_err(|e| {
788                    StorageError::operation_failed(format!("Failed to delete token: {e}"))
789                })?;
790
791            // Delete access token mapping
792            let _: () = redis::cmd("DEL")
793                .arg(&access_token_key)
794                .query_async(&mut conn)
795                .await
796                .map_err(|e| {
797                    StorageError::operation_failed(format!(
798                        "Failed to delete access token mapping: {e}"
799                    ))
800                })?;
801
802            // Remove from user tokens set
803            let _: () = redis::cmd("SREM")
804                .arg(&user_tokens_key)
805                .arg(token_id)
806                .query_async(&mut conn)
807                .await
808                .map_err(|e| {
809                    StorageError::operation_failed(format!(
810                        "Failed to remove token from user set: {e}"
811                    ))
812                })?;
813        }
814
815        Ok(())
816    }
817
818    async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
819        let mut conn = self.get_connection().await?;
820        let user_tokens_key = self.key(&format!("user_tokens:{user_id}"));
821
822        let token_ids: Vec<String> = redis::cmd("SMEMBERS")
823            .arg(&user_tokens_key)
824            .query_async(&mut conn)
825            .await
826            .map_err(|e| {
827                StorageError::operation_failed(format!("Failed to get user tokens: {e}"))
828            })?;
829
830        let mut tokens = Vec::new();
831        for token_id in token_ids {
832            if let Some(token) = self.get_token(&token_id).await? {
833                tokens.push(token);
834            }
835        }
836
837        Ok(tokens)
838    }
839
840    async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
841        let mut conn = self.get_connection().await?;
842        let session_key = self.key(&format!("session:{session_id}"));
843
844        let session_json = serde_json::to_string(data).map_err(|e| {
845            StorageError::serialization(format!("Session serialization failed: {e}"))
846        })?;
847
848        let ttl = (data.expires_at - chrono::Utc::now()).num_seconds().max(1);
849
850        let _: () = redis::cmd("SETEX")
851            .arg(&session_key)
852            .arg(ttl)
853            .arg(&session_json)
854            .query_async(&mut conn)
855            .await
856            .map_err(|e| StorageError::operation_failed(format!("Failed to store session: {e}")))?;
857
858        Ok(())
859    }
860
861    async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
862        let mut conn = self.get_connection().await?;
863        let session_key = self.key(&format!("session:{session_id}"));
864
865        let session_json: Option<String> = redis::cmd("GET")
866            .arg(&session_key)
867            .query_async(&mut conn)
868            .await
869            .map_err(|e| StorageError::operation_failed(format!("Failed to get session: {e}")))?;
870
871        if let Some(json) = session_json {
872            let session: SessionData = serde_json::from_str(&json).map_err(|e| {
873                StorageError::serialization(format!("Session deserialization failed: {e}"))
874            })?;
875            Ok(Some(session))
876        } else {
877            Ok(None)
878        }
879    }
880
881    async fn delete_session(&self, session_id: &str) -> Result<()> {
882        let mut conn = self.get_connection().await?;
883        let session_key = self.key(&format!("session:{session_id}"));
884
885        let _: () = redis::cmd("DEL")
886            .arg(&session_key)
887            .query_async(&mut conn)
888            .await
889            .map_err(|e| {
890                StorageError::operation_failed(format!("Failed to delete session: {e}"))
891            })?;
892
893        Ok(())
894    }
895
896    async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
897        let mut conn = self.get_connection().await?;
898        let pattern = self.key("session:*");
899
900        // Use SCAN to find all session keys
901        let keys: Vec<String> = redis::cmd("KEYS")
902            .arg(&pattern)
903            .query_async(&mut conn)
904            .await
905            .map_err(|e| StorageError::operation_failed(format!("Failed to scan sessions: {e}")))?;
906
907        let mut user_sessions = Vec::new();
908
909        // Check each session to see if it belongs to the user
910        for key in keys {
911            if let Ok(session_json) = redis::cmd("GET")
912                .arg(&key)
913                .query_async::<Option<String>>(&mut conn)
914                .await
915                && let Some(session_json) = session_json
916                && let Ok(session) = serde_json::from_str::<SessionData>(&session_json)
917                && session.user_id == user_id
918                && !session.is_expired()
919            {
920                user_sessions.push(session);
921            }
922        }
923
924        Ok(user_sessions)
925    }
926
927    async fn store_kv_if_absent(
928        &self,
929        key: &str,
930        value: &[u8],
931        ttl: Option<Duration>,
932    ) -> Result<bool> {
933        let mut conn = self.get_connection().await?;
934        let storage_key = self.key(&format!("kv:{key}"));
935        // SET ... NX [PX ms]: atomic; the reply is OK when set and nil when the key exists.
936        let mut cmd = redis::cmd("SET");
937        cmd.arg(&storage_key).arg(value).arg("NX");
938        if let Some(ttl) = ttl {
939            let millis = u64::try_from(ttl.as_millis()).unwrap_or(u64::MAX).max(1);
940            cmd.arg("PX").arg(millis);
941        }
942        let reply: Option<String> = cmd.query_async(&mut conn).await.map_err(|e| {
943            StorageError::operation_failed(format!("Failed to store KV if absent: {e}"))
944        })?;
945        Ok(reply.is_some())
946    }
947
948    async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
949        let mut conn = self.get_connection().await?;
950        let storage_key = self.key(&format!("kv:{key}"));
951
952        if let Some(ttl) = ttl {
953            // PSETEX, not SETEX: a remaining TTL under one second must not
954            // become `SETEX key 0 ...`, which Redis rejects.
955            let millis = u64::try_from(ttl.as_millis()).unwrap_or(u64::MAX).max(1);
956            let _: () = redis::cmd("PSETEX")
957                .arg(&storage_key)
958                .arg(millis)
959                .arg(value)
960                .query_async(&mut conn)
961                .await
962                .map_err(|e| {
963                    StorageError::operation_failed(format!("Failed to store KV with TTL: {e}"))
964                })?;
965        } else {
966            let _: () = redis::cmd("SET")
967                .arg(&storage_key)
968                .arg(value)
969                .query_async(&mut conn)
970                .await
971                .map_err(|e| StorageError::operation_failed(format!("Failed to store KV: {e}")))?;
972        }
973
974        Ok(())
975    }
976
977    async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
978        let mut conn = self.get_connection().await?;
979        let storage_key = self.key(&format!("kv:{key}"));
980
981        let value: Option<Vec<u8>> = redis::cmd("GET")
982            .arg(&storage_key)
983            .query_async(&mut conn)
984            .await
985            .map_err(|e| StorageError::operation_failed(format!("Failed to get KV: {e}")))?;
986
987        Ok(value)
988    }
989
990    async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
991        let mut conn = self.get_connection().await?;
992        let storage_key = self.key(&format!("kv:{key}"));
993
994        // PTTL: -2 = no such key, -1 = no expiry, otherwise milliseconds left.
995        let millis: i64 = redis::cmd("PTTL")
996            .arg(&storage_key)
997            .query_async(&mut conn)
998            .await
999            .map_err(|e| StorageError::operation_failed(format!("Failed to get KV TTL: {e}")))?;
1000
1001        Ok(u64::try_from(millis)
1002            .ok()
1003            .filter(|millis| *millis > 0)
1004            .map(Duration::from_millis))
1005    }
1006
1007    fn tracks_kv_ttl(&self) -> bool {
1008        true
1009    }
1010
1011    async fn delete_kv(&self, key: &str) -> Result<()> {
1012        let mut conn = self.get_connection().await?;
1013        let storage_key = self.key(&format!("kv:{key}"));
1014
1015        let _: () = redis::cmd("DEL")
1016            .arg(&storage_key)
1017            .query_async(&mut conn)
1018            .await
1019            .map_err(|e| StorageError::operation_failed(format!("Failed to delete KV: {e}")))?;
1020
1021        Ok(())
1022    }
1023
1024    async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
1025        let mut conn = self.get_connection().await?;
1026        let pattern = self.key(&format!("kv:{prefix}*"));
1027        let keys: Vec<String> = redis::cmd("KEYS")
1028            .arg(&pattern)
1029            .query_async(&mut conn)
1030            .await
1031            .map_err(|e| StorageError::operation_failed(format!("Failed to list KV keys: {e}")))?;
1032
1033        Ok(keys
1034            .into_iter()
1035            .filter_map(|key| key.strip_prefix(&self.key_prefix).map(str::to_string))
1036            .filter_map(|key| key.strip_prefix("kv:").map(str::to_string))
1037            .collect())
1038    }
1039
1040    async fn cleanup_expired(&self) -> Result<()> {
1041        // Redis handles expiration automatically, so this is a no-op
1042        Ok(())
1043    }
1044
1045    async fn count_active_sessions(&self) -> Result<u64> {
1046        let mut conn = self.get_connection().await?;
1047        let pattern = self.key("session:*");
1048
1049        // Use KEYS to find all session keys (consider SCAN for production with many keys)
1050        let keys: Vec<String> = redis::cmd("KEYS")
1051            .arg(&pattern)
1052            .query_async(&mut conn)
1053            .await
1054            .map_err(|e| StorageError::operation_failed(format!("Failed to scan sessions: {e}")))?;
1055
1056        // Count only non-expired sessions by checking TTL
1057        let mut active_count = 0u64;
1058        for key in keys {
1059            let ttl: i64 = redis::cmd("TTL")
1060                .arg(&key)
1061                .query_async(&mut conn)
1062                .await
1063                .map_err(|e| StorageError::operation_failed(format!("Failed to check TTL: {e}")))?;
1064
1065            // TTL > 0 means key has expiration and is still active
1066            // TTL = -1 means key has no expiration (active)
1067            // TTL = -2 means key doesn't exist (expired)
1068            if ttl > 0 || ttl == -1 {
1069                active_count += 1;
1070            }
1071        }
1072
1073        Ok(active_count)
1074    }
1075}
1076
1077impl SessionData {
1078    /// Create a new session with consistent timestamps.
1079    ///
1080    /// # Arguments
1081    /// * `session_id` - Unique session identifier (typically a UUID)
1082    /// * `user_id` - Associated user ID
1083    /// * `expires_in` - Session lifetime from now
1084    ///
1085    /// Use [`with_metadata`](SessionData::with_metadata) to attach IP and
1086    /// user-agent information after construction.
1087    ///
1088    /// # Panics
1089    /// If `expires_in` conversion to `chrono::Duration` fails catastrophically.
1090    pub fn new(
1091        session_id: impl Into<String>,
1092        user_id: impl Into<String>,
1093        expires_in: Duration,
1094    ) -> Self {
1095        let now = chrono::Utc::now();
1096
1097        Self {
1098            session_id: session_id.into(),
1099            user_id: user_id.into(),
1100            created_at: now,
1101            expires_at: now
1102                + chrono::Duration::from_std(expires_in).unwrap_or(chrono::Duration::hours(1)),
1103            last_activity: now,
1104            ip_address: None,
1105            user_agent: None,
1106            data: HashMap::new(),
1107        }
1108    }
1109
1110    /// Check if the session has expired.
1111    pub fn is_expired(&self) -> bool {
1112        chrono::Utc::now() > self.expires_at
1113    }
1114
1115    /// Return the remaining lifetime of this session.
1116    ///
1117    /// Returns [`Duration::ZERO`](std::time::Duration::ZERO) when the session
1118    /// has already expired.
1119    pub fn time_until_expiry(&self) -> std::time::Duration {
1120        let remaining = self.expires_at - chrono::Utc::now();
1121        remaining.to_std().unwrap_or(std::time::Duration::ZERO)
1122    }
1123
1124    /// Check if the session is still active (not expired).
1125    pub fn is_active(&self) -> bool {
1126        !self.is_expired()
1127    }
1128
1129    /// Update the last activity timestamp.
1130    pub fn update_activity(&mut self) {
1131        self.last_activity = chrono::Utc::now();
1132    }
1133
1134    /// Set session metadata (IP address and user-agent) in one call.
1135    pub fn with_metadata(mut self, ip_address: Option<String>, user_agent: Option<String>) -> Self {
1136        self.ip_address = ip_address;
1137        self.user_agent = user_agent;
1138        self
1139    }
1140
1141    /// Set the client IP address.
1142    pub fn ip_address(mut self, ip: impl Into<String>) -> Self {
1143        self.ip_address = Some(ip.into());
1144        self
1145    }
1146
1147    /// Set the client user-agent string.
1148    pub fn user_agent(mut self, ua: impl Into<String>) -> Self {
1149        self.user_agent = Some(ua.into());
1150        self
1151    }
1152
1153    /// Add a custom data entry (chainable).
1154    pub fn with_data(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
1155        self.data.insert(key.into(), value);
1156        self
1157    }
1158
1159    /// Add custom data to the session.
1160    pub fn set_data(&mut self, key: impl Into<String>, value: serde_json::Value) {
1161        self.data.insert(key.into(), value);
1162    }
1163
1164    /// Get custom data from the session.
1165    pub fn get_data(&self, key: &str) -> Option<&serde_json::Value> {
1166        self.data.get(key)
1167    }
1168}
1169
1170/// Implementation of AuditStorage for MemoryStorage
1171#[async_trait]
1172impl crate::audit::AuditStorage for MemoryStorage {
1173    async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1174        // Store audit event as JSON in KV storage
1175        let json_data = serde_json::to_vec(event).map_err(|e| {
1176            crate::errors::AuthError::internal(format!("Failed to serialize audit event: {}", e))
1177        })?;
1178
1179        let key = format!("audit_event_{}", event.id);
1180        self.store_kv(&key, &json_data, None).await
1181    }
1182
1183    async fn query_events(
1184        &self,
1185        query: &crate::audit::AuditQuery,
1186    ) -> Result<Vec<crate::audit::AuditEvent>> {
1187        // Simple implementation - in production, this would be more efficient
1188        let all_keys = self.list_kv_keys("audit_event_").await?;
1189        let mut events = Vec::new();
1190
1191        for key in all_keys {
1192            if let Some(data) = self.get_kv(&key).await?
1193                && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1194            {
1195                // Apply filters
1196                let mut include = true;
1197
1198                if let Some(ref time_range) = query.time_range
1199                    && (event.timestamp < time_range.start || event.timestamp > time_range.end)
1200                {
1201                    include = false;
1202                }
1203
1204                if let Some(ref event_types) = query.event_types
1205                    && !event_types.contains(&event.event_type)
1206                {
1207                    include = false;
1208                }
1209
1210                if let Some(ref user_id) = query.user_id
1211                    && event.user_id.as_ref() != Some(user_id)
1212                {
1213                    include = false;
1214                }
1215
1216                if include {
1217                    events.push(event);
1218                }
1219            }
1220        }
1221
1222        // Sort and limit
1223        events.sort_by(|a, b| match query.sort_order {
1224            crate::audit::SortOrder::TimestampAsc => a.timestamp.cmp(&b.timestamp),
1225            crate::audit::SortOrder::TimestampDesc => b.timestamp.cmp(&a.timestamp),
1226            crate::audit::SortOrder::RiskLevelDesc => b.risk_level.cmp(&a.risk_level),
1227        });
1228
1229        if let Some(limit) = query.limit {
1230            events.truncate(limit as usize);
1231        }
1232        Ok(events)
1233    }
1234
1235    async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1236        let key = format!("audit_event_{}", event_id);
1237        if let Some(data) = self.get_kv(&key).await? {
1238            let event = serde_json::from_slice(&data).map_err(|e| {
1239                crate::errors::AuthError::internal(format!(
1240                    "Failed to deserialize audit event: {}",
1241                    e
1242                ))
1243            })?;
1244            Ok(Some(event))
1245        } else {
1246            Ok(None)
1247        }
1248    }
1249
1250    async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1251        let events = self.query_events(query).await?;
1252        Ok(events.len() as u64)
1253    }
1254
1255    async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1256        let all_keys = self.list_kv_keys("audit_event_").await?;
1257        let mut deleted_count = 0;
1258
1259        for key in all_keys {
1260            if let Some(data) = self.get_kv(&key).await?
1261                && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1262                && event.timestamp < before
1263            {
1264                self.delete_kv(&key).await?;
1265                deleted_count += 1;
1266            }
1267        }
1268
1269        Ok(deleted_count)
1270    }
1271
1272    async fn get_statistics(
1273        &self,
1274        query: &crate::audit::StatsQuery,
1275    ) -> Result<crate::audit::AuditStatistics> {
1276        use std::collections::HashMap;
1277
1278        // Pull all events matching the time range in the query.
1279        let audit_query = crate::audit::AuditQuery::builder()
1280            .time_range(query.time_range.start, query.time_range.end)
1281            .sort_order(crate::audit::SortOrder::TimestampAsc)
1282            .build();
1283        let events = self.query_events(&audit_query).await?;
1284        let total_events = events.len() as u64;
1285
1286        let mut event_type_counts: HashMap<String, u64> = HashMap::new();
1287        let mut risk_level_counts: HashMap<String, u64> = HashMap::new();
1288        let mut outcome_counts: HashMap<String, u64> = HashMap::new();
1289
1290        for event in &events {
1291            *event_type_counts
1292                .entry(format!("{:?}", event.event_type))
1293                .or_insert(0) += 1;
1294            *risk_level_counts
1295                .entry(format!("{:?}", event.risk_level))
1296                .or_insert(0) += 1;
1297            *outcome_counts
1298                .entry(format!("{:?}", event.outcome))
1299                .or_insert(0) += 1;
1300        }
1301
1302        Ok(crate::audit::AuditStatistics {
1303            total_events,
1304            event_type_counts,
1305            risk_level_counts,
1306            outcome_counts,
1307            time_series: Vec::new(),
1308            top_users: Vec::new(),
1309            top_ips: Vec::new(),
1310        })
1311    }
1312}
1313
1314impl MemoryStorage {
1315    /// Helper method to list KV keys with a prefix
1316    async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
1317        Ok(self.inner.list_kv_keys_by_prefix(_prefix))
1318    }
1319}
1320
1321/// Implementation of AuditStorage for `Arc<MemoryStorage>`
1322#[async_trait]
1323impl crate::audit::AuditStorage for Arc<MemoryStorage> {
1324    async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1325        self.as_ref().store_event(event).await
1326    }
1327
1328    async fn query_events(
1329        &self,
1330        query: &crate::audit::AuditQuery,
1331    ) -> Result<Vec<crate::audit::AuditEvent>> {
1332        self.as_ref().query_events(query).await
1333    }
1334
1335    async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1336        self.as_ref().get_event(event_id).await
1337    }
1338
1339    async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1340        self.as_ref().count_events(query).await
1341    }
1342
1343    async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1344        self.as_ref().delete_old_events(before).await
1345    }
1346
1347    async fn get_statistics(
1348        &self,
1349        query: &crate::audit::StatsQuery,
1350    ) -> Result<crate::audit::AuditStatistics> {
1351        self.as_ref().get_statistics(query).await
1352    }
1353}
1354
1355#[cfg(test)]
1356mod tests {
1357    use super::*;
1358    use crate::tokens::AuthToken;
1359
1360    // ── Token CRUD ──────────────────────────────────────────────────
1361
1362    #[tokio::test]
1363    async fn test_memory_storage() {
1364        let storage = MemoryStorage::new();
1365
1366        let token = AuthToken::new("user123", "token123", Duration::from_secs(3600), "test");
1367
1368        storage.store_token(&token).await.unwrap();
1369
1370        let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1371        assert_eq!(retrieved.user_id, "user123");
1372
1373        let retrieved = storage
1374            .get_token_by_access_token(&token.access_token)
1375            .await
1376            .unwrap()
1377            .unwrap();
1378        assert_eq!(retrieved.token_id, token.token_id);
1379
1380        let user_tokens = storage.list_user_tokens("user123").await.unwrap();
1381        assert_eq!(user_tokens.len(), 1);
1382
1383        storage.delete_token(&token.token_id).await.unwrap();
1384        let retrieved = storage.get_token(&token.token_id).await.unwrap();
1385        assert!(retrieved.is_none());
1386    }
1387
1388    #[tokio::test]
1389    async fn test_token_update() {
1390        let storage = MemoryStorage::new();
1391        let mut token = AuthToken::new("user1", "access_original", Duration::from_secs(3600), "pw");
1392        storage.store_token(&token).await.unwrap();
1393
1394        token.auth_method = "mfa".to_string();
1395        storage.update_token(&token).await.unwrap();
1396
1397        let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1398        assert_eq!(retrieved.auth_method, "mfa");
1399    }
1400
1401    #[tokio::test]
1402    async fn test_token_get_nonexistent() {
1403        let storage = MemoryStorage::new();
1404        let result = storage.get_token("nonexistent").await.unwrap();
1405        assert!(result.is_none());
1406
1407        let result = storage
1408            .get_token_by_access_token("nonexistent")
1409            .await
1410            .unwrap();
1411        assert!(result.is_none());
1412    }
1413
1414    #[tokio::test]
1415    async fn test_list_user_tokens_multiple() {
1416        let storage = MemoryStorage::new();
1417        let t1 = AuthToken::new("user_a", "at1", Duration::from_secs(3600), "pw");
1418        let t2 = AuthToken::new("user_a", "at2", Duration::from_secs(3600), "pw");
1419        let t3 = AuthToken::new("user_b", "at3", Duration::from_secs(3600), "pw");
1420
1421        storage.store_token(&t1).await.unwrap();
1422        storage.store_token(&t2).await.unwrap();
1423        storage.store_token(&t3).await.unwrap();
1424
1425        let user_a_tokens = storage.list_user_tokens("user_a").await.unwrap();
1426        assert_eq!(user_a_tokens.len(), 2);
1427
1428        let user_b_tokens = storage.list_user_tokens("user_b").await.unwrap();
1429        assert_eq!(user_b_tokens.len(), 1);
1430
1431        let empty = storage.list_user_tokens("nobody").await.unwrap();
1432        assert!(empty.is_empty());
1433    }
1434
1435    #[tokio::test]
1436    async fn test_store_tokens_bulk() {
1437        let storage = MemoryStorage::new();
1438        let tokens = vec![
1439            AuthToken::new("u1", "a1", Duration::from_secs(3600), "pw"),
1440            AuthToken::new("u2", "a2", Duration::from_secs(3600), "pw"),
1441            AuthToken::new("u3", "a3", Duration::from_secs(3600), "pw"),
1442        ];
1443        let ids: Vec<String> = tokens.iter().map(|t| t.token_id.clone()).collect();
1444
1445        storage.store_tokens_bulk(&tokens).await.unwrap();
1446
1447        for id in &ids {
1448            assert!(storage.get_token(id).await.unwrap().is_some());
1449        }
1450
1451        storage.delete_tokens_bulk(&ids).await.unwrap();
1452
1453        for id in &ids {
1454            assert!(storage.get_token(id).await.unwrap().is_none());
1455        }
1456    }
1457
1458    // ── Session CRUD ────────────────────────────────────────────────
1459
1460    #[tokio::test]
1461    async fn test_session_storage() {
1462        let storage = MemoryStorage::new();
1463
1464        let session = SessionData::new("session123", "user123", Duration::from_secs(3600))
1465            .with_metadata(
1466                Some("192.168.1.1".to_string()),
1467                Some("Test Agent".to_string()),
1468            );
1469
1470        storage
1471            .store_session(&session.session_id, &session)
1472            .await
1473            .unwrap();
1474
1475        let retrieved = storage
1476            .get_session(&session.session_id)
1477            .await
1478            .unwrap()
1479            .unwrap();
1480        assert_eq!(retrieved.user_id, "user123");
1481        assert_eq!(retrieved.ip_address, Some("192.168.1.1".to_string()));
1482
1483        storage.delete_session(&session.session_id).await.unwrap();
1484        let retrieved = storage.get_session(&session.session_id).await.unwrap();
1485        assert!(retrieved.is_none());
1486    }
1487
1488    #[tokio::test]
1489    async fn test_session_get_nonexistent() {
1490        let storage = MemoryStorage::new();
1491        let result = storage.get_session("no_such_session").await.unwrap();
1492        assert!(result.is_none());
1493    }
1494
1495    #[tokio::test]
1496    async fn test_list_user_sessions() {
1497        let storage = MemoryStorage::new();
1498
1499        let s1 = SessionData::new("s1", "alice", Duration::from_secs(3600));
1500        let s2 = SessionData::new("s2", "alice", Duration::from_secs(3600));
1501        let s3 = SessionData::new("s3", "bob", Duration::from_secs(3600));
1502
1503        storage.store_session("s1", &s1).await.unwrap();
1504        storage.store_session("s2", &s2).await.unwrap();
1505        storage.store_session("s3", &s3).await.unwrap();
1506
1507        let alice_sessions = storage.list_user_sessions("alice").await.unwrap();
1508        assert_eq!(alice_sessions.len(), 2);
1509
1510        let bob_sessions = storage.list_user_sessions("bob").await.unwrap();
1511        assert_eq!(bob_sessions.len(), 1);
1512    }
1513
1514    #[tokio::test]
1515    async fn test_count_active_sessions() {
1516        let storage = MemoryStorage::new();
1517
1518        let s1 = SessionData::new("cs1", "u1", Duration::from_secs(3600));
1519        let s2 = SessionData::new("cs2", "u2", Duration::from_secs(3600));
1520        storage.store_session("cs1", &s1).await.unwrap();
1521        storage.store_session("cs2", &s2).await.unwrap();
1522
1523        let count = storage.count_active_sessions().await.unwrap();
1524        assert!(count >= 2);
1525    }
1526
1527    #[tokio::test]
1528    async fn test_store_sessions_bulk() {
1529        let storage = MemoryStorage::new();
1530        let sessions = vec![
1531            (
1532                "bs1".to_string(),
1533                SessionData::new("bs1", "u1", Duration::from_secs(3600)),
1534            ),
1535            (
1536                "bs2".to_string(),
1537                SessionData::new("bs2", "u2", Duration::from_secs(3600)),
1538            ),
1539        ];
1540
1541        storage.store_sessions_bulk(&sessions).await.unwrap();
1542        assert!(storage.get_session("bs1").await.unwrap().is_some());
1543        assert!(storage.get_session("bs2").await.unwrap().is_some());
1544
1545        let ids = vec!["bs1".to_string(), "bs2".to_string()];
1546        storage.delete_sessions_bulk(&ids).await.unwrap();
1547        assert!(storage.get_session("bs1").await.unwrap().is_none());
1548        assert!(storage.get_session("bs2").await.unwrap().is_none());
1549    }
1550
1551    #[tokio::test]
1552    async fn test_session_custom_data() {
1553        let storage = MemoryStorage::new();
1554        let mut session = SessionData::new("sd1", "u1", Duration::from_secs(3600));
1555        session.set_data("theme", serde_json::json!("dark"));
1556        session.set_data("lang", serde_json::json!("en"));
1557
1558        storage.store_session("sd1", &session).await.unwrap();
1559
1560        let retrieved = storage.get_session("sd1").await.unwrap().unwrap();
1561        assert_eq!(
1562            retrieved.get_data("theme"),
1563            Some(&serde_json::json!("dark"))
1564        );
1565        assert_eq!(retrieved.get_data("lang"), Some(&serde_json::json!("en")));
1566        assert_eq!(retrieved.get_data("missing"), None);
1567    }
1568
1569    // ── KV Storage ──────────────────────────────────────────────────
1570
1571    #[tokio::test]
1572    async fn test_kv_storage() {
1573        let storage = MemoryStorage::new();
1574
1575        let key = "test_key";
1576        let value = b"test_value";
1577
1578        storage
1579            .store_kv(key, value, Some(Duration::from_secs(3600)))
1580            .await
1581            .unwrap();
1582
1583        let retrieved = storage.get_kv(key).await.unwrap().unwrap();
1584        assert_eq!(retrieved, value);
1585
1586        storage.delete_kv(key).await.unwrap();
1587        let retrieved = storage.get_kv(key).await.unwrap();
1588        assert!(retrieved.is_none());
1589    }
1590
1591    #[tokio::test]
1592    async fn test_kv_no_ttl() {
1593        let storage = MemoryStorage::new();
1594        storage
1595            .store_kv("persistent", b"forever", None)
1596            .await
1597            .unwrap();
1598
1599        let retrieved = storage.get_kv("persistent").await.unwrap().unwrap();
1600        assert_eq!(retrieved, b"forever");
1601    }
1602
1603    #[tokio::test]
1604    async fn test_kv_overwrite() {
1605        let storage = MemoryStorage::new();
1606        storage
1607            .store_kv("k1", b"v1", Some(Duration::from_secs(3600)))
1608            .await
1609            .unwrap();
1610        storage
1611            .store_kv("k1", b"v2", Some(Duration::from_secs(3600)))
1612            .await
1613            .unwrap();
1614
1615        let retrieved = storage.get_kv("k1").await.unwrap().unwrap();
1616        assert_eq!(retrieved, b"v2");
1617    }
1618
1619    #[tokio::test]
1620    async fn test_kv_get_nonexistent() {
1621        let storage = MemoryStorage::new();
1622        let result = storage.get_kv("no_such_key").await.unwrap();
1623        assert!(result.is_none());
1624    }
1625
1626    #[tokio::test]
1627    async fn test_kv_list_keys_prefix() {
1628        let storage = MemoryStorage::new();
1629        storage
1630            .store_kv("user:1:name", b"alice", None)
1631            .await
1632            .unwrap();
1633        storage
1634            .store_kv("user:1:email", b"alice@x.com", None)
1635            .await
1636            .unwrap();
1637        storage.store_kv("user:2:name", b"bob", None).await.unwrap();
1638        storage
1639            .store_kv("session:abc", b"data", None)
1640            .await
1641            .unwrap();
1642
1643        let user1_keys = storage.list_kv_keys("user:1:").await.unwrap();
1644        assert_eq!(user1_keys.len(), 2);
1645
1646        let all_user_keys = storage.list_kv_keys("user:").await.unwrap();
1647        assert_eq!(all_user_keys.len(), 3);
1648
1649        let session_keys = storage.list_kv_keys("session:").await.unwrap();
1650        assert_eq!(session_keys.len(), 1);
1651
1652        let empty = storage.list_kv_keys("nonexistent:").await.unwrap();
1653        assert!(empty.is_empty());
1654    }
1655
1656    #[tokio::test]
1657    async fn test_kv_binary_data() {
1658        let storage = MemoryStorage::new();
1659        let binary = vec![0u8, 1, 2, 255, 254, 253, 0, 128];
1660        storage.store_kv("binary_key", &binary, None).await.unwrap();
1661
1662        let retrieved = storage.get_kv("binary_key").await.unwrap().unwrap();
1663        assert_eq!(retrieved, binary);
1664    }
1665
1666    // ── Cleanup ──────────────────────────────────────────────────────
1667
1668    #[tokio::test]
1669    async fn test_cleanup_expired() {
1670        let storage = MemoryStorage::new();
1671
1672        // Store a KV entry with a very short TTL (already expired by the time
1673        // cleanup runs because DashMap wraps its own expiry clock).
1674        // Note: MemoryStorage cleanup uses TimestampedToken's own expires_at
1675        // (derived from default_ttl), NOT AuthToken.expires_at. We test KV
1676        // cleanup because it respects TTLs directly.
1677        storage
1678            .store_kv("expire_me", b"val", Some(Duration::from_secs(0)))
1679            .await
1680            .unwrap();
1681        storage
1682            .store_kv("keep_me", b"val", Some(Duration::from_secs(3600)))
1683            .await
1684            .unwrap();
1685
1686        // Give a tiny window for the zero-TTL entry to register as expired
1687        tokio::time::sleep(Duration::from_millis(10)).await;
1688
1689        storage.cleanup_expired().await.unwrap();
1690
1691        // Zero-TTL entry should be cleaned up, valid entry remains
1692        assert!(storage.get_kv("expire_me").await.unwrap().is_none());
1693        assert!(storage.get_kv("keep_me").await.unwrap().is_some());
1694    }
1695
1696    // ── Session expiration ──────────────────────────────────────────
1697
1698    #[tokio::test]
1699    async fn test_session_is_expired() {
1700        let mut session = SessionData::new("exp1", "u1", Duration::from_secs(3600));
1701        assert!(!session.is_expired());
1702
1703        session.expires_at = chrono::Utc::now() - chrono::Duration::seconds(1);
1704        assert!(session.is_expired());
1705    }
1706
1707    #[tokio::test]
1708    async fn test_session_update_activity() {
1709        let mut session = SessionData::new("act1", "u1", Duration::from_secs(3600));
1710        let first_activity = session.last_activity;
1711        // Small delay to ensure timestamp changes
1712        session.update_activity();
1713        assert!(session.last_activity >= first_activity);
1714    }
1715
1716    // ── Token upsert semantics ──────────────────────────────────────
1717
1718    #[tokio::test]
1719    async fn test_token_store_twice_overwrites_primary() {
1720        let storage = MemoryStorage::new();
1721        let token = AuthToken::new("u1", "at1", Duration::from_secs(3600), "pw");
1722        let token_id = token.token_id.clone();
1723
1724        storage.store_token(&token).await.unwrap();
1725        storage.store_token(&token).await.unwrap();
1726
1727        // Primary DashMap uses insert() so only one entry with this token_id exists.
1728        let got = storage.get_token(&token_id).await.unwrap();
1729        assert!(got.is_some());
1730    }
1731
1732    // ── Delete idempotency ──────────────────────────────────────────
1733
1734    #[tokio::test]
1735    async fn test_delete_nonexistent_token() {
1736        let storage = MemoryStorage::new();
1737        // Deleting a key that doesn't exist should not error
1738        let result = storage.delete_token("nope").await;
1739        assert!(result.is_ok());
1740    }
1741
1742    #[tokio::test]
1743    async fn test_delete_nonexistent_session() {
1744        let storage = MemoryStorage::new();
1745        let result = storage.delete_session("nope").await;
1746        assert!(result.is_ok());
1747    }
1748
1749    #[tokio::test]
1750    async fn test_delete_nonexistent_kv() {
1751        let storage = MemoryStorage::new();
1752        let result = storage.delete_kv("nope").await;
1753        assert!(result.is_ok());
1754    }
1755}