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

Create a new request from a raw hyper request.

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

Attach route parameters extracted from the URL path.

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 set_path(&mut self, new_path: &str)

Rewrite the request path (server-side only — the browser URL is unchanged).

Replaces the URI path component while preserving the scheme, authority, and query string. Used by pre-route middleware (e.g. HostMiddleware) to map custom-domain requests onto internal slug-based routes before routing occurs.

new_path must begin with /. Panics in debug mode if it does not.

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 old(&self, field: &str) -> Option<String>

Read a previously-submitted form value from session flash.

After a POST handler calls ValidationError::with_old_input(&data).redirect_back(...), the GET handler retrieves the value with req.old("field_name") and passes it as InputProps.default_value to repopulate the form.

Reads from _flash.old._old_input.<field> without clearing (read-only semantics). Flash aging (move new→old→deleted) is handled by the session middleware at request boundaries, so multiple reads in the same GET handler are safe.

Returns None when no flash value exists, no session is active, or the key is absent.

pub fn validation_error(&self, field: &str) -> Option<String>

Read the first validation error message for a field from session flash.

After a POST handler calls errors.redirect_back(...), the GET handler calls req.validation_error("field_name") and passes the result as InputProps.error.

Reads from _flash.old._validation_errors without clearing (read-only semantics).

Returns None when no flash errors exist, no session is active, or the field has no error.

pub fn has_validation_errors(&self) -> bool

Returns true when any validation errors were flashed from a prior request.

Useful for rendering a form-wide error summary banner.

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.