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