Merge pull request #36 from floze-the-genius/fix/api-error-display-29

Improve ApiError display output

Author: lightsofapollo

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes are recorded here. This project follows semantic versioning,
 with one pre-1.0 qualification: a minor release may change generated Rust APIs
 when correcting output that was wrong or incomplete on the wire.
 
+## [Unreleased]
+
+### Fixed
+
+- `ApiError` display output now bounds large response-body previews and includes
+  typed error details or typed-body parse failures when available (#29).
+
 ## [0.7.0] - 2026-07-17
 
 ### Added

src/generator.rs

@@ -976,7 +976,9 @@ impl CodeGenerator {
             /// `headers`, and `body` are always populated so callers can
             /// inspect what the server sent without modifying the generated
             /// code. `typed` carries the parsed per-operation error variant
-            /// when the body matched a declared schema.
+            /// when the body matched a declared schema. Formatting the error
+            /// limits only the displayed body preview; the public fields
+            /// retain the complete response and parsing details.
             #[derive(Debug, Clone)]
             pub struct ApiError<E> {
                 pub status: u16,
@@ -986,6 +988,21 @@ impl CodeGenerator {
                 pub parse_error: Option<String>,
             }
 
+            const API_ERROR_BODY_DISPLAY_LIMIT: usize = 500;
+            const API_ERROR_BODY_TRUNCATION_MARKER: &str = "... [truncated]";
+
+            fn display_api_error_body(body: &str) -> std::borrow::Cow<'_, str> {
+                let Some((end, _)) = body.char_indices().nth(API_ERROR_BODY_DISPLAY_LIMIT) else {
+                    return std::borrow::Cow::Borrowed(body);
+                };
+
+                let mut displayed =
+                    String::with_capacity(end + API_ERROR_BODY_TRUNCATION_MARKER.len());
+                displayed.push_str(&body[..end]);
+                displayed.push_str(API_ERROR_BODY_TRUNCATION_MARKER);
+                std::borrow::Cow::Owned(displayed)
+            }
+
             impl<E> ApiError<E> {
                 pub fn is_client_error(&self) -> bool {
                     (400..500).contains(&self.status)
@@ -1004,7 +1021,22 @@ impl CodeGenerator {
 
             impl<E: std::fmt::Debug> std::fmt::Display for ApiError<E> {
                 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                    write!(f, "API error {}: {}", self.status, self.body)
+                    write!(
+                        f,
+                        "API error {}: {}",
+                        self.status,
+                        display_api_error_body(&self.body)
+                    )?;
+
+                    if let Some(typed) = &self.typed {
+                        write!(f, "; typed: {typed:?}")?;
+                    }
+
+                    if let Some(parse_error) = &self.parse_error {
+                        write!(f, "; parse error: {parse_error}")?;
+                    }
+
+                    Ok(())
                 }
             }
 

src/http_error.rs

@@ -212,6 +212,8 @@ pub type HttpResult<T> = Result<T, HttpError>;
 /// inspect what the server actually sent without having to hack the generated
 /// client. `typed` is `Some(_)` when the raw body was successfully parsed into a
 /// per-operation error type; `parse_error` records why parsing failed when not.
+/// Formatting the error limits only the displayed body preview; the public
+/// fields retain the complete response and parsing details.
 #[derive(Debug, Clone)]
 pub struct ApiError<E> {
     pub status: u16,
@@ -221,6 +223,20 @@ pub struct ApiError<E> {
     pub parse_error: Option<String>,
 }
 
+const API_ERROR_BODY_DISPLAY_LIMIT: usize = 500;
+const API_ERROR_BODY_TRUNCATION_MARKER: &str = "... [truncated]";
+
+fn display_api_error_body(body: &str) -> std::borrow::Cow<'_, str> {
+    let Some((end, _)) = body.char_indices().nth(API_ERROR_BODY_DISPLAY_LIMIT) else {
+        return std::borrow::Cow::Borrowed(body);
+    };
+
+    let mut displayed = String::with_capacity(end + API_ERROR_BODY_TRUNCATION_MARKER.len());
+    displayed.push_str(&body[..end]);
+    displayed.push_str(API_ERROR_BODY_TRUNCATION_MARKER);
+    std::borrow::Cow::Owned(displayed)
+}
+
 impl<E> ApiError<E> {
     pub fn is_client_error(&self) -> bool {
         (400..500).contains(&self.status)
@@ -233,7 +249,22 @@ impl<E> ApiError<E> {
 
 impl<E: std::fmt::Debug> std::fmt::Display for ApiError<E> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "API error {}: {}", self.status, self.body)
+        write!(
+            f,
+            "API error {}: {}",
+            self.status,
+            display_api_error_body(&self.body)
+        )?;
+
+        if let Some(typed) = &self.typed {
+            write!(f, "; typed: {typed:?}")?;
+        }
+
+        if let Some(parse_error) = &self.parse_error {
+            write!(f, "; parse error: {parse_error}")?;
+        }
+
+        Ok(())
     }
 }
 

tests/http_error_test.rs

@@ -1,4 +1,65 @@
-use openapi_to_rust::http_error::{HttpError, HttpResult};
+use openapi_to_rust::http_error::{ApiError, HttpError, HttpResult};
+use reqwest::header::HeaderMap;
+
+#[derive(Debug)]
+enum TypedApiError {
+    Invalid,
+}
+
+fn api_error<E>(
+    body: impl Into<String>,
+    typed: Option<E>,
+    parse_error: Option<&str>,
+) -> ApiError<E> {
+    ApiError {
+        status: 422,
+        headers: HeaderMap::new(),
+        body: body.into(),
+        typed,
+        parse_error: parse_error.map(str::to_owned),
+    }
+}
+
+#[test]
+fn test_api_error_display_normal_body() {
+    let error = api_error::<TypedApiError>("small response", None, None);
+
+    assert_eq!(error.to_string(), "API error 422: small response");
+}
+
+#[test]
+fn test_api_error_display_truncates_body_without_mutating_it() {
+    let body = "é".repeat(600);
+    let error = api_error::<TypedApiError>(body.clone(), None, None);
+    let displayed = error.to_string();
+
+    assert_eq!(
+        displayed,
+        format!("API error 422: {}... [truncated]", "é".repeat(500))
+    );
+    assert_eq!(error.body, body);
+}
+
+#[test]
+fn test_api_error_display_includes_typed_error() {
+    let error = api_error("validation failed", Some(TypedApiError::Invalid), None);
+
+    assert_eq!(
+        error.to_string(),
+        "API error 422: validation failed; typed: Invalid"
+    );
+}
+
+#[test]
+fn test_api_error_display_includes_parse_error() {
+    let error =
+        api_error::<TypedApiError>("not json", None, Some("expected value at line 1 column 1"));
+
+    assert_eq!(
+        error.to_string(),
+        "API error 422: not json; parse error: expected value at line 1 column 1"
+    );
+}
 
 #[test]
 fn test_http_error_creation() {
@@ -312,6 +373,22 @@ fn test_generated_error_code() {
         client_content.contains("pub fn is_retryable"),
         "Generated code should contain is_retryable method"
     );
+    assert!(
+        client_content.contains("API_ERROR_BODY_DISPLAY_LIMIT"),
+        "Generated code should bound the displayed API error body"
+    );
+    assert!(
+        client_content.contains("API_ERROR_BODY_TRUNCATION_MARKER"),
+        "Generated code should include a clear body truncation marker"
+    );
+    assert!(
+        client_content.contains("typed: {typed:?}"),
+        "Generated code should display typed API error details"
+    );
+    assert!(
+        client_content.contains("parse error: {parse_error}"),
+        "Generated code should display typed parsing failures"
+    );
 
     // Verify HttpResult type alias
     assert!(