Struct ServerCacheLayer 

pub struct ServerCacheLayer<M, K = DefaultKeyer>
where
    M: CacheManager,
    K: Keyer,
{ /* private fields */ }

Tower layer for server-side HTTP response caching.

This layer should be placed AFTER routing to ensure request extensions (like path parameters) are preserved.

Shared Cache Behavior

This implements a shared cache as defined in RFC 9111. Responses cached by this layer are served to all users making requests with matching cache keys. The cache automatically rejects responses with the private directive, but does not inspect Authorization headers or session cookies.

For authenticated or user-specific endpoints, either:

• Set Cache-Control: private in responses (prevents caching)
• Use a CustomKeyer that includes user/session identifiers in the cache key

Implementations

impl<M> ServerCacheLayer<M, DefaultKeyer>

where M: CacheManager,

pub fn new(manager: M) -> Self

Create a new cache layer with default options.

impl<M, K> ServerCacheLayer<M, K>

where M: CacheManager, K: Keyer,

pub fn with_keyer(manager: M, keyer: K) -> Self

Create a cache layer with a custom keyer.

pub fn with_options(self, options: ServerCacheOptions) -> Self

Set custom options.

pub fn metrics(&self) -> &Arc<CacheMetrics>

Get a reference to the cache metrics.

pub async fn invalidate( &self, cache_key: &str, ) -> Result<(), Box<dyn StdError + Send + Sync>>

Invalidate a specific cache entry by its key.

pub async fn invalidate_request<B>( &self, req: &Request<B>, ) -> Result<(), Box<dyn StdError + Send + Sync>>

Invalidate cache entry for a specific request.

Uses the configured keyer to generate the cache key from the request.

Trait Implementations

impl<M, K> Clone for ServerCacheLayer<M, K>

where M: CacheManager + Clone, K: Keyer + Clone,

fn clone(&self) -> ServerCacheLayer<M, K>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, M, K> Layer<S> for ServerCacheLayer<M, K>

where M: CacheManager + Clone, K: Keyer,

type Service = ServerCacheService<S, M, K>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.