huio 0.1.1

HTTP Framework based on Actix-Web
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

# huio

HTTP framework for Rust built on top of [Actix-Web](https://actix.rs/).

## Installation

```toml
[dependencies]
huio = "0.1.0"
tokio = { version = "1", features = ["full"] }
```

## Quick start

```rust
use huio::{HuIOServer, http::{Request, Response}, routing::{Dispatcher, Router}};

async fn hello(_req: Request) -> Response {
    Response::ok("Hello, world!")
}

#[tokio::main]
async fn main() {
    let router = Router::new("/").get(hello);

    HuIOServer::default()
        .hostname("0.0.0.0")
        .port(8080)
        .router(Dispatcher::new(router))
        .build()
        .unwrap()
        .run()
        .await
        .unwrap();
}
```

## Routing

```rust
use huio::routing::Router;

let api = Router::new("/users")
    .get(list_users)
    .post(create_user)
    .nest(
        Router::new("/:id")
            .get(get_user)
            .put(update_user)
            .delete(delete_user),
    );

let root = Router::new("/").nest(api);
```

Path parameters use the `:name` syntax and are accessed via `req.param("name")`. Trailing slashes are normalized automatically. `HEAD` requests are handled automatically if a `GET` handler is registered.

## Request

```rust
req.path()           // &str
req.method           // HttpMethod
req.param("id")      // Option<&str>  — path parameter
req.query("page")    // Option<&str>  — query string parameter
req.query_all()      // &HashMap<String, String>
req.headers          // HashMap<String, String>
req.body             // Vec<u8>
```

## Response

```rust
Response::ok("text")               // 200 text/plain
Response::json(value)              // 200 application/json (accepts any impl Serialize)
Response::not_found()              // 404
Response::method_not_allowed(&[])  // 405
Response::internal_error()         // 500

// Builder methods (chainable):
Response::ok("text")
    .status(201).unwrap()
    .header("X-Custom", "value")
```

## Middleware

`Middleware` is `Arc<dyn Fn(Request, Next) -> BoxFuture<Response> + Send + Sync>`.  
Middlewares are applied per-router and inherited by nested routers.

```rust
use std::sync::Arc;
use huio::http::Middleware;

let logger: Middleware = Arc::new(|req, next| {
    Box::pin(async move {
        println!("→ {:?} {}", req.method, req.path());
        let start = std::time::Instant::now();
        let res = next(req).await;
        println!("← {} {:?}", res.status_code(), start.elapsed());
        res
    })
});

let router = Router::new("/api")
    .middleware(logger)
    .get(handler);
```

## Server configuration

```rust
HuIOServer::default()
    .hostname("127.0.0.1")   // default: "0.0.0.0"
    .port(3000)               // default: 80
    .basepath("/v1")          // optional base prefix
    .router(Dispatcher::new(root))
    .build()?
    .run()
    .await?;
```

`build()` returns `HuIOServer<Ready>`, which exposes `.hostname()`, `.port()`, `.basepath()` getters and `.run()`.

## HTTP methods

`GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS` — registered via same-named builder methods on `Router`.

## License

MIT