schematools 0.22.5

Tools for codegen, preprocessing and validation of json-schema and openapi spec
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

use crate::{
    codegen::jsonschema::{JsonSchemaExtractOptions, ModelContainer},
    error::Error,
    resolver::SchemaResolver,
    scope::SchemaScope,
};
use serde::Serialize;
use serde_json::Map;
use serde_json::Value;

#[derive(Debug, Serialize, Clone)]
pub struct RequestBody {
    #[serde(rename = "models")]
    pub models: Option<super::MediaModelsContainer>,

    #[serde(rename = "required")]
    pub required: bool,

    #[serde(rename = "description")]
    pub description: Option<String>,
}

pub fn extract(
    node: &Map<String, Value>,
    scope: &mut SchemaScope,
    mcontainer: &mut ModelContainer,
    resolver: &SchemaResolver,
    options: &JsonSchemaExtractOptions,
) -> Result<Option<RequestBody>, Error> {
    match node.get("requestBody") {
        Some(body) => {
            scope.property("requestBody");
            let body = extract_requestbody(body, scope, mcontainer, resolver, options)?;
            scope.pop();

            Ok(body)
        }
        None => Ok(None),
    }
}

pub fn extract_requestbody(
    node: &Value,
    scope: &mut SchemaScope,
    mcontainer: &mut ModelContainer,
    resolver: &SchemaResolver,
    options: &JsonSchemaExtractOptions,
) -> Result<Option<RequestBody>, Error> {
    resolver.resolve(node, scope, |node, scope| match node {
        Value::Object(ref data) => {
            log::trace!("{}", scope);

            let required = data
                .get("required")
                .map(|s| s.as_bool().unwrap())
                .unwrap_or(false);

            let description = data.get("description").map(|v| {
                v.as_str()
                    .map(|s| s.lines().collect::<Vec<_>>().join(" "))
                    .unwrap()
            });

            scope.glue("request").glue("body");

            let model = super::get_content(data, scope, mcontainer, resolver, options)
                .map_or(Ok(None), |v| v.map(Some));

            scope.reduce(2);

            Ok(Some(RequestBody {
                models: model?,
                description,
                required,
            }))
        }
        _ => Err(Error::CodegenInvalidEndpointProperty(
            "requestBody".to_string(),
            scope.to_string(),
        )),
    })
}