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