Fix Optional Cascades (#343)

* Fix optional cascade

Turns out that using Valid on optional never worked

* Update PrimitiveOptional.java

* Update PrimitiveOptional.java

* final field in OptionalAdapter and format only

---------

Co-authored-by: robin.bygrave <robin.bygrave@eroad.com>

Author: SentryMan

blackbox-test/src/main/java/example/avaje/optional/CurseBearer.java

@@ -14,4 +14,8 @@ public record CurseBearer(
     @NotBlank(message = "it'll happen to you too") Optional<String> name,
     @Positive OptionalInt estus,
     @Positive(message = "You Died") OptionalLong souls,
-    @Positive(message = "you didn't pass the vigor check") OptionalDouble vigor) {}
+    @Positive(message = "you didn't pass the vigor check") OptionalDouble vigor,
+    @Valid Optional<DarkSign> ds) {
+
+  public record DarkSign(@NotBlank(message = "not cursed") String brand) {}
+}

blackbox-test/src/test/java/example/avaje/optional/OptionalTest.java

@@ -9,11 +9,10 @@
 import java.util.OptionalInt;
 import java.util.OptionalLong;
 import java.util.Set;
-import java.util.stream.Stream;
 
 import org.junit.jupiter.api.Test;
 
-import example.avaje.composable.Sans;
+import example.avaje.optional.CurseBearer.DarkSign;
 import io.avaje.validation.ConstraintViolation;
 import io.avaje.validation.ConstraintViolationException;
 import io.avaje.validation.Validator;
@@ -29,21 +28,26 @@ void valid() {
             Optional.of("Belmont"),
             OptionalInt.of(5),
             OptionalLong.of(10000),
-            OptionalDouble.of(42.0));
+            OptionalDouble.of(42.0),
+            Optional.empty());
     validator.validate(monarch);
   }
 
   @Test
   void validEmpty() {
     final var hollow =
         new CurseBearer(
-            Optional.empty(), OptionalInt.empty(), OptionalLong.empty(), OptionalDouble.empty());
+            Optional.empty(),
+            OptionalInt.empty(),
+            OptionalLong.empty(),
+            OptionalDouble.empty(),
+            Optional.empty());
     validator.validate(hollow);
   }
 
   @Test
   void validNull() {
-    final var hollow = new CurseBearer(null, null, null, null);
+    final var hollow = new CurseBearer(null, null, null, null, null);
     validator.validate(hollow);
   }
 
@@ -52,13 +56,18 @@ void invalid() {
     final var violations =
         violations(
             new CurseBearer(
-                Optional.of(""), OptionalInt.of(0), OptionalLong.of(0), OptionalDouble.of(0)));
+                Optional.of(""),
+                OptionalInt.of(0),
+                OptionalLong.of(0),
+                OptionalDouble.of(0),
+                Optional.of(new DarkSign(""))));
     assertThat(violations)
         .contains(
             "it'll happen to you too",
             "must be greater than 0",
             "You Died",
-            "you didn't pass the vigor check");
+            "you didn't pass the vigor check",
+            "not cursed");
   }
 
   Set<String> violations(Object any) {

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

@@ -7,6 +7,7 @@
 
 final class AdapterHelper {
 
+  private static final String OPTIONAL = "java.util.Optional";
   private final Append writer;
   private final ElementAnnotationContainer elementAnnotations;
   private final String indent;
@@ -68,7 +69,7 @@ void write() {
       return;
     }
 
-    if (!typeUse1.isEmpty() && (isAssignable(genericType.mainType(), "java.lang.Iterable"))) {
+    if (!typeUse1.isEmpty() && isAssignable(genericType.mainType(), "java.lang.Iterable")) {
       writer.eol().append("%s    .list()", indent);
       writeTypeUse(genericType.param0(), typeUse1);
 
@@ -100,22 +101,37 @@ void write() {
           indent, mainType.shortWithoutAnnotations().replace("[]", ""));
       }
 
-    } else if (hasValid) {
-      if (!classLevel) {
-        if (genericType.mainType().equals(recursiveType)) {
-          writer.eol().append("%s    .andThen(this)", indent);
+    } else if (OPTIONAL.equals(genericType.mainType())) {
+      // cascade validate
+      if (hasValid) {
+        if (mainType.param0().fullWithoutAnnotations().equals(recursiveType)) {
+          // cascade validate
+          writer.eol().append("%s    .andThen(this)", indent, mainType.param0().shortType());
         } else {
-          writer.eol().append("%s    .andThen(ctx.adapter(%s.class))", indent, genericType.shortWithoutAnnotations());
+          // cascade validate
+          writer.eol().append("%s    .andThen(ctx.adapter(%s.class))", indent, mainType.param0().shortType());
         }
       }
-
-    } else if (genericType.mainType().contains("java.util.Optional")) {
       writer.eol().append("%s    .optional()", indent);
+    } else if (genericType.mainType().contains(OPTIONAL)) {
+      writer.eol().append("%s    .primitiveOptional()", indent);
+    } else if (hasValid && !classLevel) {
+      if (genericType.mainType().equals(recursiveType)) {
+        writer.eol().append("%s    .andThen(this)", indent);
+      } else {
+        writer.eol().append("%s    .andThen(ctx.adapter(%s.class))", indent, genericType.shortWithoutAnnotations());
+      }
     }
   }
 
   private void writeFirst(List<Entry<UType, String>> annotations) {
     boolean first = true;
+
+    var type =
+      OPTIONAL.equals(genericType.mainType())
+        ? genericType.param0().shortWithoutAnnotations()
+        : this.type;
+
     for (final var a : annotations) {
       if (first) {
         writer.append("%sctx.<%s>adapter(%s.class, %s)", indent, type, a.getKey().shortWithoutAnnotations(), a.getValue());

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

@@ -119,7 +119,7 @@ void cascadeTypes(Set<String> types) {
     }
 
     final String mainType = genericType.mainType();
-    if ("java.util.List".equals(mainType) || "java.util.Set".equals(mainType)) {
+    if ("java.util.List".equals(mainType) || "java.util.Set".equals(mainType) || "java.util.Optional".equals(mainType)) {
       types.add(genericType.param0().fullWithoutAnnotations());
     } else if ("java.util.Map".equals(mainType)) {
       types.add(genericType.param1().fullWithoutAnnotations());

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

@@ -9,6 +9,7 @@ public class Contact {
   public String firstName;
   public String lastName;
 
+  @Valid
   public Optional<Address> address;
 
   public Contact() {

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

@@ -0,0 +1,21 @@
+package io.avaje.validation.generator.models.valid.optional;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import io.avaje.validation.constraints.NotBlank;
+import io.avaje.validation.constraints.Positive;
+import io.avaje.validation.constraints.Valid;
+
+@Valid
+public record CurseBearer(
+    @NotBlank(message = "it'll happen to you too") Optional<String> name,
+    @Positive OptionalInt estus,
+    @Positive(message = "You Died") OptionalLong souls,
+    @Positive(message = "you didn't pass the vigor check") OptionalDouble vigor,
+    @Valid Optional<DarkSign> ds) {
+
+  public record DarkSign(@NotBlank(message = "not cursed") String brand) {}
+}

validator/src/main/java/io/avaje/validation/adapter/OptionalAdapter.java

@@ -0,0 +1,22 @@
+package io.avaje.validation.adapter;
+
+import java.util.Optional;
+
+final class OptionalAdapter<T> implements ValidationAdapter<Optional<T>> {
+
+  private final ValidationAdapter<T> adapter;
+
+  OptionalAdapter(ValidationAdapter<T> adapter) {
+    this.adapter = adapter;
+  }
+
+  @Override
+  public boolean validate(Optional<T> value, ValidationRequest req, String propertyName) {
+    if (value == null) {
+      return true;
+    }
+
+    value.ifPresent(v -> adapter.validate(v, req, propertyName));
+    return true;
+  }
+}

…n/adapter/OptionalValidationAdapter.java …alidation/adapter/PrimitiveOptional.javavalidator/src/main/java/io/avaje/validation/adapter/OptionalValidationAdapter.java renamed to validator/src/main/java/io/avaje/validation/adapter/PrimitiveOptional.java validator/src/main/java/io/avaje/validation/adapter/OptionalValidationAdapter.java renamed to validator/src/main/java/io/avaje/validation/adapter/PrimitiveOptional.java

@@ -1,14 +1,13 @@
 package io.avaje.validation.adapter;
 
-import java.util.Optional;
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
 
-final class OptionalValidationAdapter<T> extends ContainerAdapter<T> {
+final class PrimitiveOptional<T> extends ContainerAdapter<T> {
 
-  OptionalValidationAdapter(ValidationAdapter<T> adapters) {
-    super(adapters);
+  PrimitiveOptional(ValidationAdapter<T> adapter) {
+    super(adapter);
   }
 
   @Override
@@ -17,9 +16,7 @@ public boolean validate(T value, ValidationRequest req, String propertyName) {
     if (value == null) {
       return true;
     }
-    if (value instanceof final Optional<?> o) {
-      o.ifPresent(v -> initalAdapter.validate((T) v, req, propertyName));
-    } else if (value instanceof final OptionalInt i) {
+    if (value instanceof final OptionalInt i) {
       i.ifPresent(v -> initalAdapter.validate((T) (Integer) v, req, propertyName));
     } else if (value instanceof final OptionalLong l) {
       l.ifPresent(v -> initalAdapter.validate((T) (Long) v, req, propertyName));

validator/src/main/java/io/avaje/validation/adapter/ValidationAdapter.java

@@ -1,6 +1,7 @@
 package io.avaje.validation.adapter;
 
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 
 /**
@@ -80,8 +81,17 @@ default ContainerAdapter<T> array() {
    *
    * @return The adapter for optional value validation
    */
-  default ContainerAdapter<T> optional() {
-    return new OptionalValidationAdapter<>(this);
+  default ValidationAdapter<Optional<T>> optional() {
+    return new OptionalAdapter<>(this);
+  }
+
+  /**
+   * Create an adapter for validating a primitive optional value. (OptionalInt, OptionalDouble, etc.)
+   *
+   * @return The adapter for optional value validation
+   */
+  default ValidationAdapter<T> primitiveOptional() {
+    return new PrimitiveOptional<>(this);
   }
 
   /**