Handle Repeatable Constraints

validator-generator/pom.xml

@@ -13,7 +13,7 @@
   <name>validator generator</name>
   <description>annotation processor generating validation adapters</description>
   <properties>
-    <avaje.prisms.version>1.31</avaje.prisms.version>
+    <avaje.prisms.version>1.38</avaje.prisms.version>
   </properties>
 
   <dependencies>

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

@@ -1,9 +1,10 @@
 package io.avaje.validation.generator;
 
-import java.util.Map;
-
 import static io.avaje.validation.generator.APContext.isAssignable;
 
+import java.util.List;
+import java.util.Map.Entry;
+
 final class AdapterHelper {
 
   private final Append writer;
@@ -113,9 +114,9 @@ void write() {
     }
   }
 
-  private void writeFirst(Map<UType, String> annotations) {
+  private void writeFirst( List<Entry<UType, String>> annotations) {
     boolean first = true;
-    for (final var a : annotations.entrySet()) {
+    for (final var a : annotations) {
       if (first) {
         writer.append("%sctx.<%s>adapter(%s.class, %s)", indent, type, a.getKey().shortWithoutAnnotations(), a.getValue());
         first = false;
@@ -128,7 +129,7 @@ private void writeFirst(Map<UType, String> annotations) {
     }
   }
 
-  private boolean isMapType(Map<UType, String> typeUse1, Map<UType, String> typeUse2) {
+  private boolean isMapType(List<Entry<UType, String>> typeUse1, List<Entry<UType, String>> typeUse2) {
     return (!typeUse1.isEmpty() || !typeUse2.isEmpty())
       && "java.util.Map".equals(genericType.mainType());
   }
@@ -137,12 +138,12 @@ private boolean isTopTypeIterable() {
     return mainType != null && isAssignable(mainType.mainType(), "java.lang.Iterable");
   }
 
-  private void writeTypeUse(UType uType, Map<UType, String> typeUse12) {
-    writeTypeUse(uType, typeUse12, true);
+  private void writeTypeUse(UType uType, List<Entry<UType, String>> typeUse1) {
+    writeTypeUse(uType, typeUse1, true);
   }
 
-  private void writeTypeUse(UType uType, Map<UType, String> typeUseMap, boolean keys) {
-    for (final var a : typeUseMap.entrySet()) {
+  private void writeTypeUse(UType uType, List<Entry<UType, String>> typeUse1, boolean keys) {
+    for (final var a : typeUse1) {
 
       if (Constants.VALID_ANNOTATIONS.contains(a.getKey().mainType())) {
         continue;
@@ -153,7 +154,7 @@ private void writeTypeUse(UType uType, Map<UType, String> typeUseMap, boolean ke
     }
 
     if (!Util.isBasicType(uType.fullWithoutAnnotations())
-        && typeUseMap.keySet().stream()
+        && typeUse1.stream().map(Entry::getKey)
             .map(UType::mainType)
             .anyMatch(Constants.VALID_ANNOTATIONS::contains)) {
       var typeUse = keys ? genericType.param0() : genericType.param1();

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

@@ -35,7 +35,6 @@ private void readMetaData(TypeElement moduleType) {
 
       if (metaData != null) {
         metaData.value().stream().map(TypeMirror::toString).forEach(componentMetaData::add);
-
       } else if (metaDataFactory != null) {
         metaDataFactory.value().stream().map(TypeMirror::toString).forEach(componentMetaData::add);
 

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

@@ -2,156 +2,131 @@
 
 import static io.avaje.validation.generator.APContext.typeElement;
 import static io.avaje.validation.generator.PrimitiveUtil.isPrimitiveValidationAnnotations;
-import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toList;
 
-import java.util.HashMap;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.VariableElement;
 
 record ElementAnnotationContainer(
     UType genericType,
     boolean hasValid,
-    Map<UType, String> annotations,
-    Map<UType, String> typeUse1,
-    Map<UType, String> typeUse2,
-    Map<UType, String> crossParam) {
+    List<Entry<UType, String>> annotations,
+    List<Entry<UType, String>> typeUse1,
+    List<Entry<UType, String>> typeUse2,
+    List<Entry<UType, String>> crossParam) {
 
   static ElementAnnotationContainer create(Element element) {
-    final var hasValid = ValidPrism.isPresent(element);
-    Map<UType, String> typeUse1;
-    Map<UType, String> typeUse2;
-    final Map<UType, String> crossParam = new HashMap<>();
+    List<Entry<UType, String>> typeUse1;
+    List<Entry<UType, String>> typeUse2;
+    final List<Entry<UType, String>> crossParam = new ArrayList<>();
     UType uType;
     if (element instanceof final ExecutableElement executableElement) {
       uType = UType.parse(executableElement.getReturnType());
     } else {
       uType = UType.parse(element.asType());
     }
 
+    final var hasValid =
+        ValidPrism.isPresent(element)
+            || uType.annotations().stream().anyMatch(ValidPrism::isInstance);
+
     typeUse1 =
-      Optional.ofNullable(uType.param0()).map(UType::annotations).stream()
-        .flatMap(List::stream)
-        .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
-        .collect(
-          toMap(
-            a -> UType.parse(a.getAnnotationType()),
-            a -> AnnotationUtil.annotationAttributeMap(a, element)));
+        Optional.ofNullable(uType.param0()).map(UType::annotations).stream()
+            .flatMap(List::stream)
+            .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
+            .map(
+                a ->
+                    Map.entry(
+                        UType.parse(a.getAnnotationType()),
+                        AnnotationUtil.annotationAttributeMap(a, element)))
+            .toList();
 
     typeUse2 =
-      Optional.ofNullable(uType.param1()).map(UType::annotations).stream()
-        .flatMap(List::stream)
-        .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
-        .collect(
-          toMap(
-            a -> UType.parse(a.getAnnotationType()),
-            a -> AnnotationUtil.annotationAttributeMap(a, element)));
+        Optional.ofNullable(uType.param1()).map(UType::annotations).stream()
+            .flatMap(List::stream)
+            .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
+            .map(
+                a ->
+                    Map.entry(
+                        UType.parse(a.getAnnotationType()),
+                        AnnotationUtil.annotationAttributeMap(a, element)))
+            .toList();
 
     final var annotations =
-      element.getAnnotationMirrors().stream()
-        .filter(m -> !ValidPrism.isInstance(m))
-        .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
-        .map(a -> {
-          if (CrossParamConstraintPrism.isPresent(a.getAnnotationType().asElement())) {
-            crossParam.put(
-              UType.parse(a.getAnnotationType()),
-              AnnotationUtil.annotationAttributeMap(a, element));
-            return null;
-          }
-          return a;
-        })
-        .filter(Objects::nonNull)
-        .collect(
-          toMap(
-            a -> UType.parse(a.getAnnotationType()),
-            a -> AnnotationUtil.annotationAttributeMap(a, element)));
+        Stream.concat(element.getAnnotationMirrors().stream(), uType.annotations().stream())
+            .filter(m -> !ValidPrism.isInstance(m))
+            .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
+            .map(
+                a -> {
+                  if (CrossParamConstraintPrism.isPresent(a.getAnnotationType().asElement())) {
+                    crossParam.add(
+                        Map.entry(
+                            UType.parse(a.getAnnotationType()),
+                            AnnotationUtil.annotationAttributeMap(a, element)));
+                    return null;
+                  }
+                  return a;
+                })
+            .filter(Objects::nonNull)
+            .map(
+                a ->
+                    Map.entry(
+                        UType.parse(a.getAnnotationType()),
+                        AnnotationUtil.annotationAttributeMap(a, element)))
+            .distinct()
+            .collect(toList());
 
     if (Util.isNonNullable(element)) {
       var nonNull = UType.parse(APContext.typeElement(NonNullPrism.PRISM_TYPE).asType());
-      annotations.put(nonNull, "Map.of(\"message\",\"{avaje.NotNull.message}\")");
+      annotations.add(Map.entry(nonNull, "Map.of(\"message\",\"{avaje.NotNull.message}\")"));
     }
 
-    return new ElementAnnotationContainer(uType, hasValid, annotations, typeUse1, typeUse2, crossParam);
+    return new ElementAnnotationContainer(
+        uType, hasValid, annotations, typeUse1, typeUse2, crossParam);
   }
 
   static boolean hasMetaConstraintAnnotation(AnnotationMirror m) {
     return hasMetaConstraintAnnotation(m.getAnnotationType().asElement())
-      || ValidPrism.isInstance(m);
+        || ValidPrism.isInstance(m);
   }
 
   static boolean hasMetaConstraintAnnotation(Element element) {
     return ConstraintPrism.isPresent(element);
   }
 
-  // it seems we cannot directly retrieve mirrors from var elements, so var Elements needs special handling
-
-  static ElementAnnotationContainer create(VariableElement varElement) {
-    var uType = UType.parse(varElement.asType());
-    final var annotations =
-      uType.annotations().stream()
-        .filter(m -> !ValidPrism.isInstance(m))
-        .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
-        .collect(
-          toMap(
-            a -> UType.parse(a.getAnnotationType()),
-            a -> AnnotationUtil.annotationAttributeMap(a, varElement)));
-
-    var typeUse1 =
-      Optional.ofNullable(uType.param0()).map(UType::annotations).stream()
-        .flatMap(List::stream)
-        .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
-        .collect(
-          toMap(
-            a -> UType.parse(a.getAnnotationType()),
-            a -> AnnotationUtil.annotationAttributeMap(a, varElement)));
-
-    var typeUse2 =
-      Optional.ofNullable(uType.param1()).map(UType::annotations).stream()
-        .flatMap(List::stream)
-        .filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
-        .collect(
-          toMap(
-            a -> UType.parse(a.getAnnotationType()),
-            a -> AnnotationUtil.annotationAttributeMap(a, varElement)));
-
-    final boolean hasValid = uType.annotations().stream().anyMatch(ValidPrism::isInstance);
-
-    if (Util.isNonNullable(varElement)) {
-      var nonNull = UType.parse(APContext.typeElement(NonNullPrism.PRISM_TYPE).asType());
-      annotations.put(nonNull, "Map.of(\"message\",\"{avaje.NotNull.message}\")");
-    }
-
-    return new ElementAnnotationContainer(uType, hasValid, annotations, typeUse1, typeUse2, Map.of());
-  }
-
   public void addImports(Set<String> importTypes) {
     importTypes.addAll(genericType.importTypes());
-    annotations.keySet().forEach(t -> importTypes.addAll(t.importTypes()));
-    typeUse1.keySet().forEach(t -> importTypes.addAll(t.importTypes()));
-    typeUse2.keySet().forEach(t -> importTypes.addAll(t.importTypes()));
+    annotations.forEach(t -> importTypes.addAll(t.getKey().importTypes()));
+    typeUse1.forEach(t -> importTypes.addAll(t.getKey().importTypes()));
+    typeUse2.forEach(t -> importTypes.addAll(t.getKey().importTypes()));
   }
 
   boolean isEmpty() {
     return annotations.isEmpty() && typeUse1.isEmpty() && typeUse2.isEmpty();
   }
 
   boolean supportsPrimitiveValidation() {
-    for (final var validationAnnotation : annotations.keySet()) {
+    for (final var entry : annotations) {
+      var validationAnnotation = entry.getKey();
       ConstraintPrism.getOptionalOn(typeElement(validationAnnotation.full()))
-        .ifPresent(p -> {
-          if (p.unboxPrimitives()) {
-            validationAnnotation
-              .shortType()
-              .transform(PrimitiveUtil::addPrimitiveValidationAnnotation);
-          }
-        });
+          .ifPresent(
+              p -> {
+                if (p.unboxPrimitives()) {
+                  validationAnnotation
+                      .shortType()
+                      .transform(PrimitiveUtil::addPrimitiveValidationAnnotation);
+                }
+              });
 
       if (!isPrimitiveValidationAnnotations(validationAnnotation.shortType())) {
         return false;

validator-generator/src/test/java/io/avaje/validation/generator/models/valid/SignupRequest.java

@@ -0,0 +1,28 @@
+package io.avaje.validation.generator.models.valid;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+
+@Valid
+public class SignupRequest {
+
+  @NotBlank(message = "{signup.password.notblank1}")
+  @Size(min = 16, max = 32, message = "{signup.password.size}")
+  @Pattern(regexp = "^[a-zA-Z0-9!@#$^&*]*$", message = "{signup.password.invalid}")
+  @Pattern(regexp = ".*[a-z].*", message = "{signup.password.lowercase}")
+  @Pattern(regexp = ".*[A-Z].*", message = "{signup.password.uppercase}")
+  @Pattern(regexp = ".*[0-9].*", message = "{signup.password.digit}")
+  @Pattern(regexp = ".*[!@#$^&*].*", message = "{signup.password.special}")
+  private String password;
+
+  public String getPassword() {
+    return password;
+  }
+
+  public void setPassword(String password) {
+    this.password = password;
+  }
+}