Skip to content

Handle Repeatable Constraints #267

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Jan 26, 2025
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,31 @@
package example.avaje.repeat;

import jakarta.validation.Valid;
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 = 5, 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 SignupRequest(String password) {
this.password = password;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}
}
Original file line number Diff line number Diff line change
@@ -1,3 +1,11 @@
example.avaje.MyKey.message=Invalid MyKey
example.avaje.MySerial.message=Invalid my serial
org.foo.MyCustomALong.message=Invalid special number

signup.password.notblank1=Signup password must not be blank
signup.password.size=Signup password size error
signup.password.invalid=Signup password invalid
signup.password.lowercase=Signup must have a lower case
signup.password.uppercase=Signup must have at least 1 upper case
signup.password.digit=Signup digit
signup.password.special=Signup special character
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
package example.avaje.repeat;

import io.avaje.validation.ConstraintViolation;
import io.avaje.validation.ConstraintViolationException;
import io.avaje.validation.Validator;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;

class SignupRequestTest {

final Validator validator = Validator.builder()
.addResourceBundles("example.avaje.CustomMessages")
.build();

@Test
void lowercaseNoSpecial() {
SignupRequest req = new SignupRequest("foo");

var violations = all(req, Locale.ENGLISH);
assertThat(violations).hasSize(3);
assertThat(violations.get(0).message()).isEqualTo("Signup password size error");
assertThat(violations.get(1).message()).isEqualTo("Signup must have at least 1 upper case");
assertThat(violations.get(2).message()).isEqualTo("Signup special character");
}

@Test
void missingDigit() {
SignupRequest req = new SignupRequest("fooBar!");

var violations = all(req, Locale.ENGLISH);
assertThat(violations).hasSize(1);
assertThat(violations.get(0).message()).isEqualTo("Signup digit");
}

List<ConstraintViolation> all(Object any, Locale locale) {
try {
validator.validate(any, locale);
fail("not expected");
return List.of();
} catch (ConstraintViolationException e) {
return new ArrayList<>(e.violations());
}
}
}
2 changes: 1 addition & 1 deletion validator-generator/pom.xml
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
Original file line number Diff line number Diff line change
@@ -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;
Expand Down Expand Up @@ -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;
Expand All @@ -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());
}
Expand All @@ -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;
Expand All @@ -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();
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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);

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -2,148 +2,112 @@

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<>();
UType uType;
if (element instanceof final ExecutableElement executableElement) {
uType = UType.parse(executableElement.getReturnType());
} else {
uType = UType.parse(element.asType());
}

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)));

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)));

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)));
final var hasValid =
ValidPrism.isPresent(element)
|| uType.annotations().stream().anyMatch(ValidPrism::isInstance);

List<Entry<UType, String>> typeUse1 = typeUseFor(uType.param0(), element);
List<Entry<UType, String>> typeUse2 = typeUseFor(uType.param1(), element);

final List<Entry<UType, String>> crossParam = new ArrayList<>();
final var annotations = annotations(element, uType, crossParam);

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);
}

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(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());
}

private static List<Entry<UType, String>> typeUseFor(UType uType, Element element) {
return Optional.ofNullable(uType).map(UType::annotations).stream()
.flatMap(List::stream)
.filter(ElementAnnotationContainer::hasMetaConstraintAnnotation)
.map(a ->
Map.entry(
UType.parse(a.getAnnotationType()),
AnnotationUtil.annotationAttributeMap(a, element)))
.toList();
}

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()) {
Expand Down
Loading