Struct CachePlugin 

pub struct CachePlugin { /* private fields */ }

The plugin. Carries no models, no routes — just a Cache handle it installs as the ambient cache at boot, so cache_page and any handler that calls ambient() find it without explicit dependency injection.

Idiomatic registration (the carried cache is wired in on_ready):

App::builder()
    .plugin(CachePlugin::new(Cache::memory()))
    // or: CachePlugin::new(Cache::redis("redis://localhost:6379/0").await?)
    .build()?;

CachePlugin::init(cache) remains for manual/test wiring outside the plugin lifecycle.

Opt-in compression and Cache-Control headers

CachePlugin::new(Cache::memory())
    .with_compression()               // enables gzip/br/zstd negotiation
    .cache_control("public, max-age=3600")
    .vary("Accept-Encoding")

Implementations

impl CachePlugin

pub fn new(cache: Cache) -> Self

Build the plugin carrying cache. The idiomatic App::builder().plugin(CachePlugin::new(Cache::memory())) then installs it as the ambient handle at boot (BROKEN-9) — no separate init call, so cache_page actually caches.

pub fn init(cache: Cache)

Store cache as the ambient handle directly, outside the plugin lifecycle. Prefer CachePlugin::new in app code; this stays for manual / test wiring. Calling it twice panics (same contract as settings::init).

pub fn with_compression(self) -> Self

Enable response compression. Applies tower_http::compression::CompressionLayer to the router; negotiates gzip / brotli / deflate / zstd via Accept-Encoding. Default: off.

pub fn cache_control(self, value: impl Into<String>) -> Self

Emit a Cache-Control header on every response. value is the raw directive string (e.g. "public, max-age=3600", "no-store"). Default: not set.

pub fn vary(self, value: impl Into<String>) -> Self

Emit a Vary header on every response. Typically paired with with_compression: "Accept-Encoding" tells caches that different encodings are distinct variants of the same URL. Default: not set.

Trait Implementations

impl Default for CachePlugin

fn default() -> CachePlugin

Returns the “default value” for a type.

impl Plugin for CachePlugin

fn name(&self) -> &'static str

A stable identifier. Used as the key in the migration tracking table, in dependency lists, and as the directory name under migrations/. Plugin names live in the same namespace as migrate::APP_PLUGIN_NAME ("app"), so user crates must not pick the name "app".

fn wrap_router(&self, router: Router) -> Router

Wrap the app router with the plugin’s middleware layers.

fn on_ready(&self, _ctx: &AppContext) -> Result<(), PluginError>

Wire signals, start background work, seal admin registrations. Called after phase 4 (system checks) passes, in topological dependency order. Sync, on purpose; spawn async work via ctx.runtime() when the runtime handle lands.

fn dependencies(&self) -> &'static [&'static str]

Names of plugins that must load before this one. The App::builder() topological sort uses this; cycles surface as BuildError::PluginCycle. The default is no dependencies.

fn models(&self) -> Vec<ModelMeta>

The plugin’s models, in declaration order. The M7 migration engine collects these across every registered plugin and uses them as the diff target for makemigrations.

fn routes(&self) -> Router

The plugin’s HTTP routes. Merged into the app router after the hand-written one passed to AppBuilder::routes(). Plugins choose their own path prefixes (spec 02 §“What a plugin can contribute”: routes are flat, not auto-prefixed).

fn routes_builder(&self) -> Option<Routes>

The drift-free alternative to routes + route_paths (gaps4 #31): mount routes through the recording Routes builder and the framework takes BOTH the axum router and the declared RouteSpecs from that ONE source, so the route registry can never fall out of sync with what’s mounted.

fn route_paths(&self) -> Vec<RouteSpec>

Declared URL routes this plugin contributes — a companion to routes used for surfacing route lists outside the request flow (currently: the dev-mode default 404 page). axum doesn’t expose its internal route table, so plugins report what they declare here; the framework treats this as informational only — not a source of truth for routing.

fn openapi_paths(&self) -> Vec<(String, Value)>

OpenAPI path items the plugin contributes. Returned as a Vec<(path, value)> where path is the URL template (/api/auth/login, /api/foo/{id}) and value is the matching OpenAPI 3.0 Path Item Object serialised as a serde_json::Value.

fn system_checks(&self) -> Vec<SystemCheck>

Boot-time checks the plugin needs to pass. Run in phase 4 of App::build() alongside the framework’s built-in checks. Severity::Error blocks boot; Severity::Warning logs and continues.

fn provides_storage(&self) -> bool

true if this plugin registers a Storage backend (e.g. StoragePlugin, which calls crate::storage::set_storage in Plugin::on_ready).

fn database(&self) -> Option<&'static str>

The database alias every model this plugin contributes should be read from and written to. Returns None to use the "default" pool (the same one umbral::db::pool() returns).

fn templates_dirs(&self) -> Vec<PathBuf>

Template directories this plugin contributes.

fn template_registrars( &self, ) -> Vec<Box<dyn Fn(&mut Environment<'static>) + Send + Sync>>

Custom template tags / filters this plugin contributes (feature #67 - a loadable template tag/filter library).

fn middleware(&self) -> Vec<Arc<dyn Middleware>>

Framework-level request/response middleware this plugin contributes (feature #68).

fn static_files(&self) -> Vec<StaticFile>

Static files the plugin ships baked into its binary.

fn static_dirs(&self) -> Vec<StaticDir>

On-disk source directories this plugin contributes to the unified static pipeline.

fn static_root_dirs(&self) -> Vec<PathBuf>

On-disk directories served at the root of static_url — with no namespace segment.

fn commands(&self) -> Vec<Box<dyn PluginCommand>>

CLI subcommands the plugin contributes.

fn api_endpoints(&self) -> Vec<ApiEndpoint>

Callable HTTP endpoints this plugin wants advertised in a machine-readable index (e.g. a REST API root, or a client’s service-discovery fetch).