Apply camel

Author: owjs3901

crates/vespera_macro/src/parser.rs

@@ -182,6 +182,86 @@ fn is_primitive_type(ty: &Type) -> bool {
     }
 }
 
+/// Extract rename_all attribute from struct attributes
+fn extract_rename_all(attrs: &[syn::Attribute]) -> Option<String> {
+    for attr in attrs {
+        if attr.path().is_ident("serde") {
+            // Parse the attribute tokens manually
+            // Format: #[serde(rename_all = "camelCase")]
+            let tokens = attr.meta.require_list().ok()?;
+            let token_str = tokens.tokens.to_string();
+
+            // Look for rename_all = "..." pattern
+            if let Some(start) = token_str.find("rename_all") {
+                let remaining = &token_str[start + "rename_all".len()..];
+                if let Some(equals_pos) = remaining.find('=') {
+                    let value_part = &remaining[equals_pos + 1..].trim();
+                    // Extract string value (remove quotes)
+                    if value_part.starts_with('"') && value_part.ends_with('"') {
+                        let value = &value_part[1..value_part.len() - 1];
+                        return Some(value.to_string());
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Convert field name according to rename_all rule
+fn rename_field(field_name: &str, rename_all: Option<&str>) -> String {
+    match rename_all {
+        Some("camelCase") => {
+            // Convert snake_case to camelCase
+            let mut result = String::new();
+            let mut capitalize_next = false;
+            for ch in field_name.chars() {
+                if ch == '_' {
+                    capitalize_next = true;
+                } else if capitalize_next {
+                    result.push(ch.to_uppercase().next().unwrap_or(ch));
+                    capitalize_next = false;
+                } else {
+                    result.push(ch);
+                }
+            }
+            result
+        }
+        Some("snake_case") => {
+            // Convert camelCase to snake_case
+            let mut result = String::new();
+            for (i, ch) in field_name.chars().enumerate() {
+                if ch.is_uppercase() && i > 0 {
+                    result.push('_');
+                }
+                result.push(ch.to_lowercase().next().unwrap_or(ch));
+            }
+            result
+        }
+        Some("kebab-case") => {
+            // Convert snake_case to kebab-case
+            field_name.replace('_', "-")
+        }
+        Some("PascalCase") => {
+            // Convert snake_case to PascalCase
+            let mut result = String::new();
+            let mut capitalize_next = true;
+            for ch in field_name.chars() {
+                if ch == '_' {
+                    capitalize_next = true;
+                } else if capitalize_next {
+                    result.push(ch.to_uppercase().next().unwrap_or(ch));
+                    capitalize_next = false;
+                } else {
+                    result.push(ch);
+                }
+            }
+            result
+        }
+        _ => field_name.to_string(),
+    }
+}
+
 /// Parse struct definition to OpenAPI Schema
 pub fn parse_struct_to_schema(
     struct_item: &syn::ItemStruct,
@@ -190,15 +270,21 @@ pub fn parse_struct_to_schema(
     let mut properties = BTreeMap::new();
     let mut required = Vec::new();
 
+    // Extract rename_all attribute from struct
+    let rename_all = extract_rename_all(&struct_item.attrs);
+
     match &struct_item.fields {
         Fields::Named(fields_named) => {
             for field in &fields_named.named {
-                let field_name = field
+                let rust_field_name = field
                     .ident
                     .as_ref()
                     .map(|i| i.to_string())
                     .unwrap_or_else(|| "unknown".to_string());
 
+                // Apply rename_all transformation if present
+                let field_name = rename_field(&rust_field_name, rename_all.as_deref());
+
                 let field_type = &field.ty;
                 let schema_ref = parse_type_to_schema_ref(field_type, known_schemas);
 

examples/axum-example/openapi.json

@@ -54,6 +54,33 @@
         }
       }
     },
+    "/complex-struct-body-with-rename": {
+      "post": {
+        "operationId": "mod_file_with_complex_struct_body_with_rename",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ComplexStructBodyWithRename"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/health": {
       "get": {
         "operationId": "health",
@@ -358,6 +385,69 @@
           "nested_struct_map_array"
         ]
       },
+      "ComplexStructBodyWithRename": {
+        "type": "object",
+        "properties": {
+          "age": {
+            "type": "integer"
+          },
+          "array": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "map": {
+            "type": "object"
+          },
+          "name": {
+            "type": "string"
+          },
+          "nestedArray": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/StructBodyWithOptional"
+            }
+          },
+          "nestedMap": {
+            "type": "object"
+          },
+          "nestedStruct": {
+            "$ref": "#/components/schemas/StructBodyWithOptional"
+          },
+          "nestedStructArray": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/StructBodyWithOptional"
+            }
+          },
+          "nestedStructArrayMap": {
+            "type": "array",
+            "items": {
+              "type": "object"
+            }
+          },
+          "nestedStructMap": {
+            "type": "object"
+          },
+          "nestedStructMapArray": {
+            "type": "object"
+          }
+        },
+        "required": [
+          "name",
+          "age",
+          "nestedStruct",
+          "array",
+          "map",
+          "nestedArray",
+          "nestedMap",
+          "nestedStructArray",
+          "nestedStructMap",
+          "nestedStructArrayMap",
+          "nestedStructMapArray"
+        ]
+      },
       "StructBody": {
         "type": "object",
         "properties": {

examples/axum-example/src/routes/mod.rs

@@ -64,7 +64,6 @@ pub async fn mod_file_with_struct_body_with_optional(
 }
 
 #[derive(Deserialize, Schema)]
-#[serde(rename_all = "camelCase")]
 pub struct ComplexStructBody {
     pub name: String,
     pub age: u32,
@@ -96,3 +95,39 @@ pub async fn mod_file_with_complex_struct_body(Json(body): Json<ComplexStructBod
         body.nested_struct_map_array
     )
 }
+
+#[derive(Deserialize, Schema)]
+#[serde(rename_all = "camelCase")]
+pub struct ComplexStructBodyWithRename {
+    pub name: String,
+    pub age: u32,
+    pub nested_struct: StructBodyWithOptional,
+    pub array: Vec<String>,
+    pub map: HashMap<String, String>,
+    pub nested_array: Vec<StructBodyWithOptional>,
+    pub nested_map: HashMap<String, StructBodyWithOptional>,
+    pub nested_struct_array: Vec<StructBodyWithOptional>,
+    pub nested_struct_map: HashMap<String, StructBodyWithOptional>,
+    pub nested_struct_array_map: Vec<HashMap<String, StructBodyWithOptional>>,
+    pub nested_struct_map_array: HashMap<String, Vec<StructBodyWithOptional>>,
+}
+
+#[vespera::route(post, path = "/complex-struct-body-with-rename")]
+pub async fn mod_file_with_complex_struct_body_with_rename(
+    Json(body): Json<ComplexStructBodyWithRename>,
+) -> String {
+    format!(
+        "name: {}, age: {}, nested_struct: {:?}, array: {:?}, map: {:?}, nested_array: {:?}, nested_map: {:?}, nested_struct_array: {:?}, nested_struct_map: {:?}, nested_struct_array_map: {:?}, nested_struct_map_array: {:?}",
+        body.name,
+        body.age,
+        body.nested_struct,
+        body.array,
+        body.map,
+        body.nested_array,
+        body.nested_map,
+        body.nested_struct_array,
+        body.nested_struct_map,
+        body.nested_struct_array_map,
+        body.nested_struct_map_array
+    )
+}