Struct RouteGraphql 

pub struct RouteGraphql {
    pub enabled: bool,
    pub depth_limit: usize,
    pub complexity_limit: u64,
    pub complexity_coefficient: u64,
    pub cost_per_field: HashMap<String, u64>,
    pub persisted_queries: Option<GraphqlPersistedQueries>,
    pub federation: Option<GraphqlFederation>,
}

Route-scoped GraphQL awareness config (DW-099, routes[].graphql).

When enabled (compiled into every build; no cargo feature), the gateway enforces query depth/complexity limits and optional persisted-query enforcement on every request the route matches, BEFORE the route limits and authentication. A query whose depth or complexity exceeds the configured limits is rejected with 400 (graphql_depth_exceeded or graphql_complexity_exceeded); a query whose SHA-256 hash is not in the persisted-query store is rejected with 400 (graphql_persisted_query_required).

The check is compiled into every build (no cargo feature): a config carrying the block behaves identically in any build.

Depth is the maximum brace-nesting level of the query (the top-level operation body is depth 1). Complexity is the sum of per-field costs: each field’s cost is looked up in cost_per_field, falling back to complexity_coefficient (default

1. when the field name is not in the map.

Both are computed by a bounded hand-rolled scanner (no external GraphQL parser dependency).

Fields

enabled: bool

Master switch. Default false: the GraphQL block is inert even when present (allows staged rollout). When true, the depth and complexity checks run on every request the route matches.

depth_limit: usize

Maximum query depth (max brace-nesting level). A query whose depth exceeds this is rejected with 400 graphql_depth_exceeded. Must be > 0 when the block is enabled (validation rejects 0 or absent). The top-level operation body is depth 1, so a value of 1 permits only a flat selection set with no nested fields.

complexity_limit: u64

Maximum query complexity (sum of per-field costs). A query whose complexity exceeds this is rejected with 400 graphql_complexity_exceeded. Must be > 0 when the block is enabled.

complexity_coefficient: u64

Default cost per field when the field name is not in cost_per_field (default 1). The complexity total is sum(cost_per_field[name].unwrap_or(complexity_coefficient)).

cost_per_field: HashMap<String, u64>

Per-field cost overrides. Maps a field name to its explicit cost; any field not in this map uses complexity_coefficient. Empty (the default): every field costs complexity_coefficient.

persisted_queries: Option<GraphqlPersistedQueries>

Persisted-query enforcement (Apollo APQ + GET-by-hash variant). When enabled, every request’s query SHA-256 hash must be in the configured store (a map of hash -> query text). A hash not in the store is rejected with 400 graphql_persisted_query_required. Absent (the default): no persisted-query enforcement.

federation: Option<GraphqlFederation>

Federation passthrough config (DP-11, #256). When enabled, the gateway treats the route as a federation passthrough: it forwards GraphQL requests to a single federated upstream (subgraph or supergraph router) while preserving federation-specific headers and allowing introspection queries (_service, __schema) to bypass depth/complexity checks.

Trait Implementations

impl Clone for RouteGraphql

fn clone(&self) -> RouteGraphql

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RouteGraphql

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RouteGraphql

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RouteGraphql

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 PartialEq for RouteGraphql

fn eq(&self, other: &RouteGraphql) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RouteGraphql

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RouteGraphql