Crate reinhardt_http 

Reinhardt HTTP

HTTP request and response handling for the Reinhardt framework.

This crate provides core HTTP abstractions including typed request and response types, header handling, content negotiation, file uploads, and middleware composition.

Quick Start

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

// Build a request
let request = Request::builder()
    .method(Method::GET)
    .uri("/api/status")
    .version(hyper::Version::HTTP_11)
    .headers(HeaderMap::new())
    .body(bytes::Bytes::new())
    .build()
    .unwrap();

// Create a simple response
let response = Response::ok().with_body("OK");

Architecture

Key modules in this crate:

• request: Typed HTTP request wrapper with builder pattern and trusted proxy support
• response: HTTP response with helpers for JSON, streaming, and error responses
• middleware: Middleware trait and composition chain for request processing
• auth_state: Authentication state extensions stored in request context
• upload: File upload handling (in-memory and temporary file backends)
• chunked_upload: Resumable chunked upload session management
• extensions: Typed request extension storage

Feature Flags

Feature	Default	Description
parsers	enabled	Request body parsing (JSON, Form, Multipart)
messages	disabled	Flash message middleware for session-based notifications
full	disabled	Enables all optional features

Request Construction

Requests are constructed using the builder pattern for type-safe configuration:

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

let request = Request::builder()
    .method(Method::POST)
    .uri("/api/users")
    .version(hyper::Version::HTTP_11)
    .headers(HeaderMap::new())
    .body(bytes::Bytes::from("request body"))
    .build()
    .unwrap();

Response Creation

Responses use helper methods and builder pattern:

use reinhardt_http::Response;

// Using helpers
let response = Response::ok().with_body("Hello, World!");

// With JSON
let json_response = Response::ok()
    .with_json(&serde_json::json!({"status": "success"}))
    .unwrap();

Re-exports

pub use auth_state::AuthState;

pub use chunked_upload::ChunkedUploadError;

pub use chunked_upload::ChunkedUploadManager;

pub use chunked_upload::ChunkedUploadSession;

pub use chunked_upload::UploadProgress;

pub use extensions::Extensions;

pub use middleware::ExcludeMiddleware;

pub use middleware::Handler;

pub use middleware::Middleware;

pub use middleware::MiddlewareChain;

pub use request::Request;

pub use request::RequestBuilder;

pub use request::TrustedProxies;

pub use response::Response;

pub use response::SafeErrorResponse;

pub use response::StreamBody;

pub use response::StreamingResponse;

pub use upload::FileUploadError;

pub use upload::FileUploadHandler;

pub use upload::MemoryFileUpload;

pub use upload::TemporaryFileUpload;

Modules

auth_state

Authentication state tracking for requests. Authentication state stored in request extensions.

chunked_upload

Chunked file upload handling with progress tracking. Chunked upload handling for large files

extensions

Request extension storage for passing data between middleware. Type-safe extensions for Request

middleware

Middleware trait and handler chain. Middleware and handler traits for HTTP request processing.

request

HTTP request type and builder.

response

HTTP response type and builder.

upload

File upload handling and validation. File upload handling functionality

Enums

Error

The main error type for the Reinhardt framework.

Type Aliases

Result

A convenient Result type alias using reinhardt_core::exception::Error as the error type.

ViewResult

A convenient type alias for view/endpoint function return types.