rwf2/Rocket
Rocket
Rocket is a type-safe web framework designed for building server-side applications. It provides a high-performance asynchronous routing engine that maps incoming network traffic to concurrent handler functions, while managing the full lifecycle of web requests. The framework emphasizes compile-time verification, ensuring that request parameters, response types, and routing logic remain consistent throughout the development process.
The framework distinguishes itself through its use of request guards, which act as a validation layer to intercept and transform incoming data into structured types before it reaches core business logic. It also features an integrated testing suite that allows developers to dispatch internal requests and verify application behavior without requiring an active network connection. Additionally, the framework supports thread-safe state management, enabling the sharing of global resources across the application while maintaining safe, concurrent access within individual handlers.
Beyond its core routing and validation capabilities, the framework includes tools for automated configuration management, which merges settings from multiple sources into structured objects. It also provides extensive support for response handling, including asynchronous streaming, dynamic template rendering, and the ability to derive custom response logic for specific data types. These features are complemented by lifecycle hooks that allow for the execution of custom logic during application startup, shutdown, or request processing phases.
Features
- Request Routers - The framework extracts variable segments from URL paths into function arguments using type-safe guards to automatically parse and validate incoming request data.
- Route Handlers - The framework maps specific HTTP methods to handler functions using attributes while automatically managing method reinterpretation for form-based requests and standard operations.
- Type-Safe Web Frameworks - Building robust web services where request parameters, body data, and responses are automatically validated against defined data structures at compile-time.
- Request Guards - The framework protects route handlers with custom validation policies that execute before the handler to ensure only authorized or valid requests reach business logic.
- Dependency Injection Containers - The framework registers thread-safe values at application startup to share global state across the system and retrieve them within request handlers using dedicated guards.
- Asynchronous Request Routers - A high-performance engine that maps incoming network traffic to concurrent handler functions while managing the full lifecycle of web requests.
- Connection Pools - The framework maintains database connections using connection pools and request guards to retrieve active database handles within route handler functions when required.
- API Testing - The framework inspects status codes, headers, and body content using built-in tools to confirm that the application returns the expected information during automated test sequences.
- Test Configuration - Verifying application logic and route behavior by dispatching internal requests and validating responses without needing to start a network server.
- Request Body Deserializers - The framework maps incoming request bodies to typed structures using automated deserialization to handle JSON payloads or streaming file uploads through secure guards.
- Request Parameter Parsers - The framework parses and validates URL query strings into typed data structures to ensure incoming request parameters match expected formats before processing.
- Response Streaming - The framework supports sending asynchronous data to clients using specialized responders for infinite streams, file serving, or real-time communication patterns.
- Route Generators - The framework creates type-safe links for application routes at compile-time to ensure parameter correctness and automatic formatting for dynamic route values.
- Request Validation Middleware - Intercepting incoming data to enforce access policies and transform raw input into validated application types before reaching core business logic.
- Response Handlers - The framework provides standard responders for strings and results to automatically manage status codes, content types, and error handling.
- Test Runners - The framework runs multiple requests concurrently using asynchronous methods to verify that application logic handles parallel operations correctly while maintaining stability during testing.
- Form Parsers - The framework converts incoming form submissions into structured types automatically while supporting complex nesting, collections, and multipart data with built-in error reporting.
- Template Engines - The framework generates dynamic web pages by providing context data to template engines that automatically discover and process files based on extensions.
- Configuration Management Systems - Centralizing settings from multiple sources like environment variables and files into a unified, type-safe configuration object for different deployment environments.
- Functional Lifecycle Hooks - The framework enables executing logic during lifecycle events using simple functions or closures without requiring full interface or trait implementations.
- Cookie Handlers - The framework handles client-side cookies using built-in guards that support both standard storage and encrypted private data for secure information exchange.
- Request Contexts - The framework stores data locally within the scope of a single request to ensure values are computed or generated at most once per request cycle.
- Request Forwarding Mechanisms - The framework passes requests to subsequent matching routes based on priority or type-mismatch to enable flexible fallback logic when primary handlers fail.
- Responder Derivation - The framework automatically generates response logic for custom types to declare status codes, content types, and headers without manual implementation code.
