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