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