Skip to main content

auth_framework/storage/
core.rs

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