Fix Recursive Validation (#256)

* fix recursive validation

* Delete validator-generator/io.avaje.validation.spi.ValidationExtension

* Update Recursive.java

* Format, remove unneeded public modifier

---------

Co-authored-by: Rob Bygrave <[email protected]>

Author: SentryMan

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

@@ -0,0 +1,7 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.constraints.NotNull;
+import io.avaje.validation.constraints.Valid;
+
+@Valid
+public record Recursive(@NotNull String name, @Valid @NotNull Recursive child) {}

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

@@ -0,0 +1,20 @@
+package example.avaje.cascade;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+import io.avaje.validation.Validator;
+
+class RecursiveTest {
+
+  Validator validator = Validator.builder().build();
+
+  @Test
+  void valid() {
+    var recurse =
+        new Recursive("recursive1", new Recursive("recursive2", new Recursive("recursive3", null)));
+    assertThat(validator.check(recurse).iterator().next())
+        .matches(c -> "child.child.child".equals(c.path()));
+  }
+}

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

@@ -15,9 +15,10 @@ final class AdapterHelper {
   private final boolean classLevel;
   private final boolean crossParam;
   private boolean usePrimitiveValidation;
+  private String recursiveType;
 
   AdapterHelper(Append writer, ElementAnnotationContainer elementAnnotations, String indent) {
-    this(writer, elementAnnotations, indent,"Object", null, false, false);
+    this(writer, elementAnnotations, indent, "Object", null, false, false);
   }
 
   AdapterHelper(
@@ -72,25 +73,39 @@ void write() {
 
     } else if (isTopTypeIterable()) {
       writer.eol().append("%s    .list()", indent);
+      // cascade validate
       if (hasValid) {
-        // cascade validate
-        writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class))", indent, mainType.param0().shortType());
+        if (mainType.param0().fullWithoutAnnotations().equals(recursiveType)) {
+          // cascade validate
+          writer.eol().append("%s    .andThenMulti(this)", indent, mainType.param0().shortType());
+        } else {
+          // cascade validate
+          writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class))", indent, mainType.param0().shortType());
+        }
       }
 
     } else if (isMapType(typeUse1, typeUse2)) {
       writer.eol().append("%s    .mapKeys()", indent);
       writeTypeUse(genericType.param0(), typeUse1);
-
       writer.eol().append("%s    .mapValues()", indent);
       writeTypeUse(genericType.param1(), typeUse2, false);
 
     } else if (hasValid && genericType.mainType().contains("[]")) {
       writer.eol().append("%s    .array()", indent);
-      writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class))", indent, mainType.shortWithoutAnnotations().replace("[]",""));
+      if (genericType.mainType().replace("[]", "").equals(recursiveType)) {
+        writer.eol().append("%s    .andThenMulti(this)", indent);
+      } else {
+        writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class))",
+          indent, mainType.shortWithoutAnnotations().replace("[]", ""));
+      }
 
     } else if (hasValid) {
       if (!classLevel) {
-        writer.eol().append("%s    .andThen(ctx.adapter(%s.class))", indent, genericType.shortWithoutAnnotations());
+        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());
+        }
       }
 
     } else if (genericType.mainType().contains("java.util.Optional")) {
@@ -147,4 +162,8 @@ private void writeTypeUse(UType uType, Map<UType, String> typeUseMap, boolean ke
           .append("%s    .andThenMulti(ctx.adapter(%s.class))", indent, typeUse.shortWithoutAnnotations());
     }
   }
+
+  void withEnclosingType(UType recursive) {
+    this.recursiveType = recursive.fullWithoutAnnotations();
+  }
 }

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

@@ -1,9 +1,10 @@
 package io.avaje.validation.generator;
 
-import static io.avaje.validation.generator.PrimitiveUtil.isPrimitiveValidationType;
 import static io.avaje.validation.generator.APContext.logError;
+import static io.avaje.validation.generator.PrimitiveUtil.isPrimitiveValidationType;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 
 import javax.lang.model.element.Element;
@@ -174,15 +175,22 @@ public String toString() {
   void writeConstructor(Append writer) {
     writer.append("    this.%s = ", adapterFieldName).eol();
 
-    new AdapterHelper(
-            writer,
-            elementAnnotations,
-            "        ",
-            PrimitiveUtil.wrap(genericType.shortWithoutAnnotations()),
-            genericType,
-            classLevel)
-        .usePrimitiveValidation(usePrimitiveValidation)
-        .write();
+    var helper =
+      new AdapterHelper(
+        writer,
+        elementAnnotations,
+        "        ",
+        PrimitiveUtil.wrap(genericType.shortWithoutAnnotations()),
+        genericType,
+        classLevel)
+        .usePrimitiveValidation(usePrimitiveValidation);
+
+    Optional.of(element.getEnclosingElement())
+      .filter(TypeElement.class::isInstance)
+      .map(e -> UType.parse(e.asType()))
+      .ifPresent(helper::withEnclosingType);
+
+    helper.write();
     writer.append(";").eol().eol();
   }
 

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

@@ -0,0 +1,13 @@
+package io.avaje.validation.generator.models.valid;
+
+import java.util.List;
+
+import io.avaje.validation.constraints.NotNull;
+import io.avaje.validation.constraints.Valid;
+
+@Valid
+public record Recursive(
+    @NotNull String name,
+    @Valid @NotNull Recursive child,
+    @Valid Recursive[] array,
+    @Valid List<Recursive> list) {}