Struct CacheService

Source

pub struct CacheService<B: CacheBackend> { /* private fields */ }

Expand description

High-level cache service for web applications.

Wraps CacheExpander in Arc for easy sharing across threads without requiring external Arc<Mutex<>> wrappers.

§Design

Since CacheBackend implementations use interior mutability (RwLock, Mutex), and CacheExpander now uses &self methods, we can safely wrap it in Arc without needing an additional Mutex.

§Example

use cache_kit::{CacheService, backend::InMemoryBackend};

// Create service (can be shared across threads)
let cache = CacheService::new(InMemoryBackend::new());

// In your web service struct
pub struct UserService {
    cache: CacheService<InMemoryBackend>,
    repo: Arc<UserRepository>,
}

impl UserService {
    pub fn get(&self, id: &str) -> Result<Option<User>> {
        let mut feeder = UserFeeder { id: id.to_string(), user: None };
        self.cache.execute(&mut feeder, &*self.repo, CacheStrategy::Refresh)?;
        Ok(feeder.user)
    }
}

Implementations§

Source §

impl<B: CacheBackend> CacheService

Source

pub fn new(backend: B) -> Self

Create a new cache service with the given backend.

Source

pub fn with_metrics(backend: B, metrics: Box<dyn CacheMetrics>) -> Self

Create a new cache service with custom metrics.

Source

pub async fn execute<T, F, R>( &self, feeder: &mut F, repository: &R, strategy: CacheStrategy, ) -> Result<()>
where T: CacheEntity, F: CacheFeed<T>, R: DataRepository<T>, T::Key: FromStr,

Execute a cache operation.

This is equivalent to calling expander.with() but more ergonomic for service-oriented architectures.

§Arguments

feeder: Entity feeder (implements CacheFeed<T>)
repository: Data repository (implements DataRepository<T>)
strategy: Cache strategy (Fresh, Refresh, Invalidate, Bypass)

§Example

let cache = CacheService::new(InMemoryBackend::new());
let mut feeder = UserFeeder { id: "user_123".to_string(), user: None };
let repo = UserRepository::new(pool);

cache.execute(&mut feeder, &repo, CacheStrategy::Refresh).await?;
let user = feeder.user;

§Errors

Returns Err in these cases:

Error::ValidationError: Feeder validation fails
Error::DeserializationError: Cached data is corrupted
Error::InvalidCacheEntry: Invalid cache envelope
Error::VersionMismatch: Schema version mismatch
Error::BackendError: Cache backend unavailable
Error::RepositoryError: Database access fails
Error::SerializationError: Entity serialization fails

Source

pub async fn execute_with_config<T, F, R>( &self, feeder: &mut F, repository: &R, strategy: CacheStrategy, config: OperationConfig, ) -> Result<()>
where T: CacheEntity, F: CacheFeed<T>, R: DataRepository<T>, T::Key: FromStr,

Execute a cache operation with advanced configuration.

This method allows per-operation configuration such as TTL override and retry logic, while working seamlessly with Arc-wrapped services.

§Arguments

feeder: Entity feeder (implements CacheFeed<T>)
repository: Data repository (implements DataRepository<T>)
strategy: Cache strategy (Fresh, Refresh, Invalidate, Bypass)
config: Operation configuration (TTL override, retry count)

§Example

let cache = CacheService::new(InMemoryBackend::new());
let mut feeder = UserFeeder { id: "user_123".to_string(), user: None };
let repo = UserRepository::new(pool);

let config = OperationConfig::default()
    .with_ttl(Duration::from_secs(300))
    .with_retry(3);

cache.execute_with_config(&mut feeder, &repo, CacheStrategy::Refresh, config).await?;
let user = feeder.user;