Struct RedisCacheMiddlewareBuilder

pub struct RedisCacheMiddlewareBuilder { /* private fields */ }

Builder for configuring and creating the RedisCacheMiddleware.

Provides a fluent interface for configuring cache parameters such as TTL, maximum cacheable size, cache key prefix, and cache decision predicates.

Implementations

impl RedisCacheMiddlewareBuilder

pub fn new(redis_url: impl Into<String>) -> Self

Creates a new builder with the given Redis URL.

Arguments

• redis_url - The Redis connection URL (e.g., “redis://127.0.0.1:6379”)

Returns

A new RedisCacheMiddlewareBuilder with default settings:

• TTL: 3600 seconds (1 hour)
• Max cacheable size: 1MB
• Cache prefix: “cache:”
• Cache predicate: cache all responses

pub fn ttl(self, seconds: u64) -> Self

Sets the TTL (time-to-live) for cached responses in seconds.

Arguments

• seconds - The number of seconds a response should remain in the cache

Returns

Self for method chaining

pub fn max_cacheable_size(self, bytes: usize) -> Self

Sets the maximum size of responses that can be cached, in bytes.

Responses larger than this size will not be cached.

Arguments

• bytes - The maximum cacheable response size in bytes

Returns

Self for method chaining

pub fn cache_prefix(self, prefix: impl Into<String>) -> Self

Sets the prefix used for Redis cache keys.

Arguments

• prefix - The string prefix to use for all cache keys

Returns

Self for method chaining

pub fn cache_if<F>(self, predicate: F) -> Self

where F: Fn(&CacheDecisionContext<'_>) -> bool + Send + Sync + 'static,

Set a predicate function to determine if a response should be cached

Example:

builder.cache_if(|ctx| {
    // Only cache GET requests
    if ctx.method != "GET" {
        return false;
    }
     
    // Don't cache if Authorization header is present
    if ctx.headers.contains_key("Authorization") {
        return false;
    }
     
    // Don't cache responses to paths that start with /admin
    if ctx.path.starts_with("/admin") {
        return false;
    }

    // Don't cache for a specific route if its body contains some field
    if ctx.path.starts_with("/api/users") && ctx.method == "POST" {
       if let Ok(user_json) = serde_json::from_slice::<serde_json::Value>(ctx.body) {
           // Check properties in the JSON to make caching decisions
           return user_json.get("role").and_then(|r| r.as_str()) != Some("admin");
       }
   }
    true
})

pub async fn build(self) -> RedisCacheMiddleware

Builds and returns the configured RedisCacheMiddleware.

Returns

A new RedisCacheMiddleware instance configured with the settings from this builder.

Panics

This method will panic if it cannot connect to Redis using the provided URL.