prax_query/data_cache/

redis.rs

//! Redis cache backend for distributed caching.
//!
//! > **Status: not yet implemented.** No Redis client is compiled into this
//! > crate, so this backend is a stub that fails loudly instead of silently
//! > succeeding:
//! >
//! > - [`RedisConnection::new`] / [`RedisCache::new`] return an error at
//! >   construction time.
//! > - Every command (`get`, `set`, `del`, `scan`, `mget`, pipeline
//! >   execution, …) returns [`CacheError::Backend`] with a
//! >   "redis backend not available" message.
//!
//! A real implementation — with connection pooling (bb8/deadpool), cluster
//! support, pipelining, Lua scripting, and Pub/Sub invalidation — requires
//! adding a Redis client dependency (e.g. `redis-rs` or `fred`) and is
//! planned for a future release.
//!
//! # Example
//!
//! ```rust,ignore
//! use prax_query::data_cache::redis::{RedisCache, RedisCacheConfig};
//!
//! // Currently returns Err(CacheError::Backend) — the backend is not implemented.
//! let cache = RedisCache::new(RedisCacheConfig {
//!     url: "redis://localhost:6379".to_string(),
//!     pool_size: 10,
//!     ..Default::default()
//! }).await?;
//! ```

use std::time::Duration;

use super::backend::{BackendStats, CacheBackend, CacheError, CacheResult};
use super::invalidation::EntityTag;
use super::key::{CacheKey, KeyPattern};

/// Error returned by every Redis operation: no Redis client is compiled in.
fn unavailable() -> CacheError {
    CacheError::Backend("redis backend not available: no redis client compiled in".to_string())
}

/// Configuration for Redis cache.
#[derive(Debug, Clone)]
pub struct RedisCacheConfig {
    /// Redis connection URL.
    pub url: String,
    /// Connection pool size.
    pub pool_size: u32,
    /// Connection timeout.
    pub connection_timeout: Duration,
    /// Command timeout.
    pub command_timeout: Duration,
    /// Key prefix for all entries.
    pub key_prefix: String,
    /// Default TTL.
    pub default_ttl: Option<Duration>,
    /// Enable cluster mode.
    pub cluster_mode: bool,
    /// Database number (0-15).
    pub database: u8,
    /// Enable TLS.
    pub tls: bool,
    /// Username for AUTH.
    pub username: Option<String>,
    /// Password for AUTH.
    pub password: Option<String>,
}

impl Default for RedisCacheConfig {
    fn default() -> Self {
        Self {
            url: "redis://localhost:6379".to_string(),
            pool_size: 10,
            connection_timeout: Duration::from_secs(5),
            command_timeout: Duration::from_secs(2),
            key_prefix: "prax:cache".to_string(),
            default_ttl: Some(Duration::from_secs(300)),
            cluster_mode: false,
            database: 0,
            tls: false,
            username: None,
            password: None,
        }
    }
}

impl RedisCacheConfig {
    /// Create a new config with the given URL.
    pub fn new(url: impl Into<String>) -> Self {
        Self {
            url: url.into(),
            ..Default::default()
        }
    }

    /// Set pool size.
    pub fn with_pool_size(mut self, size: u32) -> Self {
        self.pool_size = size;
        self
    }

    /// Set key prefix.
    pub fn with_prefix(mut self, prefix: impl Into<String>) -> Self {
        self.key_prefix = prefix.into();
        self
    }

    /// Set default TTL.
    pub fn with_ttl(mut self, ttl: Duration) -> Self {
        self.default_ttl = Some(ttl);
        self
    }

    /// Enable cluster mode.
    pub fn cluster(mut self) -> Self {
        self.cluster_mode = true;
        self
    }

    /// Set database number.
    pub fn database(mut self, db: u8) -> Self {
        self.database = db;
        self
    }

    /// Set authentication.
    pub fn auth(mut self, username: Option<String>, password: impl Into<String>) -> Self {
        self.username = username;
        self.password = Some(password.into());
        self
    }

    /// Build the full key with prefix.
    fn full_key(&self, key: &CacheKey) -> String {
        format!("{}:{}", self.key_prefix, key.as_str())
    }
}

/// Represents a Redis connection (placeholder for actual implementation).
///
/// **Not yet implemented:** no Redis client is compiled in. Construction via
/// [`RedisConnection::new`] fails, and every command returns
/// [`CacheError::Backend`]. A real implementation would use the `redis-rs`
/// or `fred` crate.
#[derive(Clone)]
pub struct RedisConnection {
    config: RedisCacheConfig,
    // In real impl: pool: Pool<RedisConnectionManager>
}

impl RedisConnection {
    /// Create a new connection.
    ///
    /// **Not yet implemented:** always returns [`CacheError::Backend`] —
    /// no Redis client is compiled in. A real implementation would create a
    /// connection pool (bb8/deadpool), establish initial connections, and
    /// verify connectivity.
    pub async fn new(config: RedisCacheConfig) -> CacheResult<Self> {
        let _ = config;
        Err(unavailable())
    }

    /// Get the config.
    pub fn config(&self) -> &RedisCacheConfig {
        &self.config
    }

    /// Execute a Redis command (not implemented — always errors).
    async fn execute<T>(&self, _cmd: &str, _args: &[&str]) -> CacheResult<T>
    where
        T: Default,
    {
        // Not implemented: no redis client compiled in.
        // Example with redis-rs:
        // let mut conn = self.pool.get().await?;
        // redis::cmd(cmd).arg(args).query_async(&mut *conn).await
        Err(unavailable())
    }

    /// GET command (not implemented — always errors).
    pub async fn get(&self, key: &str) -> CacheResult<Option<Vec<u8>>> {
        let _ = key;
        Err(unavailable())
    }

    /// SET command with optional TTL (not implemented — always errors).
    pub async fn set(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> CacheResult<()> {
        let _ = (key, value, ttl);
        Err(unavailable())
    }

    /// DEL command (not implemented — always errors).
    pub async fn del(&self, key: &str) -> CacheResult<bool> {
        let _ = key;
        Err(unavailable())
    }

    /// EXISTS command (not implemented — always errors).
    pub async fn exists(&self, key: &str) -> CacheResult<bool> {
        let _ = key;
        Err(unavailable())
    }

    /// KEYS command (not implemented — always errors; a real impl would use SCAN in production).
    pub async fn keys(&self, pattern: &str) -> CacheResult<Vec<String>> {
        let _ = pattern;
        Err(unavailable())
    }

    /// MGET command (not implemented — always errors).
    pub async fn mget(&self, keys: &[String]) -> CacheResult<Vec<Option<Vec<u8>>>> {
        let _ = keys;
        Err(unavailable())
    }

    /// MSET command (not implemented — always errors).
    pub async fn mset(&self, pairs: &[(String, Vec<u8>)]) -> CacheResult<()> {
        let _ = pairs;
        Err(unavailable())
    }

    /// FLUSHDB command (not implemented — always errors).
    pub async fn flush(&self) -> CacheResult<()> {
        Err(unavailable())
    }

    /// DBSIZE command (not implemented — always errors).
    pub async fn dbsize(&self) -> CacheResult<usize> {
        Err(unavailable())
    }

    /// INFO command (not implemented — always errors).
    pub async fn info(&self) -> CacheResult<String> {
        Err(unavailable())
    }

    /// SCAN for pattern matching (not implemented — always errors).
    pub async fn scan(&self, pattern: &str, count: usize) -> CacheResult<Vec<String>> {
        let _ = (pattern, count);
        Err(unavailable())
    }

    /// Pipeline multiple commands.
    pub fn pipeline(&self) -> RedisPipeline {
        RedisPipeline::new(self.clone())
    }
}

/// A Redis pipeline for batching commands.
pub struct RedisPipeline {
    conn: RedisConnection,
    commands: Vec<PipelineCommand>,
}

enum PipelineCommand {
    Get(String),
    Set(String, Vec<u8>, Option<Duration>),
    Del(String),
}

impl RedisPipeline {
    fn new(conn: RedisConnection) -> Self {
        Self {
            conn,
            commands: Vec::new(),
        }
    }

    /// Add a GET command.
    pub fn get(mut self, key: impl Into<String>) -> Self {
        self.commands.push(PipelineCommand::Get(key.into()));
        self
    }

    /// Add a SET command.
    pub fn set(mut self, key: impl Into<String>, value: Vec<u8>, ttl: Option<Duration>) -> Self {
        self.commands
            .push(PipelineCommand::Set(key.into(), value, ttl));
        self
    }

    /// Add a DEL command.
    pub fn del(mut self, key: impl Into<String>) -> Self {
        self.commands.push(PipelineCommand::Del(key.into()));
        self
    }

    /// Execute the pipeline (not implemented — always errors).
    pub async fn execute(self) -> CacheResult<Vec<PipelineResult>> {
        // Not implemented: no redis client compiled in.
        Err(unavailable())
    }
}

/// Result of a pipeline command.
#[derive(Debug, Clone)]
pub enum PipelineResult {
    Ok,
    Value(Option<Vec<u8>>),
    Error(String),
}

/// Redis cache backend.
///
/// **Not yet implemented:** [`RedisCache::new`] fails at construction and
/// every [`CacheBackend`] operation returns [`CacheError::Backend`] — nothing
/// is ever silently stored, read, or invalidated. See the module-level docs.
#[derive(Clone)]
pub struct RedisCache {
    conn: RedisConnection,
    config: RedisCacheConfig,
}

impl RedisCache {
    /// Create a new Redis cache.
    ///
    /// **Not yet implemented:** always returns [`CacheError::Backend`] —
    /// no Redis client is compiled in.
    pub async fn new(config: RedisCacheConfig) -> CacheResult<Self> {
        let conn = RedisConnection::new(config.clone()).await?;
        Ok(Self { conn, config })
    }

    /// Create from a URL.
    ///
    /// **Not yet implemented:** always returns [`CacheError::Backend`].
    pub async fn from_url(url: &str) -> CacheResult<Self> {
        Self::new(RedisCacheConfig::new(url)).await
    }

    /// Get the connection.
    pub fn connection(&self) -> &RedisConnection {
        &self.conn
    }

    /// Get the config.
    pub fn config(&self) -> &RedisCacheConfig {
        &self.config
    }

    /// Build the full key with prefix.
    fn full_key(&self, key: &CacheKey) -> String {
        self.config.full_key(key)
    }
}

impl CacheBackend for RedisCache {
    async fn get<T>(&self, key: &CacheKey) -> CacheResult<Option<T>>
    where
        T: serde::de::DeserializeOwned,
    {
        let full_key = self.full_key(key);

        match self.conn.get(&full_key).await? {
            Some(data) => {
                let value: T = serde_json::from_slice(&data)
                    .map_err(|e| CacheError::Deserialization(e.to_string()))?;
                Ok(Some(value))
            }
            None => Ok(None),
        }
    }

    async fn set<T>(&self, key: &CacheKey, value: &T, ttl: Option<Duration>) -> CacheResult<()>
    where
        T: serde::Serialize + Sync,
    {
        let full_key = self.full_key(key);
        let data =
            serde_json::to_vec(value).map_err(|e| CacheError::Serialization(e.to_string()))?;

        let effective_ttl = ttl.or(self.config.default_ttl);
        self.conn.set(&full_key, &data, effective_ttl).await
    }

    async fn delete(&self, key: &CacheKey) -> CacheResult<bool> {
        let full_key = self.full_key(key);
        self.conn.del(&full_key).await
    }

    async fn exists(&self, key: &CacheKey) -> CacheResult<bool> {
        let full_key = self.full_key(key);
        self.conn.exists(&full_key).await
    }

    async fn get_many<T>(&self, keys: &[CacheKey]) -> CacheResult<Vec<Option<T>>>
    where
        T: serde::de::DeserializeOwned,
    {
        let full_keys: Vec<String> = keys.iter().map(|k| self.full_key(k)).collect();
        let results = self.conn.mget(&full_keys).await?;

        results
            .into_iter()
            .map(|opt| {
                opt.map(|data| {
                    serde_json::from_slice(&data)
                        .map_err(|e| CacheError::Deserialization(e.to_string()))
                })
                .transpose()
            })
            .collect()
    }

    async fn invalidate_pattern(&self, pattern: &KeyPattern) -> CacheResult<u64> {
        let full_pattern = format!("{}:{}", self.config.key_prefix, pattern.to_redis_pattern());

        // Use SCAN to find matching keys
        let keys = self.conn.scan(&full_pattern, 1000).await?;

        if keys.is_empty() {
            return Ok(0);
        }

        // Delete in batches
        let mut deleted = 0u64;
        for key in keys {
            if self.conn.del(&key).await? {
                deleted += 1;
            }
        }

        Ok(deleted)
    }

    async fn invalidate_tags(&self, tags: &[EntityTag]) -> CacheResult<u64> {
        // Not implemented: no redis client compiled in.
        // Real impl: tags stored as sets (tag:<tag_value> -> [key1, ...]);
        // SMEMBERS to get keys, then DEL.
        let _ = tags;
        Err(unavailable())
    }

    async fn clear(&self) -> CacheResult<()> {
        // In production, use SCAN + DEL with prefix
        // FLUSHDB would clear everything
        self.conn.flush().await
    }

    async fn len(&self) -> CacheResult<usize> {
        self.conn.dbsize().await
    }

    async fn stats(&self) -> CacheResult<BackendStats> {
        let info = self.conn.info().await?;
        let entries = self.conn.dbsize().await?;

        Ok(BackendStats {
            entries,
            memory_bytes: None, // Parse from INFO
            connections: Some(self.config.pool_size as usize),
            info: Some(info),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_redis_config() {
        let config = RedisCacheConfig::new("redis://localhost:6379")
            .with_pool_size(20)
            .with_prefix("myapp")
            .with_ttl(Duration::from_secs(600));

        assert_eq!(config.pool_size, 20);
        assert_eq!(config.key_prefix, "myapp");
        assert_eq!(config.default_ttl, Some(Duration::from_secs(600)));
    }

    #[test]
    fn test_full_key() {
        let config = RedisCacheConfig::new("redis://localhost").with_prefix("app:cache");

        let key = CacheKey::new("User", "id:123");
        let full = config.full_key(&key);

        assert_eq!(full, "app:cache:prax:User:id:123");
    }

    #[tokio::test]
    async fn test_redis_cache_creation() {
        // The Redis backend is not implemented: construction fails and every
        // operation errors instead of silently succeeding. Real integration
        // tests would need a Redis instance and a compiled-in client.
        let config = RedisCacheConfig::default();

        let err = RedisCache::new(config.clone())
            .await
            .err()
            .expect("redis construction should fail: no client compiled in");
        match &err {
            CacheError::Backend(msg) => assert!(msg.contains("not available")),
            other => panic!("expected backend error, got {other:?}"),
        }

        // Build directly (same-module access to private fields) to verify a
        // constructed instance also errors loudly on use.
        let conn = RedisConnection {
            config: config.clone(),
        };
        let cache = RedisCache { conn, config };

        assert_eq!(cache.config().pool_size, 10);

        let key = CacheKey::new("test", "key");
        assert!(cache.set(&key, &"value", None).await.is_err());
        let value: CacheResult<Option<String>> = cache.get(&key).await;
        assert!(value.is_err());
    }
}