openapi-client-generator 0.1.9

Generates a client library based on an OpenAPI spec.
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

use convert_case::{Case, Casing};
use openapiv3::{OpenAPI, ReferenceOr, Schema};
use openapiv3::{SchemaKind, Type, StringType};
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};

use crate::codegen::util::ToIdent;
use crate::codegen::util::ToToken;

pub fn generate_model_rs(spec: &OpenAPI) -> TokenStream {
    let all_struct_Schema = all_struct_Schema(spec);

    quote! {
        #all_struct_Schema
    }
}


pub fn all_struct_Schema(spec: &OpenAPI) -> TokenStream {
    let schemas = spec.components.as_ref().unwrap().schemas.iter().map(|(k, schema)| {
        let schema = schema.resolve(spec);
        struct_Schema(k, schema, spec)
    });
    quote! {
        #(#schemas)*
    }
}

pub fn struct_Schema_object(name: &str, struct_schema: &Schema, spec: &OpenAPI) -> TokenStream {
    let fields = struct_schema.properties().unwrap().iter().map(|(k, v)| {
        let k = k.to_string();
        let prop_schema = v.resolve(spec);

        let field_type = match v {
            ReferenceOr::Reference { ref reference } => {
                let name = reference.rsplit('/').next().unwrap();
                let field_type = name.to_struct_name();
                if prop_schema.schema_data.nullable {
                    quote! { Option<#field_type> }
                } else {
                    quote! { #field_type }
                }
            }
            ReferenceOr::Item(schema) => schema.to_token(spec),
        };
        let serde_attr = if k.is_restricted() {
            let serde_line = quote! {
                #[serde(rename = #k)]
            };
            serde_line
        } else {
            TokenStream::new()
        };
        let doc_attr = if let Some(doc) = &prop_schema.schema_data.description {
            quote! {
                #[doc = #doc]
            }
        } else {
            TokenStream::new()
        };
        let field = k.to_ident();
        quote! {
            #serde_attr
            #doc_attr
            pub #field: #field_type,
        }
    });
    let name = name.to_struct_name();
    quote! {
        #[derive(Debug, Serialize, Deserialize)]
        pub struct #name {
            #(#fields)*
        }
    }
}

pub fn struct_Schema_newtype(name: &str, schema: &Schema, spec: &OpenAPI) -> TokenStream {
    let field_type = schema.to_token(spec);
    if let SchemaKind::Type(Type::String(StringType {
                                             format, pattern, enumeration, min_length, max_length
                                         })) = &schema.schema_kind {
        if !enumeration.is_empty() {
            let enums = enumeration.iter().filter(|s| s.is_some()).map(|s| {
                let s = s.as_ref().unwrap().to_string();
                let name = (if s.chars().next().unwrap().is_numeric() {
                    name.to_string() + &s
                } else { s.to_string() }
                ).to_struct_name();
                quote! {
                    #[serde(rename = #s)]
                    #name
                }
            });
            let name = name.to_struct_name();
            return quote! {
                #[derive(Debug, Serialize, Deserialize)]
                pub enum #name {
                    #(#enums,)*
                }
            };
        }
    }
    let name = name.to_struct_name();
    let field_type = schema.to_token(spec);
    quote! {
        #[derive(Debug, Serialize, Deserialize)]
        pub struct #name(pub #field_type);
    }
}

pub fn struct_Schema(name: &str, schema: &Schema, spec: &OpenAPI) -> TokenStream {
    match schema.properties() {
        Some(properties) => struct_Schema_object(name, schema, spec),
        None => struct_Schema_newtype(name, schema, spec),
    }
}