Struct RedisCache 

pub struct RedisCache { /* private fields */ }

Redis / Valkey backed CachePort adapter.

Internally uses a [deadpool_redis::Pool] for connection management. Keys are stored as Redis strings; TTL is enforced via Redis PSETEX.

Example

use stygian_graph::adapters::cache_redis::{RedisCache, RedisCacheConfig};
use stygian_graph::ports::CachePort;

let cache = RedisCache::new(RedisCacheConfig::default())?;
cache.set("k", "v".into(), None).await?;
assert_eq!(cache.get("k").await?, Some("v".into()));

Implementations

impl RedisCache

pub fn new(config: RedisCacheConfig) -> Result<Self>

Create a new RedisCache from the given config.

Returns a CacheError::WriteFailed if the connection pool cannot be created (e.g. the URL is malformed).

Errors

Returns StygianError::Cache if pool creation fails.

Example

use stygian_graph::adapters::cache_redis::{RedisCache, RedisCacheConfig};

let cache = RedisCache::new(RedisCacheConfig::default())?;

pub async fn healthcheck(&self) -> Result<()>

Check connectivity to the Redis backend.

Sends a PING command and expects PONG.

Errors

Returns StygianError::Cache on connection or protocol failure.

Example

let cache = RedisCache::new(RedisCacheConfig::default())?;
cache.healthcheck().await?;

Trait Implementations

impl CachePort for RedisCache

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a value from Redis by key.

Returns Ok(None) on a cache miss and Err on backend failure.

Example

let val = cache.get("mykey").await?;

fn set<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: String, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a value in Redis with optional TTL.

If ttl is None, the adapter’s default_ttl is used. If both are None, the key is stored without expiration.

Example

cache.set("k", "v".into(), Some(Duration::from_secs(60))).await?;

fn invalidate<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a key from Redis.

Returns Ok(()) whether the key existed or not.

Example

cache.invalidate("stale-key").await?;

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check whether a key exists in Redis.

Example

if cache.exists("k").await? {
    println!("hit");
}