Struct HandlerContractConfig 

pub struct HandlerContractConfig {
    pub trait_name: String,
    pub dispatch_method: String,
    pub is_async: bool,
    pub wire_request_type: Option<String>,
    pub wire_response_type: Option<String>,
    pub optional_overrides: Vec<String>,
    pub dispatch_extra_params: Vec<String>,
    pub wire_param_name: Option<String>,
    pub dispatch_return_type: Option<String>,
    pub response_adapter: Option<String>,
}

Configuration for one handler-contract entry in [[crates.handler_contracts]].

This augments a trait already present in the extracted surface with service-specific metadata: the dispatch method that backends must bridge, whether that method is async, and the names of the wire request/response DTOs.

[[crates.handler_contracts]]
trait_name = "Handler"
dispatch_method = "call"
is_async = true
wire_request_type = "RequestData"
wire_response_type = "ResponseData"

Fields

trait_name: String

Name of the Rust trait in the surface (e.g. "Handler").

dispatch_method: String

Name of the primary dispatch method (e.g. "call").

is_async: bool

Whether the dispatch method is async (defaults to true).

wire_request_type: Option<String>

Name of the wire request DTO (e.g. "RequestData"). When absent, the dispatch method’s signature is used verbatim.

wire_response_type: Option<String>

Name of the wire response DTO (e.g. "ResponseData"). When absent, the dispatch method’s return type is used verbatim.

optional_overrides: Vec<String>

Methods that backends may optionally override (have default implementations in the trait). Subset of the trait’s method names.

dispatch_extra_params: Vec<String>

Verbatim parameter declarations the generated bridge inserts before the wire request parameter and then ignores in the body. Used when the dispatch method has leading parameters whose concrete types cannot be reconstructed from the sanitized surface (e.g. foreign framework types). Default: none.

wire_param_name: Option<String>

Name of the wire request parameter in the generated dispatch signature. When absent, defaults to "request".

dispatch_return_type: Option<String>

Verbatim return type for the generated dispatch future’s Output. When absent, the bridge synthesizes Result<{wire_response}, Box<dyn Error + Send + Sync>>. Set this when the trait’s dispatch returns a library-specific type the bridge must produce via Self::response_adapter.

response_adapter: Option<String>

Path to a library function that converts the bridge’s Result<{wire_response}, Box<dyn Error + Send + Sync>> outcome into the Self::dispatch_return_type. When absent, the bridge returns the wire response directly. The function is opaque to the generator — it simply emits a call to it.

Trait Implementations

impl Clone for HandlerContractConfig

fn clone(&self) -> HandlerContractConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HandlerContractConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HandlerContractConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for HandlerContractConfig

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 HandlerContractConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.