Struct Request 

pub struct Request { /* private fields */ }

HTTP Request wrapper providing Laravel-like access to request data

Implementations

impl Request

pub fn new(inner: Request<Incoming>) -> Self

pub fn with_params(self, params: HashMap<String, String>) -> Self

pub fn method(&self) -> &Method

Get the request method

pub fn path(&self) -> &str

Get the request path

pub fn param(&self, name: &str) -> Result<&str, ParamError>

Get a route parameter by name (e.g., /users/{id}) Returns Err(ParamError) if the parameter is missing, enabling use of ? operator

pub fn params(&self) -> &HashMap<String, String>

Get all route parameters

pub fn inner(&self) -> &Request<Incoming>

Get the inner hyper request

pub fn header(&self, name: &str) -> Option<&str>

Get a header value by name

pub fn content_type(&self) -> Option<&str>

Get the Content-Type header

pub fn is_inertia(&self) -> bool

Check if this is an Inertia XHR request

pub fn inertia_version(&self) -> Option<&str>

Get the Inertia version from request headers

pub fn inertia_partial_component(&self) -> Option<&str>

Get partial component name for partial reloads

pub fn inertia_partial_data(&self) -> Option<Vec<&str>>

Get partial data keys for partial reloads

pub async fn body_bytes(self) -> Result<(RequestParts, Bytes), FrameworkError>

Consume the request and collect the body as bytes

pub async fn json<T: DeserializeOwned>(self) -> Result<T, FrameworkError>

Parse the request body as JSON

Consumes the request since the body can only be read once.

Example

#[derive(Deserialize)]
struct CreateUser { name: String, email: String }

pub async fn store(req: Request) -> Response {
    let data: CreateUser = req.json().await?;
    // ...
}

pub async fn form<T: DeserializeOwned>(self) -> Result<T, FrameworkError>

Parse the request body as form-urlencoded

Consumes the request since the body can only be read once.

Example

#[derive(Deserialize)]
struct LoginForm { username: String, password: String }

pub async fn login(req: Request) -> Response {
    let form: LoginForm = req.form().await?;
    // ...
}

pub async fn input<T: DeserializeOwned>(self) -> Result<T, FrameworkError>

Parse the request body based on Content-Type header

• application/json -> JSON parsing
• application/x-www-form-urlencoded -> Form parsing
• Otherwise -> JSON parsing (default)

Consumes the request since the body can only be read once.

pub fn into_parts(self) -> (RequestParts, Incoming)

Consume the request and return its parts along with the inner hyper request body

This is used internally by the handler macro for FormRequest extraction.

Trait Implementations

impl FromRequest for Request

Request passes through unchanged

fn from_request<'async_trait>( req: Request, ) -> Pin<Box<dyn Future<Output = Result<Self, FrameworkError>> + Send + 'async_trait>>

where Self: 'async_trait,

Extract Self from the incoming request