json-resp 0.1.2

A utility to generate easy json response/errors
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

use std::{collections::BTreeMap, marker::PhantomData};

use utoipa::{
    openapi::{
        ContentBuilder, KnownFormat, ObjectBuilder, OneOfBuilder, Ref, RefOr, Response,
        ResponseBuilder, ResponsesBuilder, Schema, SchemaFormat, SchemaType,
    },
    IntoResponses, ToSchema,
};

use crate::{JsonResponse, Nothing};

/// A struct that can be used to combine 2 errors with the same status code
pub struct CombineErrors<E1, E2>(PhantomData<dyn Fn() -> (E1, E2)>);

impl<'__r, E1, E2> IntoResponses for CombineErrors<E1, E2>
where
    E1: ToSchema<'__r> + IntoResponses,
    E2: ToSchema<'__r> + IntoResponses,
{
    fn responses() -> BTreeMap<String, RefOr<Response>> {
        let status1 = match E1::responses().into_iter().next() {
            Some((status1, _)) => status1,
            _ => {
                panic!("Not supported")
            }
        };
        let status2 = match E2::responses().into_iter().next() {
            Some((status1, _)) => status1,
            _ => {
                panic!("Not supported")
            }
        };

        debug_assert_eq!(
            status1, status2,
            "CombineErrors can only be used for errors with same status"
        );

        let schema: RefOr<Schema> = OneOfBuilder::new()
            .item(Ref::from_schema_name(E1::schema().0))
            .item(Ref::from_schema_name(E2::schema().0))
            .into();

        ResponsesBuilder::new()
            .response(
                status1,
                ResponseBuilder::new()
                    .content("json", ContentBuilder::new().schema(schema).build()),
            )
            .build()
            .into()
    }
}

impl<'__r, T, M> ToSchema<'__r> for JsonResponse<T, M>
where
    T: ToSchema<'__r>,
    M: ToSchema<'__r>,
{
    fn schema() -> (&'__r str, RefOr<Schema>) {
        let null: RefOr<Schema> = ObjectBuilder::new()
            .schema_type(SchemaType::Object)
            .nullable(true)
            .default(Some(serde_json::Value::Null))
            .example(Some(serde_json::Value::Null))
            .build()
            .into();

        let obj = ObjectBuilder::new()
            .property(
                "status",
                ObjectBuilder::new()
                    .schema_type(SchemaType::Integer)
                    .format(Some(SchemaFormat::KnownFormat(KnownFormat::Int32)))
                    .example(Some(200.into())),
            )
            .required("status");

        let obj = match T::schema() {
            ("", _) => obj.property("content", null.clone()),
            (name, _) => obj
                .property("content", RefOr::Ref(Ref::from_schema_name(name)))
                .required("content"),
        };

        let obj = match M::schema() {
            ("", _) => obj.property("meta", null.clone()),
            (name, _) => obj
                .property("meta", RefOr::Ref(Ref::from_schema_name(name)))
                .required("meta"),
        };

        ("JsonResponse", obj.into())
    }
}

impl ToSchema<'static> for Nothing {
    fn schema() -> (&'static str, RefOr<Schema>) {
        // A dummy implementation to make it recognizable by JsonResponse
        ("", ObjectBuilder::new().into())
    }
}