pleme_redis/

cache.rs

//! General-purpose caching with TTL
//!
//! Features:
//! - Set/get/delete cached values
//! - Product-scoped keys (multi-tenant safe)
//! - JSON serialization support
//! - TTL-based expiration
//!
//! Uses ConnectionManager for efficient multiplexed connections.
//! See `.claude/skills/connection-pooling-architecture` for patterns.

use redis::aio::ConnectionManager;
use redis::{AsyncCommands, Client};
use serde::{de::DeserializeOwned, Serialize};
use tokio::sync::OnceCell;
use uuid::Uuid;

use crate::error::{RedisError, Result};
use crate::RedisConfig;

/// Cache manager for general-purpose caching
///
/// Uses ConnectionManager for multiplexed connections instead of creating
/// a new connection per operation. This provides:
/// - Automatic reconnection on failure
/// - Efficient connection reuse
/// - No pool configuration complexity
#[derive(Clone)]
pub struct CacheManager {
    client: Client,
    cache_ttl_seconds: u64,
    /// Lazily initialized multiplexed connection
    conn: OnceCell<ConnectionManager>,
}

impl CacheManager {
    /// Create a new cache manager
    pub fn new(config: &RedisConfig) -> Result<Self> {
        let client = Client::open(config.url.as_str())
            .map_err(|e| RedisError::Connection(format!("Failed to create Redis client: {}", e)))?;

        Ok(Self {
            client,
            cache_ttl_seconds: config.cache_ttl_seconds,
            conn: OnceCell::new(),
        })
    }

    /// Get multiplexed Redis connection (lazy initialized)
    ///
    /// ConnectionManager provides:
    /// - Single multiplexed connection for all operations
    /// - Automatic reconnection on failure
    /// - Cheaply cloneable (Arc-based internally)
    async fn get_connection(&self) -> Result<ConnectionManager> {
        let conn = self.conn.get_or_try_init(|| async {
            self.client
                .get_connection_manager()
                .await
                .map_err(|e| RedisError::Connection(format!("Failed to get Redis connection manager: {}", e)))
        }).await?;

        Ok(conn.clone())
    }

    /// Set a string value in cache
    pub async fn set_string(&self, key: &str, value: &str) -> Result<()> {
        let mut conn = self.get_connection().await?;

        conn.set_ex::<_, _, ()>(key, value, self.cache_ttl_seconds)
            .await
            .map_err(|e| RedisError::Operation(format!("Failed to set cache: {}", e)))?;

        Ok(())
    }

    /// Get a string value from cache
    pub async fn get_string(&self, key: &str) -> Result<Option<String>> {
        let mut conn = self.get_connection().await?;

        let value: Option<String> = conn
            .get(key)
            .await
            .map_err(|e| RedisError::Operation(format!("Failed to get cache: {}", e)))?;

        Ok(value)
    }

    /// Set a JSON-serializable value in cache
    pub async fn set_json<T: Serialize>(&self, key: &str, value: &T) -> Result<()> {
        let json = serde_json::to_string(value)?;
        self.set_string(key, &json).await
    }

    /// Get a JSON-deserializable value from cache
    pub async fn get_json<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>> {
        match self.get_string(key).await? {
            Some(json) => {
                let value = serde_json::from_str(&json)?;
                Ok(Some(value))
            }
            None => Ok(None),
        }
    }

    /// Delete a cached value
    pub async fn delete(&self, key: &str) -> Result<()> {
        let mut conn = self.get_connection().await?;

        conn.del::<_, ()>(key)
            .await
            .map_err(|e| RedisError::Operation(format!("Failed to delete cache: {}", e)))?;

        Ok(())
    }

    /// Delete multiple cached values
    pub async fn delete_many(&self, keys: &[&str]) -> Result<()> {
        if keys.is_empty() {
            return Ok(());
        }

        let mut conn = self.get_connection().await?;

        conn.del::<_, ()>(keys)
            .await
            .map_err(|e| RedisError::Operation(format!("Failed to delete caches: {}", e)))?;

        Ok(())
    }

    /// Check if a key exists
    pub async fn exists(&self, key: &str) -> Result<bool> {
        let mut conn = self.get_connection().await?;

        let exists: bool = conn
            .exists(key)
            .await
            .map_err(|e| RedisError::Operation(format!("Failed to check key existence: {}", e)))?;

        Ok(exists)
    }

    /// Set with custom TTL
    pub async fn set_string_with_ttl(&self, key: &str, value: &str, ttl_seconds: u64) -> Result<()> {
        let mut conn = self.get_connection().await?;

        conn.set_ex::<_, _, ()>(key, value, ttl_seconds)
            .await
            .map_err(|e| RedisError::Operation(format!("Failed to set cache with TTL: {}", e)))?;

        Ok(())
    }

    /// Helper: Create product-scoped key
    ///
    /// Example: cache_key("conversations", user_id, "novaskyn") -> "cache:novaskyn:conversations:{user_id}"
    pub fn scoped_key(&self, namespace: &str, id: Uuid, product: &str) -> String {
        format!("cache:{}:{}:{}", product, namespace, id)
    }

    /// Helper: Create simple product-scoped key
    ///
    /// Example: simple_key("config", "novaskyn") -> "cache:novaskyn:config"
    pub fn simple_key(&self, namespace: &str, product: &str) -> String {
        format!("cache:{}:{}", product, namespace)
    }
}

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

    #[test]
    fn test_scoped_key_format() {
        let config = RedisConfig::default();
        let manager = CacheManager::new(&config).unwrap();

        let user_id = Uuid::new_v4();
        let key = manager.scoped_key("conversations", user_id, "novaskyn");
        assert_eq!(key, format!("cache:novaskyn:conversations:{}", user_id));
    }

    #[test]
    fn test_simple_key_format() {
        let config = RedisConfig::default();
        let manager = CacheManager::new(&config).unwrap();

        let key = manager.simple_key("config", "novaskyn");
        assert_eq!(key, "cache:novaskyn:config");
    }

    #[test]
    fn test_product_scoping() {
        let config = RedisConfig::default();
        let manager = CacheManager::new(&config).unwrap();

        let user_id = Uuid::new_v4();
        let key1 = manager.scoped_key("conversations", user_id, "novaskyn");
        let key2 = manager.scoped_key("conversations", user_id, "lilitu");

        assert_ne!(key1, key2);
        assert!(key1.contains("novaskyn"));
        assert!(key2.contains("lilitu"));
    }
}