utoipauto 0.2.0

Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
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

#![allow(dead_code)]

use std::borrow::Cow;
use utoipa::openapi::schema::SchemaType;
use utoipa::openapi::{Response, ResponseBuilder, Type};
// This code is used in the tests
use utoipa::{
    openapi::{ObjectBuilder, RefOr, Schema},
    PartialSchema, ToResponse, ToSchema,
};
use utoipauto_macro::utoipa_ignore;

#[derive(ToSchema)]
pub struct ModelSchema;
#[derive(ToResponse)]
pub struct ModelResponse;

#[utoipa_ignore]
#[derive(ToSchema)]
pub struct IgnoredModelSchema;

// Manual implementation of ToSchema
pub struct ModelSchemaImpl;

impl PartialSchema for ModelSchemaImpl {
    fn schema() -> RefOr<Schema> {
        ObjectBuilder::new().schema_type(SchemaType::Type(Type::String)).into()
    }
}

impl ToSchema for ModelSchemaImpl {
    fn name() -> Cow<'static, str> {
        Cow::Borrowed("ModelSchemaImpl")
    }
}

// Manual implementation of utoipa::ToSchema
pub struct ModelSchemaImplFullName;

impl PartialSchema for ModelSchemaImplFullName {
    fn schema() -> RefOr<Schema> {
        ObjectBuilder::new().schema_type(SchemaType::Type(Type::String)).into()
    }
}

impl utoipa::ToSchema for ModelSchemaImplFullName {
    fn name() -> Cow<'static, str> {
        Cow::Borrowed("ModelSchemaImplFullName")
    }
}

// Manual implementation of ToSchema
pub struct ModelResponseImpl;

impl<'s> ToResponse<'s> for ModelResponseImpl {
    fn response() -> (&'s str, RefOr<Response>) {
        (
            "ModelResponseImpl",
            ResponseBuilder::new().description("A manual response").into(),
        )
    }
}

// Manual implementation of utoipa::ToResponse
pub struct ModelResponseImplFullName;

impl<'s> utoipa::ToResponse<'s> for ModelResponseImplFullName {
    fn response() -> (&'s str, RefOr<Response>) {
        (
            "ModelResponseImplFullName",
            ResponseBuilder::new().description("A manual response").into(),
        )
    }
}