openapi_codegen/client/
api.rs

1use crate::RustType;
2use openapiv3::ReferenceOr;
3use openapiv3::RequestBody;
4use serde_derive::Serialize;
5
6use crate::{RustPascalIdentifier, RustSnakeIdentifier};
7
8#[derive(Debug, Serialize)]
9pub struct Api {
10    pub snake_id: RustSnakeIdentifier,
11    pub pascal_id: RustPascalIdentifier,
12    pub methods: Vec<Method>, // Will be vec<Method>
13    pub tests: bool,
14}
15
16#[derive(Debug, Serialize)]
17pub struct Method {
18    pub snake_id: RustSnakeIdentifier,
19    pub path: String,
20    pub http_method: String,
21    pub path_parameters: Vec<Parameter>,
22    pub query_parameters: Vec<Parameter>,
23    pub body: Option<Parameter>,
24    pub returns: Option<RustType>,
25}
26
27#[derive(Debug, Serialize)]
28pub struct Parameter {
29    api_id: String,
30    snake_id: RustSnakeIdentifier,
31    r#type: RustType,
32    test_value: String,
33}
34
35impl From<&openapiv3::ParameterData> for Parameter {
36    fn from(parameter_data: &openapiv3::ParameterData) -> Parameter {
37        let r#type: RustType = parameter_data.into();
38
39        Parameter {
40            api_id: parameter_data.name.to_owned(),
41            snake_id: parameter_data.name.to_owned().into(),
42            test_value: match r#type.0.as_str() {
43                "String" => format!("\"{}\".into()", parameter_data.name),
44                "Vec<String>" => format!(
45                    "vec![\"{}1\".into(), \"{}2\".into()]",
46                    parameter_data.name, parameter_data.name
47                ),
48                t => format!("{}::default()", t),
49            },
50            r#type,
51        }
52    }
53}
54
55impl From<&ReferenceOr<RequestBody>> for Parameter {
56    fn from(reference_or_requestbody: &ReferenceOr<RequestBody>) -> Parameter {
57        let r#type: RustType = reference_or_requestbody.into();
58
59        Parameter {
60            api_id: "body".to_owned(),
61            snake_id: "body".to_owned().into(),
62            test_value: match r#type.0.as_str() {
63                "String" => "\"body\".into()".into(),
64                "Vec<String>" => "vec![\"body1\".into(), \"body2\".into()]".into(),
65                t => format!("{}::default()", t),
66            },
67            r#type,
68        }
69    }
70}