fix expanded-corpus generation: media types, validation patterns, paths, allOf aliases

Probe-driven fixes from running 241 previously-failing APIs.guru specs
(AWS, Adyen, apisetu.gov.in, api.video, ...) through client and server
generation. 210/240 now generate cleanly (was ~2%):

- allOf [$ref, {description}] self-references are type aliases again;
  recursive expansion overflowed the stack on AWS-style specs.
- application/pdf responses classify as Binary; application/xml and +xml
  suffixed types classify as Text on both response and request sides.
- best_content() falls back to character-data media (text/xml etc.)
  instead of leaving XML-only request bodies unsupported.
- Validation pattern normalization: Java POSIX classes (\p{Print},
  \p{Alpha}, ...) translate to ASCII ranges, ECMA \uXXXX escapes to
  Rust \u{XXXX}, legacy octal escapes to \xNN. Patterns that still
  cannot compile offline (look-around, backreferences) degrade to
  "no pattern check" instead of failing generation.
- AWS x-pattern extension promotes to the standard pattern keyword.
- Validation bundle component keys are prefixed so a schema named like
  a JSON Schema keyword (`id`) survives meta-schema validation.
- AWS query markers (/tags/{arn}#tagKeys) strip the #fragment before
  route generation; webhook synthetic paths gain their leading `/`.
- Server code qualifies non-canonical schema names (not-found) with
  their canonical Rust identifiers via rust_type_name().

Remaining known gaps (fail loudly, not silently wrong): form-style
object-array query items (AWS query protocol wire shape is undefined
by OpenAPI), multipart server extraction, YAML tab-indentation specs,
and one PathItem-as-string spec.

Author: lightsofapollo

Cargo.lock

@@ -51,6 +51,7 @@ toml_edit = "0.22"
 specta = { version = "2.0.0-rc", features = ["derive"], optional = true }
 heck = "0.5"
 jsonschema = { version = "0.49", default-features = false }
+regex = "1"
 
 [dev-dependencies]
 serde_yaml = "0.9"

Cargo.toml

@@ -705,6 +705,19 @@ pub fn merge_schema_extensions(
     Ok(result)
 }
 
+/// AWS-style specs append query markers to their path templates
+/// (`/tags/{resourceArn}#tagKeys`, `/2015-02-01/resource-tags/{ResourceId}#tagKeys`).
+/// The fragment is not part of the route — those values are declared as
+/// ordinary query parameters on the operation — so strip it before the path
+/// reaches route generation. Axum (and every HTTP router) matches on the path
+/// component only.
+fn normalize_operation_path(path: &str) -> String {
+    match path.split_once('#') {
+        Some((route, _fragment)) if route.starts_with('/') => route.to_string(),
+        _ => path.to_string(),
+    }
+}
+
 /// Load an extension file and parse it into the JSON representation used by
 /// the analyzer. YAML extensions follow the same conversion policy as YAML
 /// OpenAPI documents; every other extension is parsed as JSON.
@@ -2395,17 +2408,46 @@ impl SchemaAnalyzer {
         all_of_schemas: &[Schema],
         dependencies: &mut HashSet<String>,
     ) -> Result<SchemaType> {
-        // Special case: if allOf contains only a single reference, treat it as a direct type alias
-        // This handles patterns like: "allOf": [{"$ref": "#/components/schemas/Usage"}]
-        if all_of_schemas.len() == 1 {
-            if let Schema::Reference { reference, .. } = &all_of_schemas[0] {
-                if let Some(target) = self.extract_schema_name(reference) {
-                    dependencies.insert(target.to_string());
-                    return Ok(SchemaType::Reference {
-                        target: target.to_string(),
-                    });
-                }
+        // A reference plus annotation-only siblings is still a direct type
+        // alias. AWS-style specs frequently encode property descriptions as
+        // `allOf: [$ref, { description: ... }]`; recursively expanding a
+        // self-reference in that shape can otherwise recurse forever.
+        let referenced_targets = all_of_schemas
+            .iter()
+            .filter_map(|schema| schema.reference())
+            .filter_map(|reference| self.extract_schema_name(reference))
+            .collect::<Vec<_>>();
+        let only_reference_and_annotations = all_of_schemas.iter().all(|schema| {
+            if schema.reference().is_some() {
+                return true;
             }
+            serde_json::to_value(schema)
+                .ok()
+                .and_then(|value| value.as_object().cloned())
+                .is_some_and(|object| {
+                    object.keys().all(|key| {
+                        matches!(
+                            key.as_str(),
+                            "title"
+                                | "description"
+                                | "deprecated"
+                                | "readOnly"
+                                | "writeOnly"
+                                | "examples"
+                                | "example"
+                                | "externalDocs"
+                                | "xml"
+                                | "$comment"
+                        ) || key.starts_with("x-")
+                    })
+                })
+        });
+        if referenced_targets.len() == 1 && only_reference_and_annotations {
+            let target = referenced_targets[0];
+            dependencies.insert(target.to_string());
+            return Ok(SchemaType::Reference {
+                target: target.to_string(),
+            });
         }
 
         // AllOf represents schema composition - merge all schemas into one
@@ -4335,7 +4377,7 @@ impl SchemaAnalyzer {
         // dispatcher.
         if let Some(webhooks) = &spec.webhooks {
             for (name, path_item) in webhooks {
-                let synthetic_path = format!("__webhook__/{name}");
+                let synthetic_path = format!("/__webhook__/{name}");
                 self.ingest_path_item_operations(
                     &synthetic_path,
                     path_item,
@@ -4514,7 +4556,7 @@ impl SchemaAnalyzer {
         let mut op_info = OperationInfo {
             operation_id: operation_id.to_string(),
             method: method.to_uppercase(),
-            path: path.to_string(),
+            path: normalize_operation_path(path),
             summary: operation.summary.clone(),
             description: operation.description.clone(),
             request_body: None,
@@ -4596,7 +4638,11 @@ impl SchemaAnalyzer {
                             media_type: content_type.to_string(),
                         })
                     }
-                } else if media_type_essence(content_type).eq_ignore_ascii_case("text/plain") {
+                } else if crate::openapi::is_text_media_type(content_type) {
+                    // Any character-data media type (text/plain, text/xml,
+                    // application/xml, +xml suffixed) is buffered and handed
+                    // to the handler as a lossless UTF-8 String; the server
+                    // never parses the payload.
                     Some(RequestBodyContent::TextPlain {
                         media_type: content_type.to_string(),
                     })

src/analysis.rs

@@ -264,6 +264,69 @@ pub fn default_type_mappings() -> BTreeMap<String, String> {
     mappings
 }
 
+/// Convert an OpenAPI schema name to the canonical Rust model identifier.
+///
+/// Every code-generation surface must use this helper rather than parsing raw
+/// component keys as Rust types; otherwise names such as `not-found` panic and
+/// names such as `inline_response_200` refer to models that were never emitted.
+pub(crate) fn rust_type_name(s: &str) -> String {
+    let mut result = String::new();
+    let mut next_upper = true;
+
+    for c in s.chars() {
+        match c {
+            'a'..='z' => {
+                result.push(if next_upper {
+                    c.to_ascii_uppercase()
+                } else {
+                    c
+                });
+                next_upper = false;
+            }
+            'A'..='Z' | '0'..='9' => {
+                result.push(c);
+                next_upper = false;
+            }
+            _ => next_upper = true,
+        }
+    }
+
+    if result.is_empty() {
+        result = "Type".to_string();
+    }
+    if result.chars().next().is_some_and(|c| c.is_ascii_digit()) {
+        result = format!("Type{result}");
+    }
+    if matches!(
+        result.as_str(),
+        "Result"
+            | "Option"
+            | "Box"
+            | "Vec"
+            | "String"
+            | "Some"
+            | "None"
+            | "Ok"
+            | "Err"
+            | "Default"
+            | "Clone"
+            | "Debug"
+            | "Send"
+            | "Sync"
+            | "Sized"
+            | "Iterator"
+            | "From"
+            | "Into"
+            | "TryFrom"
+            | "TryInto"
+            | "AsRef"
+            | "AsMut"
+    ) {
+        result.push_str("Type");
+    }
+    result
+}
+
 /// Represents a generated file
 #[derive(Debug, Clone)]
 pub struct GeneratedFile {
@@ -3024,95 +3087,7 @@ impl CodeGenerator {
     }
 
     pub(crate) fn to_rust_type_name(&self, s: &str) -> String {
-        // Convert string to valid Rust type name (PascalCase)
-        let mut result = String::new();
-        let mut next_upper = true;
-        let mut prev_was_lower = false;
-
-        for c in s.chars() {
-            match c {
-                'a'..='z' => {
-                    if next_upper {
-                        result.push(c.to_ascii_uppercase());
-                        next_upper = false;
-                    } else {
-                        result.push(c);
-                    }
-                    prev_was_lower = true;
-                }
-                'A'..='Z' => {
-                    result.push(c);
-                    next_upper = false;
-                    prev_was_lower = false;
-                }
-                '0'..='9' => {
-                    // If previous was lowercase letter and this is start of a number sequence,
-                    // make it uppercase to improve readability (e.g., Tool20241022 instead of Tool20241022)
-                    if prev_was_lower && !result.chars().last().unwrap_or(' ').is_ascii_digit() {
-                        // This is fine as-is, the number follows naturally
-                    }
-                    result.push(c);
-                    next_upper = false;
-                    prev_was_lower = false;
-                }
-                '_' | '-' | '.' | ' ' => {
-                    // Skip underscore/separator and make next char uppercase
-                    next_upper = true;
-                    prev_was_lower = false;
-                }
-                _ => {
-                    // Other special characters - treat as word boundary
-                    next_upper = true;
-                    prev_was_lower = false;
-                }
-            }
-        }
-
-        // Handle empty result
-        if result.is_empty() {
-            result = "Type".to_string();
-        }
-
-        // Ensure type name starts with a letter (not a number)
-        if result.chars().next().is_some_and(|c| c.is_ascii_digit()) {
-            result = format!("Type{result}");
-        }
-
-        // Avoid masking ubiquitous std types and traits. cloudflare has a
-        // schema literally named `Result`, gcore has `Default`; emitting
-        // `pub enum Result { ... }` shadows std::result::Result and breaks
-        // every method's `-> Result<T, ApiOpError<...>>`. Same for impls
-        // like `impl Default for HttpClient { ... }` when `Default` resolves
-        // to the local type alias.
-        if matches!(
-            result.as_str(),
-            "Result"
-                | "Option"
-                | "Box"
-                | "Vec"
-                | "String"
-                | "Some"
-                | "None"
-                | "Ok"
-                | "Err"
-                | "Default"
-                | "Clone"
-                | "Debug"
-                | "Send"
-                | "Sync"
-                | "Sized"
-                | "Iterator"
-                | "From"
-                | "Into"
-                | "TryFrom"
-                | "TryInto"
-                | "AsRef"
-                | "AsMut"
-        ) {
-            result.push_str("Type");
-        }
-
-        result
+        rust_type_name(s)
     }
 
     fn to_rust_field_name(&self, s: &str) -> String {

src/generator.rs

@@ -1079,11 +1079,24 @@ pub fn is_event_stream_media_type(ct: &str) -> bool {
 }
 
 /// Returns true for non-SSE media types in the `text` top-level family.
+///
+/// Structured text formats in the `application` family whose instances are
+/// UTF-8/UTF-16 character data — XML and its `+xml` suffix variants (RFC 7303,
+/// RFC 6839) — are buffered and emitted as text as well; bytes are never
+/// XML-parsed by the generated server, so a plain `String` body preserves
+/// the payload losslessly.
 pub fn is_text_media_type(ct: &str) -> bool {
     let Some((top_level, subtype)) = media_type_essence(ct).split_once('/') else {
         return false;
     };
-    top_level.eq_ignore_ascii_case("text") && !subtype.is_empty() && !is_event_stream_media_type(ct)
+    if top_level.eq_ignore_ascii_case("text")
+        && !subtype.is_empty()
+        && !is_event_stream_media_type(ct)
+    {
+        return true;
+    }
+    top_level.eq_ignore_ascii_case("application")
+        && (subtype.eq_ignore_ascii_case("xml") || subtype.to_ascii_lowercase().ends_with("+xml"))
 }
 
 /// Returns true for OpenAPI media ranges with a wildcard subtype.
@@ -1132,6 +1145,7 @@ pub fn is_binary_media_type(ct: &str, schema: Option<&Schema>) -> bool {
     }
     if essence.eq_ignore_ascii_case("application/octet-stream")
         || essence.eq_ignore_ascii_case("application/zip")
+        || essence.eq_ignore_ascii_case("application/pdf")
     {
         return true;
     }
@@ -1222,6 +1236,11 @@ impl RequestBody {
                 return Some((ct.as_str(), media_type.schema.as_ref()));
             }
         }
+        // Character-data fallbacks (text/xml, application/xml, +xml suffixed)
+        // are buffered as UTF-8 text like text/plain.
+        if let Some((ct, media_type)) = content.iter().find(|(ct, _)| is_text_media_type(ct)) {
+            return Some((ct.as_str(), media_type.schema.as_ref()));
+        }
         content
             .iter()
             // A request media range is not a concrete Content-Type value. The
@@ -1552,13 +1571,28 @@ mod tests {
     #[test]
     fn response_media_classifier_leaves_ambiguous_formats_unsupported() {
         let string_schema: Schema = serde_json::from_value(json!({ "type": "string" })).unwrap();
-        for media_type in ["application/xml", "application/pdf", "not-a-media-type"] {
+        for media_type in ["application/x-unknown", "not-a-media-type"] {
             assert_eq!(
                 classify_response_media_type(media_type, Some(&string_schema)),
                 ResponseMediaKind::Unsupported,
                 "{media_type}"
             );
         }
+        // PDF bodies are raw bytes; XML bodies are character data. Both are
+        // pass-through lossless for a server that never parses the payload,
+        // so they classify instead of failing generation.
+        assert_eq!(
+            classify_response_media_type("application/pdf", Some(&string_schema)),
+            ResponseMediaKind::Binary
+        );
+        assert_eq!(
+            classify_response_media_type("application/xml", Some(&string_schema)),
+            ResponseMediaKind::Text
+        );
+        assert_eq!(
+            classify_response_media_type("application/atom+xml", Some(&string_schema)),
+            ResponseMediaKind::Text
+        );
         assert!(!is_binary_media_type("text/plain", None));
     }