Struct RequestBuilder 

pub struct RequestBuilder { /* private fields */ }

Builder for constructing Request instances.

Provides a fluent API for building HTTP requests with optional parameters.

Examples

use reinhardt_http::Request;
use hyper::Method;

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/users?page=1")
    .build()
    .unwrap();

assert_eq!(request.method, Method::GET);
assert_eq!(request.path(), "/api/users");
assert_eq!(request.query_params.get("page"), Some(&"1".to_string()));

Implementations

impl RequestBuilder

pub fn method(self, method: Method) -> Self

Set the HTTP method.

Examples

use reinhardt_http::Request;
use hyper::Method;

let request = Request::builder()
    .method(Method::POST)
    .uri("/api/users")
    .build()
    .unwrap();

assert_eq!(request.method, Method::POST);

pub fn uri<T>(self, uri: T) -> Self

where T: TryInto<Uri>, T::Error: Display,

Set the request URI.

Accepts either a &str or Uri. Query parameters will be automatically parsed.

Examples

use reinhardt_http::Request;
use hyper::Method;

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/users?page=1&limit=10")
    .build()
    .unwrap();

assert_eq!(request.path(), "/api/users");
assert_eq!(request.query_params.get("page"), Some(&"1".to_string()));
assert_eq!(request.query_params.get("limit"), Some(&"10".to_string()));

pub fn version(self, version: Version) -> Self

Set the HTTP version.

Defaults to HTTP/1.1 if not specified.

Examples

use reinhardt_http::Request;
use hyper::{Method, Version};

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/users")
    .version(Version::HTTP_2)
    .build()
    .unwrap();

assert_eq!(request.version, Version::HTTP_2);

pub fn headers(self, headers: HeaderMap) -> Self

Set the request headers.

Replaces all existing headers.

Examples

use reinhardt_http::Request;
use hyper::{Method, HeaderMap, header};

let mut headers = HeaderMap::new();
headers.insert(header::CONTENT_TYPE, "application/json".parse().unwrap());

let request = Request::builder()
    .method(Method::POST)
    .uri("/api/users")
    .headers(headers.clone())
    .build()
    .unwrap();

assert_eq!(request.headers.get(header::CONTENT_TYPE).unwrap(), "application/json");

pub fn header<K, V>(self, key: K, value: V) -> Self

where K: IntoHeaderName, V: TryInto<HeaderValue>, V::Error: Display,

Add a single header to the request.

Examples

use reinhardt_http::Request;
use hyper::{Method, header};

let request = Request::builder()
    .method(Method::POST)
    .uri("/api/users")
    .header(header::CONTENT_TYPE, "application/json")
    .header(header::AUTHORIZATION, "Bearer token123")
    .build()
    .unwrap();

assert_eq!(request.headers.get(header::CONTENT_TYPE).unwrap(), "application/json");
assert_eq!(request.headers.get(header::AUTHORIZATION).unwrap(), "Bearer token123");

pub fn body(self, body: Bytes) -> Self

Set the request body.

Examples

use reinhardt_http::Request;
use hyper::Method;
use bytes::Bytes;

let body = Bytes::from(r#"{"name":"Alice"}"#);
let request = Request::builder()
    .method(Method::POST)
    .uri("/api/users")
    .body(body.clone())
    .build()
    .unwrap();

assert_eq!(request.body(), &body);

pub fn secure(self, is_secure: bool) -> Self

Set whether the request is secure (HTTPS).

Defaults to false if not specified.

Examples

use reinhardt_http::Request;
use hyper::Method;

let request = Request::builder()
    .method(Method::GET)
    .uri("/")
    .secure(true)
    .build()
    .unwrap();

assert!(request.is_secure());
assert_eq!(request.scheme(), "https");

pub fn remote_addr(self, addr: SocketAddr) -> Self

Set the remote address of the client.

Examples

use reinhardt_http::Request;
use hyper::Method;
use std::net::{SocketAddr, IpAddr, Ipv4Addr};

let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
let request = Request::builder()
    .method(Method::GET)
    .uri("/")
    .remote_addr(addr)
    .build()
    .unwrap();

assert_eq!(request.remote_addr, Some(addr));

pub fn parser<P: Parser + 'static>(self, parser: P) -> Self

Add a parser to the request.

Parsers are used to parse the request body into specific formats. The parser will be boxed internally.

Examples

use reinhardt_http::Request;
use hyper::Method;

let request = Request::builder()
    .method(Method::POST)
    .uri("/api/users")
    .parser(JsonParser::new())
    .build()
    .unwrap();

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

Set path parameters (used for testing views without router).

This is primarily useful in test environments where you need to simulate path parameters that would normally be extracted by the router.

Examples

use reinhardt_http::Request;
use hyper::Method;
use std::collections::HashMap;

let mut params = HashMap::new();
params.insert("id".to_string(), "42".to_string());

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/users/42")
    .path_params(params)
    .build()
    .unwrap();

assert_eq!(request.path_params.get("id"), Some(&"42".to_string()));

pub fn build(self) -> Result<Request, String>

Build the final Request instance.

Returns an error if the URI is missing.

Examples

use reinhardt_http::Request;
use hyper::Method;

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/users")
    .build()
    .unwrap();

assert_eq!(request.method, Method::GET);
assert_eq!(request.path(), "/api/users");

Trait Implementations

impl Default for RequestBuilder

fn default() -> Self

Returns the “default value” for a type.