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 with_route_pattern(self, pattern: String) -> Self

Set the route pattern (e.g., “/users/{id}”)

pub fn route_pattern(&self) -> Option<String>

Get the route pattern for metrics grouping

pub fn insert<T: Send + Sync + 'static>(&mut self, value: T)

Insert a value into the request extensions (type-map pattern)

This is async-safe unlike thread-local storage.

pub fn get<T: Send + Sync + 'static>(&self) -> Option<&T>

Get a reference to a value from the request extensions

pub fn get_mut<T: Send + Sync + 'static>(&mut self) -> Option<&mut T>

Get a mutable reference to a value from the request extensions

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 param_as<T: FromStr>(&self, name: &str) -> Result<T, ParamError>

where T::Err: Display,

Get a route parameter parsed as a specific type

Combines param() with parsing, returning a typed value.

Example

pub async fn show(req: Request) -> Response {
    let id: i32 = req.param_as("id")?;
    // ...
}

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

Get all route parameters

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

Get a query string parameter by name

Example

// URL: /users?page=2&limit=10
let page = req.query("page"); // Some("2")
let sort = req.query("sort"); // None

pub fn query_or(&self, name: &str, default: &str) -> String

Get a query string parameter or a default value

Example

// URL: /users?page=2
let page = req.query_or("page", "1"); // "2"
let limit = req.query_or("limit", "10"); // "10"

pub fn query_as<T: FromStr>(&self, name: &str) -> Option<T>

Get a query string parameter parsed as a specific type

Example

// URL: /users?page=2&limit=10
let page: Option<i32> = req.query_as("page"); // Some(2)

pub fn query_as_or<T: FromStr>(&self, name: &str, default: T) -> T

Get a query string parameter parsed as a specific type, or a default

Example

// URL: /users?page=2
let page: i32 = req.query_as_or("page", 1); // 2
let limit: i32 = req.query_as_or("limit", 10); // 10

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 cookies(&self) -> HashMap<String, String>

Get all cookies from the request

Parses the Cookie header and returns a HashMap of cookie names to values.

Example

let cookies = req.cookies();
if let Some(session) = cookies.get("session") {
    println!("Session: {}", session);
}

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

Get a specific cookie value by name

Example

if let Some(session_id) = req.cookie("session") {
    // Use session_id
}

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 From<&Request> for SavedInertiaContext

fn from(req: &Request) -> Self

Converts to this type from the input type.

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

impl InertiaRequest for Request

Implement the framework-agnostic InertiaRequest trait for Ferro’s Request type.

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

Get a header value by name.

fn path(&self) -> &str

Get the request path (URL path component).

fn is_inertia(&self) -> bool

Check if this is an Inertia XHR request.

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

Get the Inertia asset version from the request.

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

Get the partial reload data keys.

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

Get the component name for partial reload.

fn accepts_json(&self) -> bool

Check if the request accepts JSON responses.