Add @UUID validator

blackbox-test/src/test/java/example/avaje/uuid/AUuid.java

@@ -0,0 +1,13 @@
+package example.avaje.uuid;
+
+import io.avaje.validation.constraints.UUID;
+import jakarta.validation.Valid;
+
+@Valid
+public record AUuid(
+  @UUID
+  String str,
+  @UUID
+  CharSequence charSequence
+) {
+}

blackbox-test/src/test/java/example/avaje/uuid/AUuidTest.java

@@ -0,0 +1,70 @@
+package example.avaje.uuid;
+
+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.Locale;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+class AUuidTest {
+
+  final Validator validator = Validator.builder().addLocales(Locale.GERMAN).build();
+
+  @Test
+  void valid() {
+    var value = new AUuid(UUID.randomUUID().toString(), UUID.randomUUID().toString());
+    validator.validate(value);
+  }
+
+  @Test
+  void validNull() {
+    var value = new AUuid(null, null);
+    validator.validate(value);
+  }
+
+  @Test
+  void asString() {
+    var violation = one(new AUuid("Not", UUID.randomUUID().toString()));
+    assertThat(violation.message()).isEqualTo("must be a valid UUID");
+  }
+
+  @Test
+  void asStringDE() {
+    var violation = one(new AUuid("Not", UUID.randomUUID().toString()), Locale.GERMAN);
+    assertThat(violation.message()).isEqualTo("muss eine gültige UUID sein");
+  }
+
+  @Test
+  void asCharSequence() {
+    var violation = one(new AUuid(UUID.randomUUID().toString(), "Not"));
+    assertThat(violation.message()).isEqualTo("must be a valid UUID");
+  }
+
+  @Test
+  void asCharSequenceDE() {
+    var violation = one(new AUuid(UUID.randomUUID().toString(), "Not"), Locale.GERMAN);
+    assertThat(violation.message()).isEqualTo("muss eine gültige UUID sein");
+  }
+
+  ConstraintViolation one(Object any) {
+    return one(any, Locale.ENGLISH);
+  }
+
+  ConstraintViolation one(Object any, Locale locale) {
+    try {
+      validator.validate(any, locale);
+      fail("not expected");
+      return null;
+    } catch (ConstraintViolationException e) {
+      var violations = new ArrayList<>(e.violations());
+      assertThat(violations).hasSize(1);
+      return violations.get(0);
+    }
+  }
+}

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

@@ -0,0 +1,32 @@
+package io.avaje.validation.constraints;
+
+import java.lang.annotation.*;
+
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * The annotated element must be a String validated to be a valid UUID.
+ *
+ * <p>Supported types are:
+ *
+ * <ul>
+ *   <li>{@code String}
+ *   <li>{@code CharSequence}
+ * </ul>
+ */
+@Constraint
+@Target({METHOD, FIELD, ANNOTATION_TYPE, PARAMETER, TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(UUID.List.class)
+public @interface UUID {
+  String message() default "{avaje.UUID.message}";
+
+  Class<?>[] groups() default {};
+
+  @Target({ElementType.METHOD, ElementType.FIELD})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Documented
+  public @interface List {
+    UUID[] value();
+  }
+}

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

@@ -65,6 +65,7 @@ interface Handler {
       "PositiveOrZero",
       "Negative",
       "NegativeOrZero",
+      "UUID"
     };
     for (final String key : keys) {
       handlers.put("io.avaje.validation.constraints." + key, commonHandler);

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

@@ -21,6 +21,7 @@ private BasicAdapters() {}
       request ->
           switch (request.annotationType().getSimpleName()) {
             case "Email" -> new EmailAdapter(request);
+            case "UUID" -> new UuidAdapter(request);
             case "Null" -> new NullableAdapter(request, true);
             case "NotNull", "NonNull" -> new NullableAdapter(request, false);
             case "AssertTrue" -> new AssertBooleanAdapter(request, Boolean.TRUE);

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

@@ -0,0 +1,26 @@
+package io.avaje.validation.core.adapters;
+
+import io.avaje.validation.adapter.AbstractConstraintAdapter;
+import io.avaje.validation.adapter.ValidationContext.AdapterCreateRequest;
+
+import java.util.UUID;
+
+final class UuidAdapter extends AbstractConstraintAdapter {
+
+  UuidAdapter(AdapterCreateRequest request) {
+    super(request);
+  }
+
+  @Override
+  protected boolean isValid(Object value) {
+    if (value == null) {
+      return true;
+    }
+    try {
+      UUID.fromString(String.valueOf(value));
+      return true;
+    } catch (IllegalArgumentException e) {
+      return false;
+    }
+  }
+}