rovo 0.4.4

A drop-in replacement for axum::Router with effortless OpenAPI documentation
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
131
132
133
134
135
136
137
138
139
140

use rovo::aide::axum::IntoApiResponse;
use rovo::schemars::JsonSchema;
use rovo::{
    extract::{Path, State},
    http::StatusCode,
    response::{IntoResponse, Json},
};
use rovo::{routing::get, rovo, Router};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Clone)]
#[allow(dead_code)]
struct AppState {
    value: String,
}

#[derive(Serialize, Deserialize, JsonSchema, Clone, Debug, PartialEq)]
struct Item {
    id: Uuid,
    name: String,
}

impl Default for Item {
    fn default() -> Self {
        Self {
            id: Uuid::nil(),
            name: "Test Item".to_string(),
        }
    }
}

#[derive(Deserialize, JsonSchema)]
struct ItemId {
    id: Uuid,
}

/// Get an item.
///
/// This endpoint retrieves an item by ID.
///
/// # Responses
///
/// 200: Json<Item> - Item found successfully
/// 404: () - Item not found
///
/// # Examples
///
/// 200: Item::default()
#[rovo]
async fn get_item(
    State(_state): State<AppState>,
    Path(ItemId { id }): Path<ItemId>,
) -> impl IntoApiResponse {
    if id == Uuid::nil() {
        Json(Item::default()).into_response()
    } else {
        StatusCode::NOT_FOUND.into_response()
    }
}

/// Simple handler.
///
/// # Responses
///
/// 200: Json<String> - Success
#[rovo]
async fn simple_handler(State(_state): State<AppState>) -> impl IntoApiResponse {
    Json("ok".to_string())
}

/// Multiple response codes.
///
/// # Responses
///
/// 200: Json<Item> - Success response
/// 400: () - Bad request
/// 401: () - Unauthorized
/// 500: () - Internal server error
#[rovo]
async fn multi_response(State(_state): State<AppState>) -> impl IntoApiResponse {
    Json(Item::default())
}

#[test]
fn test_macro_generates_docs_function() {
    // The macro should generate a struct that implements IntoApiMethodRouter
    let state = AppState {
        value: "test".to_string(),
    };

    // This should compile using the new routing API
    let _router: ::axum::Router = Router::<AppState>::new()
        .route("/items/{id}", get(get_item))
        .route("/simple", get(simple_handler))
        .route("/multi", get(multi_response))
        .with_state(state)
        .finish();
}

#[test]
fn test_docs_function_callable() {
    use rovo::aide::openapi::Operation;
    use rovo::aide::transform::TransformOperation;

    // Create a mock operation
    let mut operation = Operation::default();
    let transform = TransformOperation::new(&mut operation);

    // The __docs function should still be accessible for testing
    let _result = get_item::__docs(transform);
}

#[test]
fn test_multiple_handlers_compile() {
    // Test that multiple handlers with different signatures work
    let state = AppState {
        value: "test".to_string(),
    };

    let _router: ::axum::Router = Router::<AppState>::new()
        .route("/a", get(simple_handler))
        .route("/b", get(multi_response))
        .route("/c/{id}", get(get_item))
        .with_state(state)
        .finish();
}

#[test]
fn test_handler_with_path_params() {
    // Verify that handlers with path parameters compile correctly
    let state = AppState {
        value: "test".to_string(),
    };

    let _router: ::axum::Router = Router::<AppState>::new()
        .route("/items/{id}", get(get_item))
        .with_state(state)
        .finish();
}