Struct RequestParts 

pub struct RequestParts {
    pub method: Method,
    pub path: String,
    pub signing_path: String,
    pub query: Option<String>,
    pub headers: HeaderMap,
}

Owned HTTP request metadata extracted from a web_sys::Request.

Workers passes a web_sys::Request with borrowed JS strings and a ReadableStream body. The gateway expects a RequestInfo that borrows from Rust-owned data, so this struct bridges the gap by owning the parsed method, path, query, and headers.

Example

let (parts, body) = RequestParts::from_web_sys(&req)?;
let result = gateway
    .handle_request(&parts.as_request_info(), body, collect_js_body)
    .await;

Fields

method: Method

The HTTP method.

path: String

The percent-decoded URL path (e.g. "/bucket/my key").

Decoded for S3 operation parsing and bucket/key routing. Do not use this for SigV4 verification: the canonical URI must be the encoded form the client signed, so use signing_path instead.

signing_path: String

The raw, percent-encoded URL path exactly as it arrived on the wire (e.g. "/bucket/my%20key").

This is the form the client signs, so it is what SigV4 verification must canonicalize over. as_request_info wires it into RequestInfo’s signing path automatically. Integrators that rewrite paths before dispatch (e.g. path-mapping) must still sign against this encoded path — never the decoded path.

query: Option<String>

The raw query string, if present.

headers: HeaderMap

The HTTP request headers.

Implementations

impl RequestParts

pub fn from_web_sys(req: &Request) -> Result<(Self, JsBody), String>

Parse a web_sys::Request into owned request metadata and a zero-copy JsBody.

Extracts the body stream before reading headers, so the ReadableStream is never locked.

pub fn as_request_info(&self) -> RequestInfo<'_>

Borrow this struct as a RequestInfo for gateway dispatch.

Sets the signing path to the raw, percent-encoded signing_path so SigV4 verification canonicalizes over the path the client actually signed. Without this, a key containing a character the client escapes — e.g. a space → %20 — would be verified against the decoded path and fail with SignatureDoesNotMatch.