vespera_macro 0.4.0

Procedural macros for Vespera - automatic route discovery and OpenAPI generation
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::collections::{HashMap, HashSet};

use syn::Type;
use vespera_core::{
    route::{Parameter, ParameterLocation},
    schema::{Schema, SchemaRef},
};

use super::shared::is_primitive_or_like;
use crate::parser::schema::parse_type_to_schema_ref;

pub(super) fn parse_option_typed_header(param_name: &str, ty: &Type) -> Option<Vec<Parameter>> {
    let Type::Path(type_path) = ty else {
        return None;
    };
    let segment = type_path.path.segments.first()?;
    if segment.ident != "Option" {
        return None;
    }
    let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
        return None;
    };
    let Some(syn::GenericArgument::Type(Type::Path(inner_type_path))) = args.args.first() else {
        return None;
    };
    let inner_segment = inner_type_path.path.segments.last()?;
    (inner_segment.ident == "TypedHeader").then(|| vec![typed_header_parameter(param_name, false)])
}

pub(super) fn parse_header_extractor(
    param_name: &str,
    ty: &Type,
    known_schemas: &HashSet<&str>,
    struct_definitions: &HashMap<&str, &str>,
) -> Option<Vec<Parameter>> {
    let Type::Path(type_path) = ty else {
        return None;
    };
    let segment = type_path.path.segments.last()?;
    match segment.ident.to_string().as_str() {
        "Header" => parse_header(param_name, segment, known_schemas, struct_definitions),
        "TypedHeader" => Some(vec![typed_header_parameter(param_name, true)]),
        _ => None,
    }
}

fn parse_header(
    param_name: &str,
    segment: &syn::PathSegment,
    known_schemas: &HashSet<&str>,
    struct_definitions: &HashMap<&str, &str>,
) -> Option<Vec<Parameter>> {
    let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
        return None;
    };
    let Some(syn::GenericArgument::Type(inner_ty)) = args.args.first() else {
        return None;
    };
    if is_primitive_or_like(inner_ty) {
        return None;
    }
    Some(vec![Parameter {
        name: param_name.to_string(),
        r#in: ParameterLocation::Header,
        description: None,
        required: Some(true),
        schema: Some(parse_type_to_schema_ref(
            inner_ty,
            known_schemas,
            struct_definitions,
        )),
        example: None,
    }])
}

fn typed_header_parameter(param_name: &str, required: bool) -> Parameter {
    Parameter {
        name: param_name.replace('_', "-"),
        r#in: ParameterLocation::Header,
        description: None,
        required: Some(required),
        schema: Some(SchemaRef::Inline(Box::new(Schema::string()))),
        example: None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn malformed_option_and_header_generics_are_rejected() {
        let bare_option: Type = syn::parse_quote!(Option);
        assert!(parse_option_typed_header("x", &bare_option).is_none());
        let lifetime_option: Type = syn::parse_quote!(Option<'static>);
        assert!(parse_option_typed_header("x", &lifetime_option).is_none());

        let bare_header: Type = syn::parse_quote!(Header);
        assert!(
            parse_header_extractor("x", &bare_header, &HashSet::new(), &HashMap::new()).is_none()
        );
        let lifetime_header: Type = syn::parse_quote!(Header<'static>);
        assert!(
            parse_header_extractor("x", &lifetime_header, &HashSet::new(), &HashMap::new())
                .is_none()
        );
    }
}