schemars 1.2.1

Generate JSON Schemas from Rust code
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

use crate::prelude::*;

mod external {
    #[derive(Default)]
    pub struct Duration {
        pub secs: i64,
        pub nanos: i32,
    }

    #[allow(dead_code)]
    pub enum Or<A, B> {
        A(A),
        B(B),
    }

    pub struct Str<'a>(pub &'a str);
}

#[derive(JsonSchema, Deserialize, Serialize)]
#[serde(remote = "external::Duration")]
struct DurationDef {
    secs: i64,
    nanos: i32,
}

#[derive(JsonSchema, Deserialize, Serialize, Default)]
struct Process {
    #[serde(with = "DurationDef")]
    wall_time: external::Duration,
}

#[test]
fn simple() {
    test!(Process)
        .assert_snapshot()
        .assert_allows_ser_roundtrip_default()
        .assert_matches_de_roundtrip(arbitrary_values());
}

#[derive(JsonSchema, Deserialize, Serialize)]
#[serde(untagged, remote = "external::Or")]
#[schemars(rename = "{A}_or_{B}")]
enum OrDef<A, B> {
    A(A),
    B(B),
}

#[derive(JsonSchema, Deserialize, Serialize)]
#[serde(bound = "T: serde::de::DeserializeOwned + Serialize")]
struct TypeParam<T> {
    #[serde(with = "OrDef::<u8, bool>")]
    byte_or_bool: external::Or<u8, bool>,
    #[serde(with = "OrDef::<(), T>")]
    unit_or_t: external::Or<(), T>,
}

#[test]
fn type_param() {
    test!(TypeParam<String>)
        .assert_snapshot()
        .assert_allows_ser_roundtrip([
            TypeParam {
                byte_or_bool: external::Or::A(123),
                unit_or_t: external::Or::A(()),
            },
            TypeParam {
                byte_or_bool: external::Or::B(true),
                unit_or_t: external::Or::B("test".to_owned()),
            },
        ])
        .assert_matches_de_roundtrip(arbitrary_values());
}

#[allow(dead_code)]
#[derive(JsonSchema, Deserialize, Serialize)]
#[serde(remote = "external::Str")]
struct StrDef<'a>(&'a str);

#[derive(JsonSchema, Deserialize, Serialize)]
struct LifetimeParam<'a> {
    #[serde(borrow, with = "StrDef")]
    s: external::Str<'a>,
}

#[test]
fn lifetime_param() {
    let s = external::Str("test");

    test!(LifetimeParam)
        .assert_snapshot()
        .assert_allows_ser_only([LifetimeParam { s }]);
}