Struct RedisStore 

pub struct RedisStore { /* private fields */ }

Implementations

impl RedisStore

pub async fn new(connection_string: &str) -> Result<Self, StorageError>

Create a new Redis store without a key prefix.

pub async fn with_prefix( connection_string: &str, prefix: Option<&str>, ) -> Result<Self, StorageError>

Create a new Redis store with an optional key prefix.

The prefix is prepended to all keys, enabling namespacing when sharing a Redis instance with other applications.

Example

// Keys will be prefixed: "myapp:user.alice", "myapp:config.app"
let store = RedisStore::with_prefix("redis://localhost", Some("myapp:")).await?;

pub fn connection(&self) -> ConnectionManager

Get a clone of the connection manager (for sharing with MerkleStore)

pub fn prefix(&self) -> &str

Get the configured prefix

impl RedisStore

pub async fn exists_batch( &self, ids: &[String], ) -> Result<Vec<bool>, StorageError>

Check if multiple keys exist in Redis (pipelined). Returns a vec of bools matching the input order.

pub async fn list_state_ids( &self, state: &str, ) -> Result<Vec<String>, StorageError>

Get all IDs in a given state (from Redis SET).

Returns IDs without prefix - ready to use with get().

pub async fn count_by_state(&self, state: &str) -> Result<u64, StorageError>

Count items in a given state (SET cardinality).

pub async fn is_in_state( &self, id: &str, state: &str, ) -> Result<bool, StorageError>

Check if an ID is in a given state (SET membership).

pub async fn move_state( &self, id: &str, from_state: &str, to_state: &str, ) -> Result<bool, StorageError>

Move an ID from one state to another (atomic SMOVE).

Returns true if the item was moved, false if it wasn’t in the source state.

pub async fn remove_from_state( &self, id: &str, state: &str, ) -> Result<bool, StorageError>

Remove an ID from a state SET.

pub async fn delete_by_state(&self, state: &str) -> Result<u64, StorageError>

Delete all items in a state (both the SET and the actual keys).

Returns the number of items deleted.

pub async fn scan_prefix( &self, prefix: &str, limit: usize, ) -> Result<Vec<SyncItem>, StorageError>

Scan items by ID prefix using Redis SCAN.

Uses cursor-based SCAN with MATCH pattern for safe iteration. Does NOT block the server (unlike KEYS).

Example

// Get all deltas for object user.123
let deltas = store.scan_prefix("delta:user.123:", 1000).await?;

pub async fn count_prefix(&self, prefix: &str) -> Result<u64, StorageError>

Count items matching an ID prefix.

Note: This requires scanning all matching keys, so use sparingly.

pub async fn delete_prefix(&self, prefix: &str) -> Result<u64, StorageError>

Delete all items matching an ID prefix.

Returns the number of deleted items.

pub async fn xadd_cdc( &self, entry: &CdcEntry, maxlen: u64, ) -> Result<String, StorageError>

Write a CDC entry to the stream.

Uses XADD with MAXLEN ~ for bounded stream size. The stream key is {prefix}__local__:cdc.

pub async fn xadd_cdc_batch( &self, entries: &[CdcEntry], maxlen: u64, ) -> Result<Vec<String>, StorageError>

Write multiple CDC entries to the stream in a pipeline.

Returns the stream entry IDs for each write.

Trait Implementations

impl CacheStore for RedisStore

fn put_batch<'life0, 'life1, 'async_trait>( &'life0 self, items: &'life1 [SyncItem], ) -> Pin<Box<dyn Future<Output = Result<BatchWriteResult, StorageError>> + Send + 'async_trait>>

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

Write a batch of items using Redis pipeline (atomic, much faster than individual SETs).

fn put_batch_with_ttl<'life0, 'life1, 'async_trait>( &'life0 self, items: &'life1 [SyncItem], ttl_secs: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<BatchWriteResult, StorageError>> + Send + 'async_trait>>

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

Write a batch of items with optional TTL.

fn ft_create<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

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

Create a RediSearch index (FT.CREATE).

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

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

Drop a RediSearch index (FT.DROPINDEX).

fn ft_search<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, index: &'life1 str, query: &'life2 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>

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

Search using RediSearch (FT.SEARCH).

fn ft_search_with_params<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, index: &'life1 str, query: &'life2 str, params: &'life3 [(String, Vec<u8>)], limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>

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

Search using RediSearch with binary parameters (for vector KNN search). Uses FT.SEARCH index query PARAMS n name blob… LIMIT offset count NOCONTENT

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

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

fn put<'life0, 'life1, 'async_trait>( &'life0 self, item: &'life1 SyncItem, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

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

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

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

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

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

Check if an item exists (Redis EXISTS command - fast, no data transfer).