Struct CacheEdgeKv 

pub struct CacheEdgeKv(/* private fields */);

An EdgeKv backed by the application’s own cache.

This is the adapter that makes an #[edge(needs(kv))] handler work at the origin: it projects the seven-method, type-erased Cache onto the one-method byte-oriented seam the edge lane can mediate.

What the origin has to do to publish a value

Nothing edge-specific. Write bytes through the ordinary serde-aware cache path and an edge handler reading the same key sees them:

use std::sync::Arc;

use autumn_web::CacheEdgeKv;
use autumn_web::cache::{Cache, MokaCache, insert_cached};
use autumn_web::edge::EdgeKv;

let cache = MokaCache::new(128, None);
insert_cached(&cache, "banner", b"Autumn is up".to_vec(), None);

let kv = CacheEdgeKv::new(Arc::new(cache) as Arc<dyn Cache>);
assert_eq!(kv.get("banner"), Some(b"Autumn is up".to_vec()));
assert_eq!(kv.get("nothing-here"), None);

Vec<u8> is the wire currency on purpose: it is the only shape that survives both an in-process backend (stored as-is) and a serializing one like Redis (JSON round-tripped), so a value published on one replica reads back identically on another. A key holding some other type is reported as a miss rather than an error — the seam has exactly one failure mode, and a handler already has to render something sensible for it.

Implementations

impl CacheEdgeKv

pub const fn new(cache: Arc<dyn Cache>) -> Self

Adapt a cache backend into the edge key/value seam.

Pass the same backend the app serves from — typically the one given to AppBuilder::with_cache_backend — so the edge lane observes what the origin publishes.

pub fn cache(&self) -> &Arc<dyn Cache>

The cache this adapter reads through.

Trait Implementations

impl Debug for CacheEdgeKv

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EdgeKv for CacheEdgeKv

fn get(&self, key: &str) -> Option<Vec<u8>>

Read key. None means “not here” — a miss, an expiry, or a replica that has not caught up yet. Callers may not distinguish these.