#295 Programmatic validation property path handling

integration-test/core/src/main/java/io/quarkiverse/resteasy/problem/ValidationExceptionsResource.java

@@ -1,9 +1,16 @@
 package io.quarkiverse.resteasy.problem;
 
+import java.util.Set;
+
+import jakarta.inject.Inject;
+import jakarta.validation.ConstraintViolation;
+import jakarta.validation.ConstraintViolationException;
 import jakarta.validation.Valid;
 import jakarta.validation.ValidationException;
+import jakarta.validation.Validator;
 import jakarta.validation.constraints.AssertFalse;
 import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
 import jakarta.ws.rs.GET;
 import jakarta.ws.rs.HeaderParam;
 import jakarta.ws.rs.POST;
@@ -18,6 +25,9 @@
 @Produces(MediaType.APPLICATION_JSON)
 public class ValidationExceptionsResource {
 
+    @Inject
+    Validator validator;
+
     @GET
     @Path("/validation-exception")
     public void throwValidationException(@QueryParam("message") String message) {
@@ -44,9 +54,75 @@ public void throwConstraintViolationException(
             @Valid TestRequestBody invalidPayload) {
     }
 
+    @POST
+    @Path("/constraint-violation-exception/programmatic")
+    public void throwConstraintViolationExceptionProgrammatic(@QueryParam("name") String name) {
+        // Create an object with validation constraints
+        ProgrammaticTestBean bean = new ProgrammaticTestBean();
+        bean.name = name;
+        bean.email = "invalid-email"; // Invalid email format
+        bean.age = 5; // Below minimum age
+
+        // Validate programmatically
+        Set<ConstraintViolation<ProgrammaticTestBean>> violations = validator.validate(bean);
+        if (!violations.isEmpty()) {
+            throw new ConstraintViolationException(violations);
+        }
+    }
+
+    @POST
+    @Path("/constraint-violation-exception/programmatic/nested")
+    public void throwConstraintViolationExceptionProgrammaticNested(@QueryParam("companyName") String companyName) {
+        // Create nested object with validation constraints
+        ProgrammaticNestedTestBean bean = new ProgrammaticNestedTestBean();
+        bean.companyName = companyName;
+        bean.address = new ProgrammaticTestAddress();
+        bean.address.street = ""; // Empty street (invalid)
+        bean.address.city = "A"; // Too short city name
+
+        // Validate programmatically
+        Set<ConstraintViolation<ProgrammaticNestedTestBean>> violations = validator.validate(bean);
+        if (!violations.isEmpty()) {
+            throw new ConstraintViolationException(violations);
+        }
+    }
+
     public static final class TestRequestBody {
         @Min(15)
         public int phraseName;
     }
 
+    public static final class ProgrammaticTestBean {
+        @NotNull
+        @Length(min = 2, max = 50)
+        public String name;
+
+        @NotNull
+        @jakarta.validation.constraints.Email
+        public String email;
+
+        @Min(18)
+        public int age;
+    }
+
+    public static final class ProgrammaticNestedTestBean {
+        @NotNull
+        @Length(min = 3, max = 100)
+        public String companyName;
+
+        @Valid
+        @NotNull
+        public ProgrammaticTestAddress address;
+    }
+
+    public static final class ProgrammaticTestAddress {
+        @NotNull
+        @Length(min = 5, max = 200)
+        public String street;
+
+        @NotNull
+        @Length(min = 2, max = 100)
+        public String city;
+    }
+
 }

integration-test/core/src/test/java/io/quarkiverse/resteasy/problem/ValidationMappersIT.java

@@ -88,4 +88,72 @@ void constraintViolationForArgumentsShouldProvideErrorDetails() {
                 .body("violations.find{it.in == 'body'}.message", equalTo("must be greater than or equal to 15"));
     }
 
+    @Test
+    void constraintViolationDeclarativeShouldStripMethodNamesFromPropertyPath() {
+        // This test ensures that declarative validation violations properly strip method names
+        // from property paths (e.g., "methodName.parameter.field" becomes "field")
+        given()
+                .contentType(APPLICATION_JSON)
+                .body("{\"phraseName\": 1}")
+                .post("/throw/validation/constraint-violation-exception")
+                .then()
+                .statusCode(BAD_REQUEST.getStatusCode())
+                .body("violations", hasSize(1))
+                // Verify that field name is clean (no method name like "throwConstraintViolationException.body.phraseName")
+                .body("violations[0].field", equalTo("phraseName"))
+                .body("violations[0].message", equalTo("must be greater than or equal to 15"))
+                .body("violations[0].in", equalTo("body"));
+    }
+
+    @Test
+    void constraintViolationProgrammaticShouldProvideErrorDetails() {
+        given()
+                .queryParam("name", "A") // Too short name
+                .contentType(APPLICATION_JSON)
+                .post("/throw/validation/constraint-violation-exception/programmatic")
+                .then()
+                .statusCode(BAD_REQUEST.getStatusCode())
+                .body("title", equalTo(BAD_REQUEST.getReasonPhrase()))
+                .body("status", equalTo(BAD_REQUEST.getStatusCode()))
+                .body("violations", hasSize(3))
+                .body("violations.find{it.field == 'name'}.message", equalTo("length must be between 2 and 50"))
+                .body("violations.find{it.field == 'email'}.message", equalTo("must be a well-formed email address"))
+                .body("violations.find{it.field == 'age'}.message", equalTo("must be greater than or equal to 18"))
+                .body("stacktrace", nullValue());
+    }
+
+    @Test
+    void constraintViolationProgrammaticNestedShouldProvideErrorDetails() {
+        given()
+                .queryParam("companyName", "AB") // Too short company name
+                .contentType(APPLICATION_JSON)
+                .post("/throw/validation/constraint-violation-exception/programmatic/nested")
+                .then()
+                .statusCode(BAD_REQUEST.getStatusCode())
+                .body("title", equalTo(BAD_REQUEST.getReasonPhrase()))
+                .body("status", equalTo(BAD_REQUEST.getStatusCode()))
+                .body("violations", hasSize(3))
+                .body("violations.find{it.field == 'companyName'}.message", equalTo("length must be between 3 and 100"))
+                .body("violations.find{it.field == 'address.street'}.message", equalTo("length must be between 5 and 200"))
+                .body("violations.find{it.field == 'address.city'}.message", equalTo("length must be between 2 and 100"))
+                .body("stacktrace", nullValue());
+    }
+
+    @Test
+    void constraintViolationProgrammaticShouldNotStripMethodNamesFromPropertyPath() {
+        // This test ensures that programmatic validation violations preserve the original property path
+        // without stripping method names (since there are no method names in programmatic validation)
+        given()
+                .queryParam("name", "A") // Short name to trigger @Length constraint (but not @NotNull)
+                .contentType(APPLICATION_JSON)
+                .post("/throw/validation/constraint-violation-exception/programmatic")
+                .then()
+                .statusCode(BAD_REQUEST.getStatusCode())
+                .body("violations", hasSize(3))
+                // Verify that field names are simple property paths, not method.parameter.field
+                .body("violations.find{it.field == 'name'}.message", equalTo("length must be between 2 and 50"))
+                .body("violations.find{it.field == 'email'}.message", equalTo("must be a well-formed email address"))
+                .body("violations.find{it.field == 'age'}.message", equalTo("must be greater than or equal to 18"));
+    }
+
 }

runtime/src/main/java/io/quarkiverse/resteasy/problem/validation/ConstraintViolationExceptionMapper.java

@@ -2,11 +2,7 @@
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -70,12 +66,22 @@ private List<Violation> toViolations(Set<ConstraintViolation<?>> constraintViola
     private Violation toViolation(ConstraintViolation<?> constraintViolation) {
         return matchEndpointMethodParameter(constraintViolation)
                 .map(param -> createViolation(constraintViolation, param))
-                .orElseGet(() -> Violation.In.unknown
-                        .field(dropMethodName(constraintViolation.getPropertyPath()))
-                        .message(constraintViolation.getMessage()));
+                .orElseGet(() -> {
+                    String field = isDeclarativeValidation(constraintViolation)
+                            ? dropMethodName(constraintViolation.getPropertyPath())
+                            : constraintViolation.getPropertyPath().toString();
+                    return Violation.In.unknown
+                            .field(field)
+                            .message(constraintViolation.getMessage());
+                });
+
     }
 
     private Optional<Parameter> matchEndpointMethodParameter(ConstraintViolation<?> violation) {
+        if (resourceInfo == null) {
+            return Optional.empty();
+        }
+
         Iterator<Path.Node> propertyPathIterator = violation.getPropertyPath().iterator();
         if (!propertyPathIterator.hasNext()) {
             return Optional.empty();
@@ -85,10 +91,11 @@ private Optional<Parameter> matchEndpointMethodParameter(ConstraintViolation<?>
             return Optional.empty();
         }
         String paramName = propertyPathIterator.next().getName();
-        Method method = resourceInfo.getResourceMethod();
-        return Stream.of(method.getParameters())
-                .filter(param -> param.getName().equals(paramName))
-                .findFirst();
+
+        return Optional.ofNullable(resourceInfo.getResourceMethod())
+                .flatMap(method -> Stream.of(method.getParameters())
+                        .filter(param -> param.getName().equals(paramName))
+                        .findFirst());
     }
 
     private Violation createViolation(ConstraintViolation<?> constraintViolation, Parameter param) {
@@ -140,4 +147,35 @@ private String serializePath(Path propertyPath, int skipFirstSegments) {
         return String.join(".", pathSegments);
     }
 
+    private boolean isDeclarativeValidation(ConstraintViolation<?> violation) {
+        if (noJaxRsContext()) {
+            return false;
+        }
+
+        if (rootBeanResourceClassMatches(violation)) {
+            return true;
+        }
+
+        if (propertyPathStartsWithMethod(violation)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean noJaxRsContext() {
+        return resourceInfo == null;
+    }
+
+    private boolean rootBeanResourceClassMatches(ConstraintViolation<?> violation) {
+        Object rootBean = violation.getRootBean();
+        return rootBean != null && resourceInfo.getResourceClass().isInstance(rootBean);
+    }
+
+    private boolean propertyPathStartsWithMethod(ConstraintViolation<?> violation) {
+        String propertyPath = violation.getPropertyPath().toString();
+        Method method = resourceInfo.getResourceMethod();
+        return method != null && propertyPath.startsWith(method.getName() + ".");
+    }
+
 }