feat(program-d): Java codegen-spring generates + PATCHes value-object jsonb columns

codegen-spring emitted nothing for object.value. New SpringValueObjectGenerator
emits one Java record per object.value reachable (transitively) from an
entity/projection field.object @storage:jsonb column, with jakarta constraints
per member + @Valid on nested VO members (depth>=2 cascade). SpringTypeMapper
gains an ObjectField arm (no longer throws); <Entity>Dto/<Entity>Patch carry the
typed VO field (@Valid, @NotNull when @required); controller PATCH keeps
validateValue for own constraints and ADDS explicit validator.validate(voElement)
per present element (spec section 0 — validateValue does NOT cascade @Valid);
POST validates via the existing validate(dto) @Valid cascade. Reference server +
generated harness taught the VO columns + PATCH tristate.

Both lanes green (2/2 reference over Testcontainers PG, 2/2 generated over MockMvc);
codegen-spring suite 167/0; Author 25/25, TPH 8/8 — no regression. TPH-with-VO
and field.map remain staged-out follow-ups.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NGQ7oSuNcjhsMHWwZzhBwr

Author: dmealing

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringControllerGenerator.java

@@ -318,6 +318,12 @@ protected void emit(MetaObject entity, Path outRoot) {
         src.append("                return ResponseEntity.badRequest().body(Map.of(\"error\", \"validation\"));\n");
         src.append("            }\n");
         src.append("        }\n");
+        // Program D (spec section 0): validateValue does NOT cascade @Valid into a nested value
+        // object's own constraints, so validate each PRESENT VO element EXPLICITLY. The property's
+        // OWN constraints (@NotNull on a @required column, present-null tristate) are already
+        // covered above / in <Entity>Patch.fromJson; this closes the nested-constraint gap (e.g. a
+        // Marker.label over @maxLength, or null on a @required nested member) with a 400.
+        appendValueObjectValidation(src, entity);
         src.append("        return repository.patch(id, patch)\n");
         src.append("                .<ResponseEntity<?>>map(ResponseEntity::ok)\n");
         src.append("                .orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of(\"error\", \"not_found\")));\n");
@@ -370,6 +376,36 @@ protected void emit(MetaObject entity, Path outRoot) {
         }
     }
 
+    /**
+     * Program D — append per-value-object nested-validation guards into the vanilla PATCH handler,
+     * one per {@code field.object @storage:jsonb} column (spec section 0). A present single VO
+     * value is validated whole; a present array is validated element-by-element. Skips null
+     * (present-null clears / is caught upstream) so the tristate composes. Emits nothing for an
+     * entity with no value-object columns, keeping non-VO controllers byte-identical.
+     */
+    private static void appendValueObjectValidation(StringBuilder src, MetaObject entity) {
+        for (ObjectField vf : SpringDtoGenerator.valueObjectJsonbFields(entity)) {
+            String name = vf.getName();
+            String cap = SpringNaming.capitalize(name);
+            if (vf.isArrayType()) {
+                src.append("        if (patch.has").append(cap).append("() && patch.")
+                   .append(name).append("() != null) {\n");
+                src.append("            for (var __el : patch.").append(name).append("()) {\n");
+                src.append("                if (__el != null && !validator.validate(__el).isEmpty()) {\n");
+                src.append("                    return ResponseEntity.badRequest().body(Map.of(\"error\", \"validation\"));\n");
+                src.append("                }\n");
+                src.append("            }\n");
+                src.append("        }\n");
+            } else {
+                src.append("        if (patch.has").append(cap).append("() && patch.")
+                   .append(name).append("() != null && !validator.validate(patch.")
+                   .append(name).append("()).isEmpty()) {\n");
+                src.append("            return ResponseEntity.badRequest().body(Map.of(\"error\", \"validation\"));\n");
+                src.append("        }\n");
+            }
+        }
+    }
+
     /**
      * FR-017 TPH: emit the discriminator-base controller. ONE {@code @RestController} at
      * {@code /api/<base-plural>} mounting:

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringDtoGenerator.java

@@ -138,10 +138,17 @@ public static boolean appliesTo(MetaObject entity) {
     }
 
     protected void emit(MetaObject entity, Path outRoot) {
-        List<MetaField> fields = scalarFields(entity);
-        // Each scalar field carries its full validation (the standard, non-TPH DTO).
+        List<MetaField> fields = dtoComponentFields(entity);
+        // Each field carries its full validation (the standard, non-TPH DTO). A value-object
+        // jsonb column additionally gets @Valid so the POST path's validator.validate(dto)
+        // cascades into the nested VO's constraints (spec section 0 — @Valid cascades on
+        // validate(bean), unlike the PATCH path's per-field validateValue).
         List<String> annotationsPerField = new ArrayList<>(fields.size());
-        for (MetaField field : fields) annotationsPerField.add(validationAnnotations(field));
+        for (MetaField field : fields) {
+            String a = validationAnnotations(field);
+            if (isValueObjectJsonbField(field)) a = a.isEmpty() ? "@Valid" : "@Valid " + a;
+            annotationsPerField.add(a);
+        }
         emitRecord(entity, outRoot, fields, annotationsPerField);
     }
 
@@ -272,15 +279,19 @@ private void writePatch(MetaObject entity, Path outRoot, String patchName, Strin
         writeJavaFile(entity, outRoot, pkg, patchName, src.toString());
     }
 
-    /** Scalar (non-object) fields MINUS the primary-key field(s) — the caller-settable set. */
+    /**
+     * The vanilla {@code <Entity>Patch} settable set: DTO component fields (scalars PLUS
+     * value-object jsonb columns, Program D) MINUS the primary-key field(s).
+     */
     private static List<MetaField> settableFields(MetaObject entity) {
-        return settableFields(entity, null);
+        return minusPk(entity, dtoComponentFields(entity), null);
     }
 
     /**
-     * As {@link #settableFields(MetaObject)}, additionally excluding the field named
-     * {@code alsoExclude} (or nothing when {@code null}) — the FR-036 TPH per-subtype patch passes
-     * the discriminator field name so the immutable discriminator is never a settable member.
+     * The TPH per-subtype settable set: {@link #scalarFields(MetaObject)} MINUS the primary key
+     * MINUS the field named {@code alsoExclude} (the immutable discriminator, or nothing when
+     * {@code null}). Scalar-only — value-object columns on a TPH hierarchy are out of scope
+     * (Program D), so a TPH base's union DTO and per-subtype patch stay VO-free.
      *
      * <p>Public so {@link SpringControllerGenerator#emitTph} can validate a TPH per-subtype CREATE
      * body against exactly the field set the sibling {@code <Sub>Patch} covers (effective scalars
@@ -289,13 +300,18 @@ private static List<MetaField> settableFields(MetaObject entity) {
      * validated from the body.</p>
      */
     public static List<MetaField> settableFields(MetaObject entity, String alsoExclude) {
+        return minusPk(entity, scalarFields(entity), alsoExclude);
+    }
+
+    /** {@code pool} MINUS the entity's primary-key field(s) MINUS {@code alsoExclude} (when non-null). */
+    private static List<MetaField> minusPk(MetaObject entity, List<MetaField> pool, String alsoExclude) {
         List<String> pkFields = entity.getIdentities(true).stream()
             .filter(MetaIdentity::isPrimary)
             .findFirst()
             .map(MetaIdentity::getFields)
             .orElse(List.of());
         List<MetaField> out = new ArrayList<>();
-        for (MetaField field : scalarFields(entity)) {
+        for (MetaField field : pool) {
             if (pkFields.contains(field.getName())) continue;
             if (alsoExclude != null && alsoExclude.equals(field.getName())) continue;
             out.add(field);
@@ -345,15 +361,24 @@ private void emitRecord(MetaObject entity, Path outRoot, List<MetaField> fields,
         String recordName = SpringNaming.dtoName(shortName);
 
         boolean usesValidation = annotationsPerField.stream().anyMatch(a -> !a.isEmpty());
+        // @Valid (jakarta.validation, NOT ...constraints) cascades validation into a
+        // value-object jsonb component — emitted on VO fields by emit() (Program D).
+        boolean usesValid = annotationsPerField.stream().anyMatch(a -> a.contains("@Valid"));
 
         StringBuilder src = new StringBuilder();
         if (!pkg.isEmpty()) {
             src.append("package ").append(pkg).append(";\n\n");
         }
         // Wildcard import keeps the emit simple — record components carry a small,
         // closed set of jakarta.validation.constraints annotations.
+        if (usesValid) {
+            src.append("import jakarta.validation.Valid;\n");
+        }
         if (usesValidation) {
-            src.append("import jakarta.validation.constraints.*;\n\n");
+            src.append("import jakarta.validation.constraints.*;\n");
+        }
+        if (usesValid || usesValidation) {
+            src.append('\n');
         }
         src.append("/** GENERATED — wire DTO for ").append(shortName)
            .append(". Do not hand-edit; regenerated from metadata. */\n");
@@ -434,8 +459,10 @@ protected void writeJavaFile(MetaObject entity, Path outRoot, String pkg, String
 
     /**
      * Return the entity's scalar fields — i.e. every {@link MetaField} that is
-     * not an {@link ObjectField}. The {@code field.object} arm is deliberately
-     * deferred (see class javadoc).
+     * not an {@link ObjectField}. Value-object {@code field.object} columns are
+     * carried separately by {@link #dtoComponentFields(MetaObject)}; this
+     * scalar-only view still backs the TPH union / abstract-shape / sort surfaces
+     * (which are value-object-agnostic).
      */
     public static List<MetaField> scalarFields(MetaObject entity) {
         List<MetaField> out = new ArrayList<>();
@@ -446,6 +473,67 @@ public static List<MetaField> scalarFields(MetaObject entity) {
         return out;
     }
 
+    /** The single legal {@code @storage} value for a value-object jsonb column (Program D);
+     *  {@code flattened} / {@code subdocument} owned-object storage is out of scope. */
+    static final String STORAGE_JSONB = "jsonb";
+
+    /**
+     * The vanilla {@code <Entity>Dto} / {@code <Entity>Patch} component fields: every scalar
+     * field PLUS every value-object jsonb column ({@code field.object @objectRef=<value> @storage:jsonb},
+     * single or {@code @isArray}), in declared order. Program D: the VO columns become
+     * strongly-typed record components (bound to the generated {@code <VO>} record) so they
+     * POST + PATCH with nested validation. A non-VO {@link ObjectField} (flattened / subdocument
+     * storage, or an unresolved / non-value {@code @objectRef}) is still skipped.
+     */
+    public static List<MetaField> dtoComponentFields(MetaObject entity) {
+        List<MetaField> out = new ArrayList<>();
+        for (MetaField field : entity.getMetaFields()) {
+            if (field instanceof ObjectField) {
+                if (isValueObjectJsonbField(field)) out.add(field);
+                continue;
+            }
+            out.add(field);
+        }
+        return out;
+    }
+
+    /** The value-object jsonb columns of {@code entity}, in declared order (Program D) — the
+     *  fields the controller runs explicit nested-VO validation over on PATCH (spec section 0). */
+    public static List<ObjectField> valueObjectJsonbFields(MetaObject entity) {
+        List<ObjectField> out = new ArrayList<>();
+        for (MetaField field : entity.getMetaFields()) {
+            if (isValueObjectJsonbField(field)) out.add((ObjectField) field);
+        }
+        return out;
+    }
+
+    /**
+     * True iff {@code field} is a value-object jsonb column: a {@link ObjectField} whose
+     * {@code @objectRef} resolves to an {@code object.value} and whose {@code @storage} is
+     * jsonb (explicit, or the single-jsonb-column default when {@code @storage} is absent).
+     * Flattened / subdocument owned-object storage is out of scope (Program D).
+     */
+    public static boolean isValueObjectJsonbField(MetaField<?> field) {
+        if (!(field instanceof ObjectField of)) return false;
+        if (!of.hasMetaAttr(ObjectField.ATTR_OBJECTREF)) return false;
+        MetaObject ref;
+        try {
+            ref = of.getObjectRef();
+        } catch (RuntimeException unresolved) {
+            return false;
+        }
+        if (ref == null || !MetaObject.SUBTYPE_VALUE.equals(ref.getSubType())) return false;
+        if (!of.hasMetaAttr(ObjectField.ATTR_STORAGE)) return true; // default single-jsonb-column
+        Object storage = of.getMetaAttr(ObjectField.ATTR_STORAGE).getValue();
+        return STORAGE_JSONB.equalsIgnoreCase(String.valueOf(storage).trim());
+    }
+
+    /** The referenced {@code object.value} when {@code field} is a value-object jsonb column,
+     *  else {@code null}. Used by {@link SpringValueObjectGenerator}'s reachability walk. */
+    static MetaObject valueObjectRefOf(MetaField<?> field) {
+        return isValueObjectJsonbField(field) ? ((ObjectField) field).getObjectRef() : null;
+    }
+
     // === validation (SP-C validator parity) =================================
 
     /**

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringTypeMapper.java

@@ -10,6 +10,7 @@
 import com.metaobjects.field.IntegerField;
 import com.metaobjects.field.LongField;
 import com.metaobjects.field.MetaField;
+import com.metaobjects.field.ObjectField;
 import com.metaobjects.field.StringField;
 import com.metaobjects.field.TimeField;
 import com.metaobjects.field.TimestampField;
@@ -121,6 +122,19 @@ public static String javaTypeName(MetaField<?> field) {
         // inet — native java.net.InetAddress binding (ADR-0036/0037 Wave 3). Wire/storage
         // stays a String; the DB column is the Postgres-native inet type.
         if (field instanceof InetField) return "java.net.InetAddress";
+        // field.object @objectRef → the referenced value object's generated record type
+        // (Program D). A jsonb value-object column surfaces as the <VO> record (single) or
+        // — via componentType wrapping — List<<VO>> (isArray). Fully-qualified so the
+        // consuming DTO / <Entity>Patch / VO record needs no import. Only reached for the
+        // VO-ref fields the DTO/patch paths select via
+        // SpringDtoGenerator.isValueObjectJsonbField; a non-VO ObjectField never lands here.
+        if (field instanceof ObjectField of && of.hasMetaAttr(ObjectField.ATTR_OBJECTREF)) {
+            MetaObject ref = of.getObjectRef();
+            if (ref != null) {
+                String[] split = SpringNaming.splitFqn(ref.getName());
+                return split[0].isEmpty() ? split[1] : split[0] + "." + split[1];
+            }
+        }
         throw new IllegalArgumentException(
             "unsupported Spring DTO type mapping for "
                 + field.getClass().getSimpleName() + " '" + field.getName() + "'");