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 crate::parser::{Request, SchemaType};
use std::collections::{BTreeMap, BTreeSet};

/// Prepared registry data used by the Dart renderer.
pub struct ModelData {
    pub definitions: BTreeMap<String, SchemaType>,
    pub names: BTreeSet<String>,
}

/// Collects model definitions and referenced model names from parsed requests.
pub fn prepare_model_data(requests: &[Request]) -> ModelData {
    let mut model_definitions: BTreeMap<String, SchemaType> = BTreeMap::new();
    let mut model_names: BTreeSet<String> = BTreeSet::new();

    for req in requests {
        add_models_from_request(req, &mut model_definitions, &mut model_names);
    }

    for model_name in model_definitions.keys() {
        model_names.insert(model_name.to_string());
    }

    ModelData {
        definitions: model_definitions,
        names: model_names,
    }
}

/// Processes all schema-carrying parts of a request and updates model registries.
fn add_models_from_request(
    req: &Request,
    model_definitions: &mut BTreeMap<String, SchemaType>,
    model_names: &mut BTreeSet<String>,
) {
    add_models_from_params(req, model_names);
    add_models_from_body(req, model_definitions, model_names);
    add_models_from_responses(req, model_definitions, model_names);
}

/// Collects model references from operation parameters.
fn add_models_from_params(req: &Request, model_names: &mut BTreeSet<String>) {
    if let Some(params) = &req.params {
        for param in params {
            if let Some(schema_type) = &param.schema_type {
                collect_ref_names(schema_type, model_names);
            }
        }
    }
}

/// Collects model definitions and references from request body schema.
fn add_models_from_body(
    req: &Request,
    model_definitions: &mut BTreeMap<String, SchemaType>,
    model_names: &mut BTreeSet<String>,
) {
    if let Some(body) = &req.body {
        register_named_schema(
            body.schema_name.as_ref(),
            body.schema_type.as_ref(),
            model_definitions,
            model_names,
        );

        if let Some(schema_type) = &body.schema_type {
            collect_ref_names(schema_type, model_names);
        }
    }
}

/// Collects model definitions and references from response schemas.
fn add_models_from_responses(
    req: &Request,
    model_definitions: &mut BTreeMap<String, SchemaType>,
    model_names: &mut BTreeSet<String>,
) {
    if let Some(responses) = &req.responses {
        for response in responses.values() {
            register_named_schema(
                response.schema_name.as_ref(),
                response.schema_type.as_ref(),
                model_definitions,
                model_names,
            );

            if let Some(schema_type) = &response.schema_type {
                collect_ref_names(schema_type, model_names);
            }
        }
    }
}

/// Registers a named schema definition when both name and schema are available.
fn register_named_schema(
    schema_name: Option<&String>,
    schema_type: Option<&SchemaType>,
    model_definitions: &mut BTreeMap<String, SchemaType>,
    model_names: &mut BTreeSet<String>,
) {
    let Some(name) = schema_name else {
        return;
    };

    model_names.insert(name.clone());

    if let Some(schema_type) = schema_type {
        model_definitions
            .entry(name.clone())
            .or_insert_with(|| schema_type.clone());
    }
}

/// Traverses a schema tree and collects all `$ref` model names.
fn collect_ref_names(schema: &SchemaType, names: &mut BTreeSet<String>) {
    match schema {
        SchemaType::Ref(name) => {
            names.insert(name.clone());
        }
        SchemaType::Array(inner) => collect_ref_names(inner, names),
        SchemaType::Object(obj) => {
            for value in obj.properties.values() {
                collect_ref_names(value, names);
            }
        }
        SchemaType::OneOf(variants)
        | SchemaType::AnyOf(variants)
        | SchemaType::AllOf(variants) => {
            for variant in variants {
                collect_ref_names(variant, names);
            }
        }
        SchemaType::Primitive(_) | SchemaType::Unknown => {}
    }
}