Struct Route 

pub struct Route {
    pub matcher: RouteMatch,
    pub filters: Vec<String>,
    pub upstream: Option<String>,
    pub backends: Vec<Backend>,
    pub strip_prefix: Option<String>,
    pub rate_limit: Option<RouteRateLimit>,
    pub upgrade: Option<RouteUpgrade>,
    pub compression: Option<RouteCompression>,
}

One routing rule (ADR 000013 / 000034): match a request by the [route.match] dimensions, run an inline chain of filters, and forward to a single upstream (shorthand) or a weighted set of backends (traffic split / canary). strip_prefix is a host-native path rewrite applied to the forwarded request only (the chain still sees the original path) — the common reverse-proxy prefix-strip, without a plecto:filter contract change. filters / strip_prefix / rate_limit are per-route: they apply identically across every backend (ADR 000034 keeps a backend a pure {upstream, weight} pair; a route needing different policy per target uses a separate route).

Fields

matcher: RouteMatch

The match dimensions ([route.match]): host / path_prefix / method / headers / query (ADR 000034). At least path_prefix is required; all other dimensions are optional and ANDed.

filters: Vec<String>

This route’s chain: filter ids run in order (may be empty for a pure pass-through route).

upstream: Option<String>

Single-upstream shorthand: the [[upstream]] name to forward a passing request to. Mutually exclusive with backends (exactly one is required; validated at build). A single upstream is normalised to a one-element weighted set (weight 1) at compile time.

backends: Vec<Backend>

Weighted traffic split (ADR 000034): forward to these {upstream, weight} backends in proportion to their weights (canary). Mutually exclusive with upstream. Empty unless used.

strip_prefix: Option<String>

If set and the forwarded path starts with it, strip it before forwarding to the upstream (host-native rewrite; the chain saw the original path). E.g. /api + /api/x → /x.

rate_limit: Option<RouteRateLimit>

Native fast-path rate limit (ADR 000033): a coarse token-bucket baseline consulted BEFORE this route’s filter chain. Absent = unlimited (the default). Distinct from the per-filter host-ratelimit capability (ADR 000026): this is the operator’s native floor on a route (or per client-IP), needs no WASM filter, and never crosses the WASM boundary.

upgrade: Option<RouteUpgrade>

HTTP/1.1 Upgrade opt-in (ADR 000048): the Upgrade tokens this route tunnels. Absent = deny-by-default (the Upgrade/Connection pair keeps being stripped as hop-by-hop).

compression: Option<RouteCompression>

Native response compression opt-in (ADR 000074 / 000075): negotiate a content coding against the client’s Accept-Encoding and compress eligible responses AFTER the response chain (filters always see identity). Absent = never transform — deny-by-default, which is also the per-route BREACH opt-out. Do not enable on routes that reflect secrets into the response body (CSRF tokens, session nonces echoed from the request): compression + reflection enables BREACH-class chosen-plaintext attacks against TLS. Leave those routes uncompressed.

Trait Implementations

impl Clone for Route

fn clone(&self) -> Route

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Route

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Route

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Route

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for Route

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.