Struct ResponseRewritePlugin 

pub struct ResponseRewritePlugin {
    status_code: Option<u16>,
    body: Option<ResponseBody>,
    filters: Vec<BodyFilter>,
    add_headers: Vec<(String, Template)>,
    set_headers: Vec<(String, Template)>,
    remove_headers: Vec<String>,
    vars: Option<Expr>,
}

Rewrites Context.response: optionally forces a status code, replaces the body (with optional base64-decoded config content), applies regex filters to the body, and adds/sets/removes headers with {{namespace.path}} references plus legacy $var interpolation in header values. An optional vars expression gates the whole node — when present and false the node is a pure passthrough. This plugin never fails at execution time.

Fields

status_code: Option<u16>

body: Option<ResponseBody>

Replacement body. The plain-text form is a {{namespace.path}} template rendered per request; a body_base64 body is decoded once at config load and used verbatim — it is opaque binary content (images, protobufs, …), not text, so it is never templated.

filters: Vec<BodyFilter>

add_headers: Vec<(String, Template)>

Header name → value template; supports {{namespace.path}} references and legacy $var interpolation (see Template::render_with_legacy).

set_headers: Vec<(String, Template)>

Same rendering as add_headers.

remove_headers: Vec<String>

vars: Option<Expr>

Implementations

impl ResponseRewritePlugin

pub fn from_config(config: &HashMap<String, Value>) -> Result<Self, String>

Builds the plugin from node config.

Accepted keys (all optional):

• status_code (integer, 200-598): new response status code.

• body (string): new response body. Wins over filters — configuring both is rejected (as in APISIX). Supports {{namespace.path}} references, rendered per request — unless body_base64 is set (see below), in which case it is opaque binary content and is never templated.

• body_base64 (bool, default false): when true, body is decoded from base64 at config load and used verbatim as fixed bytes on every request (never templated — a base64 body is binary content such as an image, not text); invalid or empty base64 content fails here.

• headers — either the structured shape or the deprecated flat map:

  • add (array of "Name: value" strings): appended alongside existing values. The value must be non-empty and colon-free.
  • set (map {name: value}): replaces existing values. Values may be strings or numbers.
  • remove (array of names): deleted.
  • flat map {name: value} (deprecated): treated as set.

  add/set values support {{namespace.path}} references plus legacy $var / ${var} interpolation at execution time (e.g. $remote_addr, $status, $http_x_id).

• filters (array): regex substitutions applied to the response body. Each entry: regex (required, non-empty), replace (required; supports {{namespace.path}} references, rendered before the regex engine applies its own $1/$2 capture-group substitution, so those stay untouched by templating), scope (once | global, default once), options (only "i" for case-insensitive; anything else is rejected). Regexes are compiled here, so invalid patterns fail at config load.

• vars (array, APISIX triple-array expression): gate — when present and it evaluates to false, the node passes the context through unchanged.

type: response-rewrite
config:
  status_code: 200
  headers:
    set:
      x-server-id: "3"
    add:
      - "x-trace: $http_x_request_id"
    remove: [x-powered-by]
  filters:
    - regex: "X-Amzn-"
      scope: global
      replace: ""
  vars:
    - ["status", "==", "200"]

fn apply_filters(&self, ctx: &mut Context)

Runs the configured regex filters against the response body, decoding a content-encoded body first. On any obstacle (unsupported encoding, corrupt compressed data, non-UTF-8 body) it logs a warning and leaves the response untouched, matching APISIX’s “filters may not work as expected” behavior.

Trait Implementations

impl Plugin for ResponseRewritePlugin

fn plugin_type(&self) -> &str

Unique identifier for the plugin type (e.g., “proxy-rewrite”, “upstream”). This is also the key its PortSpec is registered under in port_spec.

fn reads_response_body(&self) -> bool

Whether this configured instance reads context.response.body.

fn execute<'life0, 'async_trait>( &'life0 self, ctx: Context, ) -> Pin<Box<dyn Future<Output = Result<PluginOutput, PluginExecutionError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes the plugin logic against the request/response context.

fn cache_target(&self) -> Option<CacheTarget>

The cache backend this node writes to, if it is a proxy-cache half.