vyuh 0.2.5

Vyuh web framework for Axum and SQLx with handler-first APIs
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

//! OpenAPI response overrides and custom error schemas.
//!
//! Run:
//!
//! ```sh
//! cargo run --example openapi_responses
//! ```

use std::borrow::Cow;

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use vyuh::{
    bundles,
    callables::PatchOp,
    routes::{Json, Methods, RouteConf},
};

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
struct Note {
    id: i64,
    title: String,
}

#[derive(Debug, Clone, Deserialize, JsonSchema)]
struct CreateNote {
    title: String,
}

#[derive(Debug, Clone, Serialize, JsonSchema)]
struct ApiError {
    code: String,
    message: String,
}

// Macro sugar: `returns(...)` becomes the same operation metadata patch that
// direct registration applies with `PatchOp`.
#[bundles::route(
    path = "/notes",
    method = "POST",
    description = "Create a note.",
    returns(status = 201, description = "Created note"),
    returns(
        ty = "Json<ApiError>",
        status = 409,
        description = "A note with this title already exists"
    )
)]
async fn create_note(Json(input): Json<CreateNote>) -> Json<Note> {
    Json(Note {
        id: 1,
        title: input.title,
    })
}

async fn create_note_direct(Json(input): Json<CreateNote>) -> Json<Note> {
    Json(Note {
        id: 2,
        title: input.title,
    })
}

fn main() {
    let direct_route = bundles::route(
        create_note_direct,
        RouteConf {
            name: Cow::Borrowed("create_note_direct"),
            path: Cow::Borrowed("/direct/notes"),
            methods: Methods::POST,
            slash: None,
        },
    )
    .patch(
        PatchOp::new()
            .description("Create a note through direct registration.")
            .ret()
            .status(201)
            .doc("Created note")
            .done()
            .append()
            .status(409)
            .typed::<Json<ApiError>>()
            .doc("A note with this title already exists")
            .done(),
    );

    let bundle = bundles::bundle! {
        create_note,
    }
    .merge(bundles::bundle([direct_route]))
    .with_openapi(
        bundles::OpenApiConf::default()
            .title("Response Override API")
            .spec("/openapi.json"),
    );

    assert_eq!(
        bundle.reverse("create_note", &[]),
        Some("/notes".to_string())
    );
    assert_eq!(
        bundle.reverse("create_note_direct", &[]),
        Some("/direct/notes".to_string())
    );
    println!("OpenAPI response metadata includes macro and PatchOp overrides");
}