feat(program-d): C# codegen PATCHes + validates value-object jsonb columns

Value-object jsonb columns (field.object @storage:jsonb, single AND @isarray)
are EF owned-nav properties invisible to the PATCH merge loop's FindProperty and
to the create handler's top-level TryValidateObject. Now:
- EntityGenerator splits validation attrs from EF-mapping attrs so VO POCOs carry
  [Required(AllowEmptyStrings=true)]/[MaxLength]/... + [JsonPropertyName] (pins the
  stored jsonb keys to the camelCase metadata field names).
- RoutesGenerator emits typed per-field VO merge arms (deserialize -> recursive
  validate -> assign the CLR owned-nav; EF .ToJson persists via full-document
  replacement) + per-VO POST validation; present-null clears a nullable column but
  400s a @required one, driven by @required METADATA not EF nullability; a
  post-save raw UPDATE NULLs a nullable array column (EF OwnsMany.ToJson writes []
  for a null nav, never SQL NULL).
- New ValueObjectValidator (Codegen.Runtime, the established generated-code helper
  namespace): TryValidateObject per element + manual recursion into nested VO
  members (spec section 0 — TryValidateObject is non-recursive).

Both lanes green (reference + generated full-stack over Testcontainers PG, all 20
VO scenarios); Codegen.Tests 278/0; persistence roundtrip 24/24 (Label/Settings
VO POCOs unaffected); other api-contract lanes 40/40 — no regression.

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

Author: dmealing

server/csharp/MetaObjects.Codegen.Tests/ValueObjectValidationCodegenTests.cs

@@ -0,0 +1,106 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using MetaObjects.Codegen;
+using MetaObjects.Codegen.Generators;
+using MetaObjects.Loader;
+using MetaObjects.Meta;
+using Xunit;
+
+namespace MetaObjects.Codegen.Tests;
+
+// Program D — value-object jsonb columns (field.object @storage:jsonb, single AND @isArray)
+// must be POST-able + PATCH-able with FULL nested validation. Mirrors the gate fixture
+// (fixtures/api-contract-conformance/jsonb): a reused Marker VO (label @required @maxLength 40)
+// on a required single column, a nullable single column, and a nullable array column.
+public class ValueObjectValidationCodegenTests
+{
+    private const string Model = """
+    { "metadata.root": { "package": "acme::store", "children": [
+      { "object.value": { "name": "Marker", "children": [
+        { "field.string": { "name": "label", "@required": true, "@maxLength": 40 } },
+        { "field.int":    { "name": "score" } }
+      ]}},
+      { "object.entity": { "name": "Document", "children": [
+        { "source.rdb":   { "@table": "documents" } },
+        { "field.long":   { "name": "id" } },
+        { "field.string": { "name": "title", "@required": true, "@maxLength": 200 } },
+        { "field.object": { "name": "primaryMarker",  "@objectRef": "Marker", "@storage": "jsonb", "@required": true } },
+        { "field.object": { "name": "optionalMarker", "@objectRef": "Marker", "@storage": "jsonb" } },
+        { "field.object": { "name": "markers",        "@objectRef": "Marker", "@storage": "jsonb", "isArray": true } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}}
+    ]}}
+    """;
+
+    private static MetaRoot Load()
+    {
+        var r = new MetaDataLoader().Load([new InMemoryStringSource(Model, id: "vo.json")]);
+        Assert.Empty(r.Errors);
+        return r.Root;
+    }
+
+    private static GenContext Ctx(MetaRoot root) => new()
+    {
+        Entities = root.Objects(), Root = root,
+        Config = new GenConfig { OutDir = "/tmp", Namespace = "Acme.Store.Generated" },
+    };
+
+    [Fact]
+    public void Marker_poco_carries_validation_and_json_property_name_attributes()
+    {
+        var files = new EntityGenerator().Generate(Ctx(Load())).ToList();
+        var marker = files.Single(f => f.Path == "Marker.g.cs").Content;
+
+        // The VO's own members carry validation DataAnnotations so a nested VO validates in
+        // FULL on POST/PATCH: label is required (non-empty) AND <= 40 chars.
+        Assert.Contains("[Required(AllowEmptyStrings = true)]", marker);
+        Assert.Contains("[MaxLength(40)]", marker);
+        // [JsonPropertyName] pins the owned-JSON element name (+ wire name) to the metadata
+        // field name so EF Core 8 storage matches the shared seed + cross-port wire contract.
+        Assert.Contains("[JsonPropertyName(\"label\")]", marker);
+        Assert.Contains("[JsonPropertyName(\"score\")]", marker);
+        // A VO POCO still carries NO EF-mapping attributes (JSON mapping is fluent, .ToJson).
+        Assert.DoesNotContain("[Column(", marker);
+        Assert.DoesNotContain("[Key]", marker);
+    }
+
+    [Fact]
+    public void Routes_emit_typed_vo_merge_arms_and_post_validation()
+    {
+        var files = new RoutesGenerator().Generate(Ctx(Load())).ToList();
+        var routes = files.Single(f => f.Path == "DocumentRoutes.g.cs").Content;
+
+        // PATCH merge — a typed arm per VO column (keyed on the wire field name), assigning
+        // the CLR owned-nav property (EF .ToJson persists via full-document replacement).
+        Assert.Contains("\"primaryMarker\"", routes);
+        Assert.Contains("\"optionalMarker\"", routes);
+        Assert.Contains("\"markers\"", routes);
+        Assert.Contains("existing.OptionalMarker = null;", routes);        // nullable single: present-null clears
+        Assert.Contains("existing.Markers = null;", routes);              // nullable array: present-null clears
+        Assert.Contains("Deserialize<Marker>", routes);                  // single VO
+        Assert.Contains("Deserialize<System.Collections.Generic.List<Marker>>", routes); // array VO
+        // Recursive VO validation on BOTH PATCH and POST.
+        Assert.Contains("ValueObjectValidator.Validate", routes);
+        Assert.Contains("ValueObjectValidator.Validate(input.PrimaryMarker)", routes);
+    }
+
+    [Fact]
+    public void Generated_entity_and_value_object_compile_together()
+    {
+        // The VO POCO now carries validation DataAnnotations + [JsonPropertyName]; verify the
+        // added usings compile (the full generated server incl. routes is compiled by the
+        // integration generated lane). Entity + VO only — no ASP.NET reference needed.
+        var files = new EntityGenerator().Generate(Ctx(Load())).ToList();
+        var trees = files.Select(f =>
+            CSharpSyntaxTree.ParseText(f.Content, new CSharpParseOptions(LanguageVersion.CSharp12))).ToList();
+        var refs = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!)
+            .Split(Path.PathSeparator).Where(p => p.Length > 0)
+            .Select(p => (MetadataReference)MetadataReference.CreateFromFile(p)).ToList();
+        var comp = CSharpCompilation.Create("vocompile_" + Guid.NewGuid().ToString("N"),
+            trees, refs, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        var errors = comp.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error)
+            .Select(d => $"{d.Id}: {d.GetMessage()}").ToList();
+        Assert.True(errors.Count == 0, "generated VO entity should compile, got: " + string.Join("; ", errors));
+    }
+}

server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs

@@ -566,9 +566,16 @@ protected virtual EmittedFile EmitValueObjectPoco(MetaObject vo, GenContext ctx)
         sb.AppendLine("#nullable enable");
         sb.AppendLine("using System;");
         sb.AppendLine("using System.Collections.Generic;");
+        // A VO's own members carry validation DataAnnotations ([Required]/[MaxLength]/etc.)
+        // so a nested value-object is validated in FULL on POST/PATCH (Program D).
+        sb.AppendLine("using System.ComponentModel.DataAnnotations;");
         // A value-object field with an explicit @column emits [Column(...)] — same as the entity
         // paths, so it needs the Schema namespace too (was omitted here → CS0246 on Column).
         sb.AppendLine("using System.ComponentModel.DataAnnotations.Schema;");
+        // [JsonPropertyName] pins each VO member's jsonb element name (+ wire name) to the
+        // metadata field name (camelCase). EF Core 8 owned-JSON (.ToJson) honors it, so the
+        // stored jsonb keys match the shared seed + the wire contract cross-port (Program D).
+        sb.AppendLine("using System.Text.Json.Serialization;");
         // A @dbColumnType:jsonb field surfaces as a System.Text.Json.JsonDocument (issue #98).
         if (CSharpNaming.RequiresSystemTextJson(vo))
             sb.AppendLine("using System.Text.Json;");
@@ -593,14 +600,19 @@ protected virtual EmittedFile EmitValueObjectPoco(MetaObject vo, GenContext ctx)
         {
             string? member = null;
             if (CSharpNaming.ScalarFor(field.SubType) is not null)
-                member = ScalarProperty(vo, field, [], withAttributes: false);
+                // VO POCO members carry NO EF-mapping attrs but DO carry validation
+                // DataAnnotations (the VO is validated in full on POST/PATCH; Program D).
+                member = ScalarProperty(vo, field, [], withAttributes: false, withValidationAttributes: true);
             else if (field.SubType == FIELD_SUBTYPE_ENUM)
                 member = EnumProperty(vo, field, ctx.Config, ctx.Config.ColumnNamingStrategy);
             else if (field.SubType == FIELD_SUBTYPE_OBJECT && ObjectNavProperty(vo, field, ctx) is { } nav)
                 member = nav;
             else if (field.SubType == FIELD_SUBTYPE_MAP)
                 member = MapProperty(vo, field, ctx, withAttributes: false);
             if (member is null) continue;
+            // Pin the jsonb element name (+ wire name) to the metadata field name so the
+            // stored owned-JSON keys match the shared seed + the cross-port wire contract.
+            member = $"    [JsonPropertyName(\"{field.Name}\")]\n" + member;
             member = ApplyPropertyAttributes(member, vo, field, ctx);
             members.Add(XmlDocBuilder.Prepend(member, field, "    "));
         }
@@ -756,18 +768,25 @@ protected virtual string EnumProperty(
         return $"{colAttr}    public {type} {propName} {{ get; set; }}";
     }
 
-    // A scalar property. withAttributes adds the EF mapping annotations ([Key] for a
-    // single-column PK, [Column], [MaxLength], [Required]); value-object POCOs omit
-    // them (column mapping is fluent/JSON, not annotation-driven).
+    // A scalar property. withAttributes adds the EF-mapping annotations ([Key] for a
+    // single-column PK, [Column]); value-object POCOs omit them (column mapping is
+    // fluent/JSON, not annotation-driven). withValidationAttributes controls the
+    // DataAnnotations validation attrs ([Required]/[StringLength]/[MinLength]/
+    // [MaxLength]/[Range]/[RegularExpression]) INDEPENDENTLY — a VO POCO carries these
+    // (its members are validated on POST/PATCH — Program D) even though it carries NO
+    // EF-mapping attrs; an attribute-free abstract shape carries neither. When null,
+    // validation attrs follow withAttributes (mapped entities emit both, byte-identical
+    // to before).
     //
     // When the field is an array (isArray: true), emit List<T> with an empty-list
     // initializer instead of a scalar T property. Arrays are always non-nullable
     // (the jsonb column holds the list; the list itself is never null in C#).
     protected virtual string ScalarProperty(
         MetaObject owner, MetaField field, IReadOnlyList<string> pkFields,
         bool withAttributes, ColumnNamingStrategy strategy = ColumnNamingStrategy.Literal,
-        string? baseTypeOverride = null)
+        string? baseTypeOverride = null, bool? withValidationAttributes = null)
     {
+        var emitValidation = withValidationAttributes ?? withAttributes;
         // A @dbColumnType:jsonb open-bag shifts the CLR property to a parsed JSON value
         // (JsonDocument) — issue #98 — taking precedence over the logical scalar. A uuid
         // override keeps the logical CLR type (converted at the DB seam). ScalarForField
@@ -784,11 +803,10 @@ protected virtual string ScalarProperty(
         {
             var arr = new StringBuilder();
             if (withAttributes)
-            {
                 arr.AppendLine($"    [Column(\"{CSharpNaming.Column(field, strategy)}\")]");
-                // validator.array @min/@max → element-count bounds on the collection.
+            // validator.array @min/@max → element-count bounds on the collection.
+            if (emitValidation)
                 AppendArrayValidatorAttributes(arr, field);
-            }
             arr.Append($"    public ICollection<{baseType}> {propName} {{ get; set; }} = new List<{baseType}>();");
             return arr.ToString();
         }
@@ -797,11 +815,19 @@ protected virtual string ScalarProperty(
         var isValue = CSharpNaming.IsValueType(baseType);
 
         var sb = new StringBuilder();
+        // EF-mapping attributes ([Key]/[Column]) — mapped entities only; a VO POCO's
+        // JSON member mapping is fluent (.ToJson), so it carries none of these.
         if (withAttributes)
         {
             if (pkFields.Count == 1 && pkFields[0] == field.Name)
                 sb.AppendLine("    [Key]");
             sb.AppendLine($"    [Column(\"{CSharpNaming.Column(field, strategy)}\")]");
+        }
+        // Validation DataAnnotations — mapped entities AND value-object POCOs (a VO's
+        // own members are validated on POST/PATCH; Program D), never an attribute-free
+        // abstract shape.
+        if (emitValidation)
+        {
             if (baseType == "string")
             {
                 // FR-036 A1 — a @required string is NON-EMPTY, but whitespace-only is ACCEPTED