openapi-client-generator 0.1.2

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

use convert_case::Case;
use convert_case::Casing;
use openapiv3::{OpenAPI, ReferenceOr, Schema};
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
            .as_ref()
            .resolve(spec).unwrap();
        struct_Schema(k, schema, spec)
    });
    quote! {
        #(#schemas)*
    }
}

pub fn struct_Schema_object(name: &str, struct_schema: &Schema, spec: &OpenAPI) -> TokenStream {
    // if name != "Item" {
    //     return quote! {};
    // }

    let fields = struct_schema.properties().unwrap().iter().map(|(k, v)| {
        let mut k = k.to_string();
        let prop_schema = v
            .as_ref()
            .resolve(spec)
            .unwrap();

        let mut field_type = match v {
            ReferenceOr::Reference { ref reference } => {
                let name = reference.rsplit('/').next().unwrap();
                let field_type = syn::Ident::new(name, Span::call_site()).to_token_stream();
                if prop_schema.schema_data.nullable {
                    quote! { Option<#field_type> }
                } else {
                    field_type
                }
            }
            ReferenceOr::Item(schema) => schema.to_token(spec),
        };
        // if prop_schema.schema_data.nullable {
        //     println!("cargo:warning={}.{} nullable", name, k);
        // }
        // if name == "Item" && k == "error" {
        //     println!("cargo:warning={}.{}, requiredness struct={} prop={:?}",
        //              name, k,
        //              struct_schema.required(&k),
        //              prop_schema.schema_data
        //     );
        // }
        // if prop_schema.schema_data.nullable {
        //     field_type = quote! { Option<#field_type>};
        // }
        let serde = if k.is_restricted() {
            let serde_line = quote! {
                #[serde(rename = #k)]
            };
            k += "_";
            serde_line
        } else {
            TokenStream::new()
        };
        let z = "".to_string();
        let docstring = prop_schema.schema_data.description.as_ref().unwrap_or(&z);
        // let k = k.to_case(Case::Snake);
        let field = syn::Ident::new(&k, Span::call_site());
        quote! {
            #serde
            #[doc = #docstring]
            pub #field: #field_type,
        }
    });
    let name = syn::Ident::new(name, Span::call_site());
    quote! {
        #[derive(Debug, Serialize, Deserialize)]
        pub struct #name {
            #(#fields)*
        }
    }
}

pub fn struct_Schema_newtype(name: &str, schema: &Schema, spec: &OpenAPI) -> TokenStream {
    let field = syn::Ident::new("value", Span::call_site());
    let field_type = schema.to_token(spec);
    let name = syn::Ident::new(name, Span::call_site());
    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),
    }
}