fix(analysis): handle {"type": "null"} variants in oneOf

oneOf with [Type, null] now reduces to the non-null type with the
property marked nullable, matching how anyOf already behaves. For
oneOf with 3+ variants including null, the null branch is filtered
out instead of leaking through as a serde_json::Value variant that
the generator would mangle into a phantom `SerdeJsonValue` type.

- openapi: is_nullable_pattern / non_null_variant cover oneOf too
- analysis: filter null variants in untagged unions; require &str
  parent_name to drop magic "Union"/"Inline" fallbacks
- generator: emit serde_json::Value as a path defensively, so
  any future path that pushes it as a union variant target stays
  valid Rust instead of producing SerdeJsonValue(SerdeJsonValue)

Fixes #7

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lightsofapollo

src/analysis.rs

@@ -1127,7 +1127,12 @@ impl SchemaAnalyzer {
                 ..
             } => {
                 // Handle oneOf discriminated unions
-                self.analyze_oneof_union(one_of, discriminator.as_ref(), None, &mut dependencies)?
+                self.analyze_oneof_union(
+                    one_of,
+                    discriminator.as_ref(),
+                    schema_name,
+                    &mut dependencies,
+                )?
             }
             Schema::AllOf { all_of, .. } => {
                 // Handle allOf composition (schema inheritance)
@@ -1258,7 +1263,7 @@ impl SchemaAnalyzer {
                     let union_schema_type = self.analyze_oneof_union(
                         one_of,
                         discriminator.as_ref(),
-                        Some(&union_type_name),
+                        &union_type_name,
                         dependencies,
                     )?;
 
@@ -1627,7 +1632,7 @@ impl SchemaAnalyzer {
                         let oneof_result = self.analyze_oneof_union(
                             one_of,
                             discriminator.as_ref(),
-                            Some(&union_name),
+                            &union_name,
                             dependencies,
                         )?;
 
@@ -1927,9 +1932,28 @@ impl SchemaAnalyzer {
         &mut self,
         one_of_schemas: &[Schema],
         discriminator: Option<&crate::openapi::Discriminator>,
-        parent_name: Option<&str>,
+        parent_name: &str,
         dependencies: &mut HashSet<String>,
     ) -> Result<SchemaType> {
+        // Pattern: nullable [Type, null] — return the non-null type directly.
+        // The nullable bit is recorded at the property level via is_nullable_pattern().
+        if one_of_schemas.len() == 2 {
+            let null_count = one_of_schemas
+                .iter()
+                .filter(|s| matches!(s.schema_type(), Some(OpenApiSchemaType::Null)))
+                .count();
+            if null_count == 1 {
+                if let Some(non_null) = one_of_schemas
+                    .iter()
+                    .find(|s| !matches!(s.schema_type(), Some(OpenApiSchemaType::Null)))
+                {
+                    return self
+                        .analyze_schema_value(non_null, parent_name)
+                        .map(|a| a.schema_type);
+                }
+            }
+        }
+
         // If there's no discriminator, we should create an untagged union
         if discriminator.is_none() {
             // Handle untagged unions (oneOf without discriminator)
@@ -2136,9 +2160,8 @@ impl SchemaAnalyzer {
                     });
                 } else {
                     // Handle inline schemas by creating type aliases or using primitive types directly
-                    let context = parent_name.unwrap_or("Union");
                     let inline_name = self.generate_context_aware_name(
-                        context,
+                        parent_name,
                         "InlineVariant",
                         variant_index,
                         Some(variant_schema),
@@ -2178,9 +2201,8 @@ impl SchemaAnalyzer {
                                 }
                                 _ => {
                                     // For other array types, create an inline type
-                                    let context = parent_name.unwrap_or("Inline");
                                     let inline_type_name = self.generate_context_aware_name(
-                                        context,
+                                        parent_name,
                                         "Variant",
                                         variant_index,
                                         None,
@@ -2206,11 +2228,8 @@ impl SchemaAnalyzer {
                         }
                         // For other complex types, create an inline type
                         _ => {
-                            let inline_type_name = format!(
-                                "{}Variant{}",
-                                parent_name.unwrap_or("Inline"),
-                                variant_index + 1
-                            );
+                            let inline_type_name =
+                                format!("{}Variant{}", parent_name, variant_index + 1);
                             self.add_inline_schema(
                                 &inline_type_name,
                                 variant_schema,
@@ -2246,12 +2265,27 @@ impl SchemaAnalyzer {
     fn analyze_untagged_oneof_union(
         &mut self,
         one_of_schemas: &[Schema],
-        parent_name: Option<&str>,
+        parent_name: &str,
         dependencies: &mut HashSet<String>,
     ) -> Result<SchemaType> {
+        // Drop {"type": "null"} variants. They mean "may be null" and are surfaced
+        // as Option<T> at the property level — including them here produces a junk
+        // `SerdeJsonValue(serde_json::Value)` variant.
+        let filtered: Vec<&Schema> = one_of_schemas
+            .iter()
+            .filter(|s| !matches!(s.schema_type(), Some(OpenApiSchemaType::Null)))
+            .collect();
+
+        // If filtering leaves a single variant, return its analyzed type directly.
+        if filtered.len() == 1 {
+            return self
+                .analyze_schema_value(filtered[0], parent_name)
+                .map(|a| a.schema_type);
+        }
+
         let mut union_variants = Vec::new();
 
-        for (variant_index, variant_schema) in one_of_schemas.iter().enumerate() {
+        for (variant_index, variant_schema) in filtered.iter().copied().enumerate() {
             // First check if it's a reference or recursive reference
             if let Some(ref_str) = variant_schema.reference() {
                 if let Some(schema_name) = self.extract_schema_name(ref_str) {
@@ -2279,9 +2313,8 @@ impl SchemaAnalyzer {
                 });
             } else {
                 // Handle inline schemas by creating type aliases or using primitive types directly
-                let context = parent_name.unwrap_or("Union");
                 let inline_name = self.generate_context_aware_name(
-                    context,
+                    parent_name,
                     "InlineVariant",
                     variant_index,
                     Some(variant_schema),
@@ -2340,9 +2373,8 @@ impl SchemaAnalyzer {
                                     }
                                     _ => {
                                         // For deeper nesting, create an inline type
-                                        let context = parent_name.unwrap_or("Inline");
                                         let inline_type_name = self.generate_context_aware_name(
-                                            context,
+                                            parent_name,
                                             "Variant",
                                             variant_index,
                                             None,
@@ -2361,9 +2393,8 @@ impl SchemaAnalyzer {
                             }
                             _ => {
                                 // For other array types, create an inline type
-                                let context = parent_name.unwrap_or("Inline");
                                 let inline_type_name = self.generate_context_aware_name(
-                                    context,
+                                    parent_name,
                                     "Variant",
                                     variant_index,
                                     None,
@@ -2389,9 +2420,8 @@ impl SchemaAnalyzer {
                     }
                     // For other complex types, create an inline type
                     _ => {
-                        let context = parent_name.unwrap_or("Inline");
                         let inline_type_name = self.generate_context_aware_name(
-                            context,
+                            parent_name,
                             "Variant",
                             variant_index,
                             None,
@@ -3122,7 +3152,12 @@ impl SchemaAnalyzer {
             // Check if this is a discriminated union
             if let Some(disc) = discriminator {
                 // This is a discriminated anyOf union, analyze it the same way as oneOf
-                return self.analyze_oneof_union(any_of_schemas, Some(disc), None, dependencies);
+                return self.analyze_oneof_union(
+                    any_of_schemas,
+                    Some(disc),
+                    context_name,
+                    dependencies,
+                );
             }
 
             // Auto-detect implicit discriminator from const fields across all variants
@@ -3134,7 +3169,7 @@ impl SchemaAnalyzer {
                         mapping: None,
                         extra: BTreeMap::new(),
                     }),
-                    None,
+                    context_name,
                     dependencies,
                 );
             }

src/generator.rs

@@ -1129,6 +1129,10 @@ impl CodeGenerator {
             ) {
                 let type_ident = format_ident!("{}", variant.target);
                 quote! { #type_ident }
+            } else if variant.target == "serde_json::Value" {
+                // The target is a fully-qualified path; emit it as a path so
+                // it doesn't get mangled into a phantom `SerdeJsonValue` ident.
+                quote! { serde_json::Value }
             } else if variant.target.starts_with("Vec<") && variant.target.ends_with(">") {
                 // Handle Vec types by parsing the inner type
                 let inner = &variant.target[4..variant.target.len() - 1];
@@ -1960,6 +1964,7 @@ impl CodeGenerator {
             "u8" | "u16" | "u32" | "u64" | "u128" => return "UnsignedInteger".to_string(),
             "f32" | "f64" => return "Number".to_string(),
             "String" => return "String".to_string(),
+            "serde_json::Value" => return "Value".to_string(),
             _ => {}
         }
 

src/openapi.rs

@@ -288,29 +288,32 @@ impl Schema {
         }
     }
 
-    /// Check if this appears to be a nullable pattern (anyOf with null)
+    /// Check if this appears to be a nullable pattern (anyOf or oneOf with null)
     pub fn is_nullable_pattern(&self) -> bool {
-        match self {
-            Schema::AnyOf { any_of, .. } => {
-                any_of.len() == 2
-                    && any_of
-                        .iter()
-                        .any(|s| matches!(s.schema_type(), Some(SchemaType::Null)))
-            }
-            _ => false,
-        }
+        let variants = match self {
+            Schema::AnyOf { any_of, .. } => any_of,
+            Schema::OneOf { one_of, .. } => one_of,
+            _ => return false,
+        };
+        variants.len() == 2
+            && variants
+                .iter()
+                .any(|s| matches!(s.schema_type(), Some(SchemaType::Null)))
     }
 
     /// Get the non-null variant from a nullable pattern
     pub fn non_null_variant(&self) -> Option<&Schema> {
-        if self.is_nullable_pattern() {
-            if let Schema::AnyOf { any_of, .. } = self {
-                return any_of
-                    .iter()
-                    .find(|s| !matches!(s.schema_type(), Some(SchemaType::Null)));
-            }
+        if !self.is_nullable_pattern() {
+            return None;
         }
-        None
+        let variants = match self {
+            Schema::AnyOf { any_of, .. } => any_of,
+            Schema::OneOf { one_of, .. } => one_of,
+            _ => return None,
+        };
+        variants
+            .iter()
+            .find(|s| !matches!(s.schema_type(), Some(SchemaType::Null)))
     }
 
     /// Infer schema type from structure if not explicitly set

tests/oneof_untagged_tests.rs

@@ -345,11 +345,58 @@ mod tests {
         let generator = openapi_to_rust::CodeGenerator::new(Default::default());
         let types_content = generator.generate(&mut analysis).unwrap();
 
-        // Could be handled as Option<String> or as a union with null variant
+        // The non-null variant should reduce to String — directly as Option<String>,
+        // through a type alias (`pub type X = String;`), or as an untagged enum that
+        // contains a String variant. The {"type": "null"} branch must not produce a
+        // `serde_json::Value` / `SerdeJsonValue` variant.
         assert!(
             types_content.contains("Option<String>")
+                || types_content.contains("= String;")
                 || types_content.contains("#[serde(untagged)]"),
-            "Should handle nullable oneOf appropriately"
+            "Should handle nullable oneOf appropriately, got:\n{types_content}"
+        );
+        assert!(
+            !types_content.contains("SerdeJsonValue"),
+            "null variant must not become a SerdeJsonValue variant, got:\n{types_content}"
+        );
+    }
+
+    // Regression for https://github.com/gpu-cli/openapi-to-rust/issues/7:
+    // {"type": "null"} inside oneOf with 3+ variants must be filtered out, not
+    // emitted as a phantom `SerdeJsonValue(SerdeJsonValue)` variant.
+    #[test]
+    fn test_oneof_null_among_multiple_variants_is_filtered() {
+        let spec_json = minimal_spec(json!({
+            "NullOneOfMixed": {
+                "type": "object",
+                "properties": {
+                    "value": {
+                        "oneOf": [
+                            {"type": "null"},
+                            {"type": "string"},
+                            {"type": "integer"}
+                        ]
+                    }
+                }
+            }
+        }));
+
+        let mut analyzer = openapi_to_rust::SchemaAnalyzer::new(spec_json).unwrap();
+        let mut analysis = analyzer.analyze().unwrap();
+        let generator = openapi_to_rust::CodeGenerator::new(Default::default());
+        let types_content = generator.generate(&mut analysis).unwrap();
+
+        assert!(
+            !types_content.contains("SerdeJsonValue"),
+            "null variant leaked through as SerdeJsonValue, got:\n{types_content}"
+        );
+        assert!(
+            types_content.contains("String(String)"),
+            "expected String variant in untagged enum, got:\n{types_content}"
+        );
+        assert!(
+            types_content.contains("Integer(i64)"),
+            "expected Integer variant in untagged enum, got:\n{types_content}"
         );
     }