Fix validation error related to versioning (#686)

Author: vprashrex

backend/app/core/exception_handlers.py

@@ -18,10 +18,11 @@ def _is_branch_identifier(part: str) -> bool:
     return bool(part and isinstance(part, str) and _BRANCH_PATTERN.search(part))
 
 
-def _filter_union_branch_errors(errors: list[dict]) -> list[dict]:
-    """When a field is a Union type, pydantic returns errors for every possible branch.
+def _sanitize_validation_errors(errors: list[dict]) -> list[dict]:
+    """Sanitize pydantic validation errors.
 
-    This function picks the branch where the validation error happend.
+    Filters union branch noise (keeps only the relevant branch),
+    strips internal fields, returning only loc, msg, and type.
     """
     try:
         branch_errors: dict[str, dict[str, list[dict]]] = defaultdict(
@@ -74,7 +75,11 @@ def _filter_union_branch_errors(errors: list[dict]) -> list[dict]:
                 seen_errors.add(error_key)
                 unique_errors.append(error)
 
-        return unique_errors or errors
+        sanitized = [
+            {k: v for k, v in err.items() if k in ("loc", "msg", "type")}
+            for err in (unique_errors or errors)
+        ]
+        return sanitized
     except Exception:
         return errors
 
@@ -84,7 +89,7 @@ def register_exception_handlers(app: FastAPI) -> None:
     async def validation_error_handler(
         request: Request, exc: RequestValidationError
     ) -> JSONResponse:
-        errors = _filter_union_branch_errors(exc.errors())
+        errors = _sanitize_validation_errors(exc.errors())
         return JSONResponse(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
             content=APIResponse.failure_response(errors).model_dump(),
@@ -94,9 +99,12 @@ async def validation_error_handler(
     async def http_exception_handler(
         request: Request, exc: HTTPException
     ) -> JSONResponse:
+        detail = exc.detail
+        if isinstance(detail, list):
+            detail = _sanitize_validation_errors(detail)
         return JSONResponse(
             status_code=exc.status_code,
-            content=APIResponse.failure_response(exc.detail).model_dump(),
+            content=APIResponse.failure_response(detail).model_dump(),
         )
 
     @app.exception_handler(Exception)

backend/app/crud/config/version.py

@@ -64,14 +64,13 @@ def create_or_raise(self, version_create: ConfigVersionUpdate) -> ConfigVersion:
         try:
             validated_blob = ConfigBlob.model_validate(merged_config)
         except ValidationError as e:
+            validation_errors = e.errors()
             logger.error(
-                f"[ConfigVersionCrud.create_from_partial] Validation failed | "
-                f"{{'config_id': '{self.config_id}', 'error': '{str(e)}'}}"
-            )
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid config after merge: {str(e)}",
+                f"[ConfigVersionCrud.create_or_raise] Validation failed | "
+                f"{{'config_id': '{self.config_id}', 'error_count': {len(validation_errors)}, "
+                f"'fields': {['.'.join(str(part) for part in err['loc']) for err in validation_errors]}}}"
             )
+            raise HTTPException(status_code=400, detail=validation_errors)
 
         try:
             next_version = self._get_next_version(self.config_id)

backend/app/tests/core/test_exception_handlers.py

@@ -1,18 +1,18 @@
 from fastapi.testclient import TestClient
 
 from app.core.config import settings
-from app.core.exception_handlers import _filter_union_branch_errors
+from app.core.exception_handlers import _sanitize_validation_errors
 from app.tests.utils.auth import TestAuthContext
 
 
-class TestFilterUnionBranchErrors:
-    """Unit tests for _filter_union_branch_errors."""
+class TestSanitizeValidationErrors:
+    """Unit tests for _sanitize_validation_errors."""
 
     def test_non_union_errors_pass_through(self) -> None:
         errors = [
             {"type": "missing", "loc": ("body", "name"), "msg": "Field required"},
         ]
-        assert _filter_union_branch_errors(errors) == errors
+        assert _sanitize_validation_errors(errors) == errors
 
     def test_picks_branch_with_fewer_literal_errors(self) -> None:
         errors = [
@@ -37,7 +37,7 @@ def test_picks_branch_with_fewer_literal_errors(self) -> None:
                 "msg": "Field required",
             },
         ]
-        result = _filter_union_branch_errors(errors)
+        result = _sanitize_validation_errors(errors)
         assert len(result) == 2
         for err in result:
             assert "NativeConfig" not in err["loc"]
@@ -56,7 +56,7 @@ def test_tied_branches_keep_both_and_dedup(self) -> None:
                 "msg": "Field required",
             },
         ]
-        result = _filter_union_branch_errors(errors)
+        result = _sanitize_validation_errors(errors)
         assert len(result) == 1
         assert result[0]["loc"] == ("body", "c", "x")
 
@@ -74,7 +74,7 @@ def test_strips_branch_identifiers_from_loc(self) -> None:
                 "msg": "Field required",
             }
         ]
-        result = _filter_union_branch_errors(errors)
+        result = _sanitize_validation_errors(errors)
         assert result[0]["loc"] == ("body", "cfg", "completion", "params")
 
     def test_non_union_preserved_with_union(self) -> None:
@@ -91,17 +91,17 @@ def test_non_union_preserved_with_union(self) -> None:
                 "msg": "Field required",
             },
         ]
-        result = _filter_union_branch_errors(errors)
+        result = _sanitize_validation_errors(errors)
         assert len(result) == 2
         locs = [r["loc"] for r in result]
         assert ("body", "name") in locs
 
     def test_empty_list(self) -> None:
-        assert _filter_union_branch_errors([]) == []
+        assert _sanitize_validation_errors([]) == []
 
     def test_fallback_on_malformed_input(self) -> None:
         malformed = [None, 42]  # type: ignore[list-item]
-        result = _filter_union_branch_errors(malformed)
+        result = _sanitize_validation_errors(malformed)
         assert result == malformed