ohkami 0.24.9

A performant, declarative, and runtime-flexible web framework for Rust
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

//! # Claws - handler parts for desclarative request/response handling
//!
//! Claws provides various components for typed, declarative way to
//! extract request data and construct response data:
//!
//! - [`body`]: for handling request and response bodies
//! - [`header`]: for handling request headers
//! - [`param`]: for handling request parameters (path and query)
//! - [`status`]: for handling response HTTP status codes
//!
//! See individual modules or each component's documentation for details.
//!
//! ## Example
//!
//! ```
//! use ohkami::claw::{Path, Json, status};
//! use ohkami::serde::{Serialize, Deserialize};
//!
//! #[derive(Deserialize)]
//! struct CreateUserRequest<'req> {
//!     name: &'req str,
//! }
//!
//! #[derive(Serialize)]
//! struct User {
//!     id: u64,
//!     name: String,
//! }
//!
//! # enum AppError {}
//! # impl ohkami::IntoResponse for AppError {
//! #     fn into_response(self) -> ohkami::Response {
//! #         todo!()
//! #     }
//! # }
//!
//! async fn get_user(
//!     // Extract a path parameter as `u64`
//!     Path(id): Path<u64>,
//!             // Serialize `User` into `application/json` response body
//! ) -> Result<Json<User>, AppError> {
//!     Ok(Json(User {
//!         id,
//!         name: todo!(),
//!     }))
//! }
//!
//! async fn create_user(
//!     // Extract `application/json` request body
//!     Json(body): Json<CreateUserRequest<'_>>,
//!             // Serialize `User` into `application/json` response body
//!             // with `201 Created` status
//! ) -> Result<status::Created<Json<User>>, AppError> {
//!     Ok(status::Created(Json(User {
//!         id: todo!(),
//!         name: body.name.to_owned(),
//!     })))
//! }
//! ```

pub mod content;
pub mod header;
pub mod param;
pub mod status;

pub use content::Json;
pub use header::Cookie;
pub use param::{Path, Query};

#[cold]
#[inline(never)]
fn reject(msg: impl std::fmt::Display) -> crate::Response {
    crate::Response::BadRequest().with_text(msg.to_string())
}

#[cfg(feature = "openapi")]
mod bound {
    use crate::openapi;
    use serde::{Deserialize, Serialize};

    pub trait Schema: openapi::Schema {}
    impl<S: openapi::Schema> Schema for S {}

    pub trait Incoming<'req>: Deserialize<'req> + openapi::Schema {}
    impl<'req, T> Incoming<'req> for T where T: Deserialize<'req> + openapi::Schema {}

    pub trait Outgoing: Serialize + openapi::Schema {}
    impl<T> Outgoing for T where T: Serialize + openapi::Schema {}
}
#[cfg(not(feature = "openapi"))]
mod bound {
    use serde::{Deserialize, Serialize};

    pub trait Schema {}
    impl<S> Schema for S {}

    pub trait Incoming<'req>: Deserialize<'req> {}
    impl<'req, T> Incoming<'req> for T where T: Deserialize<'req> {}

    pub trait Outgoing: Serialize {}
    impl<T> Outgoing for T where T: Serialize {}
}