add groups to valid (#274)

* add groups to valid

- add a valid adapter
- will request a valid adapter only if the valid annotation has groups

* Format and extract helper method only

---------

Co-authored-by: Rob Bygrave <robin.bygrave@gmail.com>

Author: SentryMan

blackbox-test/src/main/java/example/avaje/cascade/ACrew.java

@@ -4,5 +4,5 @@
 import io.avaje.validation.constraints.Valid;
 
 @Valid
-public record ACrew (@NotBlank(max = 4) String name) {
+public record ACrew(@NotBlank(max = 4) String name) {
 }

blackbox-test/src/main/java/example/avaje/cascade/CascadeGroup.java

@@ -0,0 +1,11 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.constraints.NotBlank;
+import io.avaje.validation.constraints.NotNull;
+import io.avaje.validation.constraints.Valid;
+
+@Valid
+public record CascadeGroup(@Valid(groups = {CascadeGroup.class}) @NotNull Cascaded name) {
+
+  public record Cascaded(@NotBlank(groups = {CascadeGroup.class}) String val) {}
+}

blackbox-test/src/test/java/example/avaje/cascade/CascadeGroupTest.java

@@ -0,0 +1,30 @@
+package example.avaje.cascade;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+import example.avaje.cascade.CascadeGroup.Cascaded;
+import io.avaje.validation.Validator;
+
+class CascadeGroupTest {
+
+  Validator validator =
+      Validator.builder()
+          .add(CascadeGroup.class, CascadeGroupValidationAdapter::new)
+          .add(CascadeGroup.Cascaded.class, CascadeGroup$CascadedValidationAdapter::new)
+          .build();
+
+  @Test
+  void valid() {
+    var value = new CascadeGroup(new Cascaded(""));
+    assertThat(validator.check(value)).isEmpty();
+  }
+
+  @Test
+  void validGroup() {
+    var value = new CascadeGroup(new Cascaded(""));
+    assertThat(validator.check(value, CascadeGroup.class).iterator().next())
+        .matches(c -> "must not be blank".equals(c.message()));
+  }
+}

validator-constraints/src/main/java/io/avaje/validation/constraints/Valid.java

@@ -19,4 +19,9 @@
  */
 @Retention(CLASS)
 @Target({TYPE, TYPE_USE, FIELD})
-public @interface Valid {}
+public @interface Valid {
+
+  /** Validation groups to use */
+  Class<?>[] groups() default {};
+
+}

validator-generator/src/main/java/io/avaje/validation/generator/AdapterHelper.java

@@ -122,7 +122,7 @@ private void writeFirst(List<Entry<UType, String>> annotations) {
         first = false;
         continue;
       }
-      writer.eol().append("%s    .andThen(ctx.adapter(%s.class,%s))", indent, a.getKey().shortWithoutAnnotations(), a.getValue());
+      writer.eol().append("%s    .andThen(ctx.adapter(%s.class, %s))", indent, a.getKey().shortWithoutAnnotations(), a.getValue());
     }
     if (annotations.isEmpty()) {
       writer.append("%sctx.<%s>noop()", indent, type);
@@ -150,7 +150,7 @@ private void writeTypeUse(UType uType, List<Entry<UType, String>> typeUse1, bool
       }
       final var k = a.getKey().shortType();
       final var v = a.getValue();
-      writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class,%s))", indent, k, v);
+      writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class, %s))", indent, k, v);
     }
 
     if (!Util.isBasicType(uType.fullWithoutAnnotations())

validator-generator/src/main/java/io/avaje/validation/generator/ElementAnnotationContainer.java

@@ -5,6 +5,7 @@
 import static java.util.stream.Collectors.toList;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -16,6 +17,7 @@
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
 
 record ElementAnnotationContainer(
     UType genericType,
@@ -53,7 +55,7 @@ static ElementAnnotationContainer create(Element element) {
 
   private static List<Entry<UType, String>> annotations(Element element, UType uType, List<Entry<UType, String>> crossParam) {
     return Stream.concat(element.getAnnotationMirrors().stream(), uType.annotations().stream())
-      .filter(m -> !ValidPrism.isInstance(m))
+      .filter(a -> excludePlainValid(a, element))
       .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
       .map(a -> {
         if (CrossParamConstraintPrism.isPresent(a.getAnnotationType().asElement())) {
@@ -71,9 +73,18 @@ private static List<Entry<UType, String>> annotations(Element element, UType uTy
           UType.parse(a.getAnnotationType()),
           AnnotationUtil.annotationAttributeMap(a, element)))
       .distinct()
+      // valid annotation goes last
+      .sorted(Comparator.comparing(
+          e -> e.getKey().shortType(),
+          Comparator.comparing("Valid"::equals)))
       .collect(toList());
   }
 
+  /** Only include Valid with groups defined */
+  private static boolean excludePlainValid(AnnotationMirror a, Element element) {
+    return !ValidPrism.isInstance(a) || !ValidPrism.instance(a).groups().isEmpty() && !(element instanceof TypeElement);
+  }
+
   private static List<Entry<UType, String>> typeUseFor(UType uType, Element element) {
     return Optional.ofNullable(uType).map(UType::annotations).stream()
       .flatMap(List::stream)

validator-generator/src/main/java/io/avaje/validation/generator/ValidPrism.java

@@ -1,7 +1,11 @@
 package io.avaje.validation.generator;
 
+import java.util.List;
+import java.util.Optional;
+
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
+import javax.lang.model.type.TypeMirror;
 
 import io.avaje.prism.GeneratePrism;
 
@@ -36,4 +40,17 @@ static boolean isInstance(AnnotationMirror e) {
         || JavaxValidPrism.getInstance(e) != null
         || HttpValidPrism.getInstance(e) != null;
   }
+
+  static ValidPrism instance(AnnotationMirror e) {
+    return Optional.<ValidPrism>empty()
+        .or(() -> AvajeValidPrism.getOptional(e))
+        .or(() -> JakartaValidPrism.getOptional(e))
+        .or(() -> JavaxValidPrism.getOptional(e))
+        .or(() -> HttpValidPrism.getOptional(e))
+        .orElse(null);
+  }
+
+  default List<TypeMirror> groups() {
+    return List.of();
+  }
 }

validator/src/main/java/io/avaje/validation/core/adapters/BasicAdapters.java

@@ -36,6 +36,7 @@ private BasicAdapters() {}
             case "NotEmpty" -> new NotEmptyAdapter(request);
             case "Pattern" -> new PatternAdapter(request);
             case "Size", "Length" -> new SizeAdapter(request);
+            case "Valid" -> new ValidAdapter(request);
             default -> null;
           };
 
@@ -273,6 +274,20 @@ public boolean validate(Object value, ValidationRequest req, String propertyName
     }
   }
 
+  private static final class ValidAdapter implements ValidationAdapter<Object> {
+
+    private final Set<Class<?>> groups;
+
+    ValidAdapter(AdapterCreateRequest request) {
+      this.groups = request.groups();
+    }
+
+    @Override
+    public boolean validate(Object value, ValidationRequest req, String propertyName) {
+      return checkGroups(groups, req);
+    }
+  }
+
   private static int arrayLength(Object array) {
     if (array instanceof final int[] intArr) {
       return intArr.length;