kayto 0.1.10

Fast OpenAPI parser that turns imperfect specs into a stable output schema with actionable diagnostics.
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

use serde::Deserialize;
use std::collections::BTreeMap;
use strum::Display;
use strum_macros::EnumString;

/// HTTP method variants used as keys in the parsed path map.
#[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Deserialize, Debug, EnumString, Display)]
#[serde(rename_all = "lowercase")]
#[strum(serialize_all = "lowercase")]
pub enum MethodVariant {
    GET,
    POST,
    PUT,
    PATCH,
    DELETE,
}

/// OpenAPI primitive and container schema types.
#[derive(Hash, PartialEq, Eq, Deserialize, Debug, EnumString, Display, Clone)]
#[serde(rename_all = "lowercase")]
#[strum(serialize_all = "lowercase")]
pub enum SchemaType {
    STRING,
    NUMBER,
    INTEGER,
    BOOLEAN,
    ARRAY,
    OBJECT,
    NULL,
}

/// Raw OpenAPI schema node as it appears in the source document.
#[derive(Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Schema {
    #[serde(rename = "$ref")]
    pub reference: Option<String>,
    #[serde(rename = "type")]
    pub type_name: Option<SchemaType>,
    #[serde(rename = "oneOf")]
    pub one_of: Option<Vec<Schema>>,
    #[serde(rename = "anyOf")]
    pub any_of: Option<Vec<Schema>>,
    #[serde(rename = "allOf")]
    pub all_of: Option<Vec<Schema>>,
    pub description: Option<String>,
    #[serde(rename = "default")]
    pub default_value: Option<serde_json::Value>,
    pub nullable: Option<bool>,
    pub format: Option<String>,
    pub required: Option<Vec<String>>,
    pub properties: Option<BTreeMap<String, Option<Schema>>>,
    #[serde(rename = "enum")]
    pub enum_variants: Option<Vec<serde_json::Value>>,
    pub items: Option<Box<Schema>>,
}

/// Raw OpenAPI method parameter node (inline or via `$ref`).
#[derive(Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct MethodParams {
    #[serde(rename = "$ref")]
    pub reference: Option<String>,
    pub name: Option<String>,
    #[serde(rename = "in")]
    pub location: Option<String>,
    pub description: Option<String>,
    pub required: Option<bool>,
    pub schema: Option<Schema>,
    #[serde(rename = "type")]
    pub type_name: Option<SchemaType>,
    #[serde(rename = "default")]
    pub default_value: Option<serde_json::Value>,
    pub nullable: Option<bool>,
    pub format: Option<String>,
    #[serde(rename = "enum")]
    pub enum_variants: Option<Vec<serde_json::Value>>,
    pub items: Option<Box<Schema>>,
}

/// Media-type payload wrapper that may contain a schema.
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Content {
    pub schema: Option<Schema>,
}

/// `content` section with dynamic media-type keys.
#[derive(Deserialize, Debug)]
pub struct ResponseContent {
    #[serde(flatten)]
    pub media_types: BTreeMap<String, Content>,
}

/// Raw OpenAPI response object.
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Response {
    pub content: Option<ResponseContent>,
}

/// Raw OpenAPI operation object.
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Method {
    pub operation_id: Option<String>,
    pub parameters: Option<Vec<MethodParams>>,
    pub request_body: Option<Response>,
    pub responses: Option<BTreeMap<String, Option<Response>>>,
}

/// Path item methods indexed by method variant.
pub type PathMethods = Option<BTreeMap<MethodVariant, Method>>;

/// Top-level paths indexed by URL template.
pub type Paths = Option<BTreeMap<String, PathMethods>>;

/// Shared components section with reusable schemas/parameters.
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Components {
    pub schemas: Option<BTreeMap<String, Option<Schema>>>,
    pub definitions: Option<BTreeMap<String, Option<Schema>>>,
    pub parameters: Option<BTreeMap<String, Option<MethodParams>>>,
}

/// Root OpenAPI document model used by the parser layer.
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct OpenAPI {
    pub paths: Paths,
    pub components: Option<Components>,
    pub parameters: Option<BTreeMap<String, Option<MethodParams>>>,
}