simbld-http 1.0.0

A comprehensive HTTP response library for Rust.
Documentation

🆕 Changelog (Version 1.0.0)

  • New Architecture: Macro System
Introduction of a complete macro system for generating HTTP responses

generate_response!: Central macro for dynamically creating customized HTTP responses. define_status!: Definition of new status codes with their associated descriptions. response_builder!: Generation of fluid builders for constructing complex responses. The macro system offers increased expressiveness and flexibility while significantly reducing verbosity.

  • Response Model Redesign
Replacement of CustomResponse with the new HttpResponse

HttpResponse<T>: Generic structure allowing for strongly-typed response bodies. ResponseBuilder: Fluid API for progressive construction of HTTP responses. This redesign improves ergonomics and type safety while offering more flexibility.

  • Native Integration of Asynchronous Traits
Complete support for modern Rust asynchronous patterns

AsyncResponder: Trait allowing Futures to be returned as HTTP responses. StreamResponse: Support for streaming response bodies for voluminous data. The asynchronous integration optimizes performance and reduces resource consumption.

📚 Updated Documentation and Examples

Complete documentation and new examples are available in the project's GitHub repository: (https://github.com/simbld/simbld-http/tree/main/examples)

New Examples
  • Macro Usage: Demonstration of response generation via the new macros.
  • Fluid API: Examples of using the builder API to construct complex responses.
  • Asynchronous Patterns: Integration with Rust and Actix-Web asynchronous features.

🆕 Changelog (Version 0.4.1)

  • New Feature: Unified Response Functions
Added functions returning (u16, &'static str) for all response families

invalid_date_of_birth, invalid_majority, invalid_marital_status, etc.:

Each function returns a tuple containing a status code and a description. The complete list of http codes (official and unofficial) is available in the file: (https://github.com/simbld/simbld-http/blob/main/THE_COMPLETE_LIST_OF_OFFICIAL_AND_UNOFFICIAL_HTTP_CODES.md)

  • Improved Code Consistency
Standardized response functions across all families

All response families now include functions that return a tuple (u16, &'static str) for better consistency and ease of use.

📚 Full Documentation and Examples

Complete examples, including detailed use cases and advanced integrations, are available in the project's GitHub repository

https://github.com/simbld/simbld-http/tree/main/examples
https://github.com/simbld/simbld-http/blob/main/src/responses
https://github.com/simbld/simbld-http/tree/main/src/helpers

Included Examples And Tests

  • Http Interceptor: An.

  • Middleware Integration: Demonstration of integration into an Actix Web server with custom middleware.

  • Response Helpers: Using helpers to create responses with status codes and descriptions.

  • Actix-Web Usage: How to integrate simbld-http with Actix-Web for handling responses and authentication.

  • Unit Testing: Demonstrates how to write unit tests using the new helpers.

🆕 Changelog (Version 0.3.1)

  • New Feature: Actix-Web Integration
Added a CustomResponse compatible with Actix-Web and an authentication middleware

custom_response_handler: Generates custom HTTP responses in an Actix-Web application.

auth_middleware: Manages token validation via query parameters to secure routes.

  • Improved Testing Capabilities
Added test files to enhance code coverage and reliability

status_codes_test.rs: Contains tests to verify the generation of HTTP status codes.

test_helpers.rs: Provides utility functions to capture test outputs.

  • New Helpers Features
Added helpers to create responses with mock data

mock_responses: Defines test responses to facilitate unit testing.

response_functions: Introduces the ResponseFunctions trait with methods to generate response functions.

  • Miscellaneous Improvements
Code optimizations and minor bug fixes
  • Updated Documentation
Examples and documentation have been updated to reflect the new features

🆕 Changelog (Version 0.2.1)

  • New Feature: Cookie Management
Added helpers to include cookies directly in responses

ok_with_cookie: Generate an OK response with an attached cookie. bad_request_with_cookie: Generate a Bad Request response with an attached cookie.

  • New Feature: Dynamic Headers
Added helpers to dynamically add custom headers in responses

ok_with_headers: Generate an OK response with custom headers. bad_request_with_headers: Generate a Bad Request response with custom headers.

  • Middleware Improvement:
The middleware now adds

x-status-description: A description associated with the HTTP status code. x-response-time-ms: The request processing time in milliseconds.

📚 Complete Documentation and Examples

Complete examples, including detailed use cases and advanced integrations, are available in the project's GitHub repository (https://github.com/simbld/simbld-http/tree/main/examples).

Included Examples

  • Basic Usage: An introduction to using simbld-http.

  • Middleware Integration: Demonstration of integration into an Actix Web server with custom middleware.

  • Response Helpers: Using helpers to create responses with cookies or custom headers.

🌟 Simbld-HTTP (v0.1.0)

simbld-http is a modular and comprehensive Rust library designed for managing HTTP response codes. Whether you're building APIs, handling custom response codes, or integrating middleware, Simbld-HTTP provides an organized and extensible framework to simplify your workflow.

✨ Key Features

Support for Standard and Custom HTTP Codes:

Handles all standard HTTP response families: 1xx to 5xx. Extends with custom families: 6xx, 7xx, and 9xx. Includes detailed descriptions for every status code.

Extensive Utilities:

JSON and XML response formatting. Helpers for paginated and generic HTTP responses. Middleware integration for Actix Web.

Easy Extensibility:

Add new families or custom helpers with minimal effort.

🚀 Why Choose Simbld-HTTP?

Developer-Friendly: Intuitive API with detailed documentation. Modular Design: Use only the parts you need for your project. Future-Proof: Easily extend to accommodate evolving HTTP standards and custom needs. Battle-Tested: Includes robust tests to ensure reliability.

📦 Installation

Add simbld-http to your ``Cargo.toml:

[dependencies]
simbld-http = "0.2.0"

📚 Documentation

Local Documentation

Run the following command to generate and open the documentation:

cargo doc --no-deps --open
This will
  • Generate detailed API documentation from inline comments (///).
  • Display all public modules, enums, and methods.
Online Documentation

The full documentation will be available on docs.rs after publishing. Stay tuned for updates!

🔧 Usage Examples

Basic Usage
use simbld_http::responses::ResponsesTypes;

let response = ResponsesTypes::Success(ResponsesSuccessCodes::Ok);
println!("Code: {}, Description: {}", response.get_code(), response.get_str("Description"));
Retrieve a Crawler Code
use simbld_http::responses::ResponsesCrawlerCodes;
use strum::EnumProperty;

fn main() {
    let code = ResponsesCrawlerCodes::ParsingErrorHeader;
    println!(
        "Code: {}, Description: {}",
        code.get_code(),
        code.get_str("Description").unwrap()
    );
}
Run the example with
cargo run --example examples_usage
Using the Middleware
cargo run --example middleware_advanced_usage
Test the middleware response with curl
curl -i http://127.0.0.1:8080/

⚙️ Structure of Families

Family Description
1xx Informational responses (e.g., ContinueRequest, Processing)
2xx Success responses (e.g., OK, Created)
3xx Redirection responses (e.g., Moved Permanently, Temporary Redirect)
4xx Client errors (e.g., Bad Request, Unauthorized)
5xx Server errors (e.g., Internal Server Error, Service Unavailable)
6xx Service operations (e.g., Service Timeout)
7xx Crawler responses (e.g., Rate Limited, Crawl Blocked)
9xx Local API errors (e.g., InsufficientFunds, ExpiredCard)

🤝 Contributing to Simbld-HTTP

We welcome contributions to Simbld-HTTP! Help us make this library the go-to solution for HTTP response code management in Rust.

1 Fork this repository
2 Clone your fork
git clone git@github.com:<your-username>/simbld-http.git
3 Create a branch for your changes
git switch -c feature/<your-feature-name>
4 Test your changes
cargo test
5 Open a pull request

📜 License

This project is licensed under the MIT License. See the LICENSE file for details.