Trait CacheableResponse

Source

pub trait CacheableResponsewhere
    Self: Sized + Send + 'static,
    Self::Cached: Clone,{
    type Cached;
    type Subject: CacheableResponse;
    type IntoCachedFuture: Future<Output = CachePolicy<Self::Cached, Self>> + Send;
    type FromCachedFuture: Future<Output = Self> + Send;

    // Required methods
    fn cache_policy<P>(
        self,
        predicates: P,
        config: &EntityPolicyConfig,
    ) -> impl Future<Output = ResponseCachePolicy<Self>> + Send
       where P: Predicate<Subject = Self::Subject> + Send + Sync;
    fn into_cached(self) -> Self::IntoCachedFuture;
    fn from_cached(cached: Self::Cached) -> Self::FromCachedFuture;
}

Expand description

Trait for response types that can be cached.

This trait defines how responses are converted to and from their cached representation. Implementations must provide methods for:

Determining if a response should be cached (cache_policy)
Converting to the cached format (into_cached)
Reconstructing from cached data (from_cached)

§Associated Types

Cached - The serializable representation stored in cache
Subject - The type that predicates evaluate (for wrapper types like Result)
IntoCachedFuture - Future returned by into_cached
FromCachedFuture - Future returned by from_cached

§Blanket Implementation

A blanket implementation is provided for Result<T, E> where T: CacheableResponse. This allows:

Ok(response) to be cached if the inner response is cacheable
Err(error) to always pass through without caching

§Example Implementation

use hitbox_core::{CacheableResponse, CachePolicy, EntityPolicyConfig};
use hitbox_core::predicate::{Predicate, PredicateResult};
use hitbox_core::response::ResponseCachePolicy;
use hitbox_core::value::CacheValue;
use chrono::Utc;

#[derive(Clone)]
struct MyResponse {
    body: String,
    status: u16,
}

impl CacheableResponse for MyResponse {
    type Cached = String;
    type Subject = Self;
    type IntoCachedFuture = std::future::Ready<CachePolicy<String, Self>>;
    type FromCachedFuture = std::future::Ready<Self>;

    async fn cache_policy<P>(
        self,
        predicates: P,
        config: &EntityPolicyConfig,
    ) -> ResponseCachePolicy<Self>
    where
        P: Predicate<Subject = Self::Subject> + Send + Sync,
    {
        match predicates.check(self).await {
            PredicateResult::Cacheable(data) => {
                let cached = data.body.clone();
                CachePolicy::Cacheable(CacheValue::new(
                    cached,
                    config.ttl.map(|d| Utc::now() + d),
                    config.stale_ttl.map(|d| Utc::now() + d),
                ))
            }
            PredicateResult::NonCacheable(data) => CachePolicy::NonCacheable(data),
        }
    }

    fn into_cached(self) -> Self::IntoCachedFuture {
        std::future::ready(CachePolicy::Cacheable(self.body))
    }

    fn from_cached(cached: String) -> Self::FromCachedFuture {
        std::future::ready(MyResponse { body: cached, status: 200 })
    }
}