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

use crate::spec;

use super::reference_resolution::resolve_parameter_ref;
use super::{issue, try_parse_schema, ParseCtx, ParseIssue, ParsedParameter};

/// Builds a synthetic schema from parameter fields when inline `schema` is absent.
fn schema_from_parameter(param: &spec::MethodParams) -> Option<spec::Schema> {
    match param.schema.as_ref() {
        Some(schema) => Some(schema.clone()),
        None => match param.type_name.as_ref() {
            Some(type_name) => Some(spec::Schema {
                reference: None,
                type_name: Some(type_name.clone()),
                one_of: None,
                any_of: None,
                all_of: None,
                description: param.description.clone(),
                default_value: param.default_value.clone(),
                nullable: param.nullable,
                format: param.format.clone(),
                required: None,
                properties: None,
                enum_variants: param.enum_variants.clone(),
                items: param.items.clone(),
            }),
            None => None,
        },
    }
}

/// Parses operation parameters into IR parameters with resolved schema types.
pub(crate) fn try_parse_parameters(
    openapi: &spec::OpenAPI,
    method: &spec::Method,
    issues: &mut Vec<ParseIssue>,
    ctx: ParseCtx<'_>,
) -> Option<Vec<ParsedParameter>> {
    if let Some(params) = &method.parameters {
        let mut parsed_params: Vec<ParsedParameter> = Vec::with_capacity(params.len());

        for param in params {
            let Some(param) = resolve_parameter_ref(openapi, param, issues, ctx) else {
                continue;
            };

            let Some(name) = param.name.as_ref() else {
                issue(issues, "parameters", ctx, "parameter name is missing");
                continue;
            };

            let schema = schema_from_parameter(&param);
            if schema.is_none() {
                issue(
                    issues,
                    "parameters",
                    ctx,
                    format!("parameter '{name}' has no schema/type"),
                );
            }

            let parameter_owner = format!("parameter '{name}'");
            let schema_type = schema.as_ref().and_then(|schema| {
                try_parse_schema(schema, issues, ctx, parameter_owner.as_str(), "$")
            });

            if schema.is_some() && schema_type.is_none() {
                issue(
                    issues,
                    "parameters",
                    ctx,
                    format!("parameter '{name}' schema is unsupported"),
                );
            }

            parsed_params.push(ParsedParameter {
                name: name.to_string(),
                location: param.location.clone(),
                description: param.description.clone(),
                required: param.required,
                schema_type,
            });
        }

        return Some(parsed_params);
    }

    None
}