Merge origin/main into sp-g-registry-conformance (#38 + opsForSubType build fix) — clean

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

fixtures/generator-registry-conformance/registry.json

@@ -53,9 +53,9 @@
       "ports": ["typescript"]
     },
     "callable": {
-      "concept": "Per-entity callable/service surface wrapping the query helpers.",
+      "concept": "Per-entity callable wrapper for a callable source (storedProc / tableFunction); in TS it also covers the service surface wrapping the query helpers.",
       "tier": "native",
-      "ports": ["typescript"]
+      "ports": ["typescript", "csharp"]
     },
     "routes-hono": {
       "concept": "Per-entity Hono CRUD routes.",

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

@@ -0,0 +1,135 @@
+// Fr013CodegenTests — FR-013 per-field @readOnly C# codegen emission.
+//
+// A @readOnly:true field is read-after-insert-only: EF may set it on read, but the
+// column is omitted from INSERT / UPDATE. The C# emission (per the FR-013 spec) is:
+//   1. EntityGenerator: the scalar property emits `{ get; private set; }` (settable
+//      by EF on materialization, not by application code) instead of `{ get; set; }`.
+//   2. DbContextGenerator: a fluent
+//      `modelBuilder.Entity<Owner>().Property(x => x.Field).Metadata
+//          .SetAfterSaveBehavior(PropertySaveBehavior.Ignore);`
+//      so the column is skipped on writes.
+//   3. A normal (writable) field is unchanged: `{ get; set; }`, no SetAfterSaveBehavior.
+//
+// Mirrors the TS reference intent (codegen-ts zod-validators.ts excludes
+// FIELD_ATTR_READ_ONLY fields from the Insert/Update schemas). This test gates the
+// C# EMISSION shape; the entity POCO + AppDbContext compile together via Roslyn.
+
+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;
+
+public class Fr013CodegenTests
+{
+    // A writable table with one read-only audit column (createdAt, DB-trigger
+    // populated) and one ordinary writable column (name).
+    private const string Model = """
+    { "metadata.root": { "package": "acme::audit", "children": [
+      { "object.entity": { "name": "Doc", "children": [
+        { "source.rdb":       { "@table": "docs" } },
+        { "field.long":       { "name": "id" } },
+        { "field.string":     { "name": "name", "@required": true, "@maxLength": 80 } },
+        { "field.timestamp":  { "name": "createdAt", "@readOnly": true } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}}
+    ]}}
+    """;
+
+    private static GenContext Ctx(MetaRoot root) => new()
+    {
+        Entities = root.Objects(),
+        Root = root,
+        Config = new GenConfig { OutDir = "/tmp", Namespace = "Acme.Generated", ColumnNamingStrategy = ColumnNamingStrategy.Literal },
+    };
+
+    private static MetaRoot Load()
+    {
+        var r = new MetaDataLoader().Load([new InMemoryStringSource(Model, id: "fr013.json")]);
+        Assert.Empty(r.Errors);
+        return r.Root;
+    }
+
+    private static string FileContent(IEnumerable<EmittedFile> files, string path) =>
+        files.Single(f => f.Path == path).Content;
+
+    [Fact]
+    public void MetaField_ReadOnly_reflects_attr()
+    {
+        var root = Load();
+        var doc = root.FindObject("Doc")!;
+        Assert.True(doc.FindField("createdAt")!.ReadOnly);
+        Assert.False(doc.FindField("name")!.ReadOnly);
+    }
+
+    [Fact]
+    public void Entity_readOnly_scalar_emits_private_set()
+    {
+        var root = Load();
+        var doc = FileContent(new EntityGenerator().Generate(Ctx(root)), "Doc.g.cs");
+
+        // The read-only field gets a private setter.
+        Assert.Contains("public DateTime? CreatedAt { get; private set; }", doc);
+        // A normal field keeps its public setter.
+        Assert.Contains("public string Name { get; set; }", doc);
+        // And the read-only field is NOT emitted with a public set.
+        Assert.DoesNotContain("public DateTime? CreatedAt { get; set; }", doc);
+    }
+
+    [Fact]
+    public void DbContext_readOnly_field_ignored_after_save()
+    {
+        var root = Load();
+        var db = FileContent(new DbContextGenerator().Generate(Ctx(root)), "AppDbContext.g.cs");
+
+        Assert.Contains(
+            "modelBuilder.Entity<Doc>().Property(x => x.CreatedAt).Metadata.SetAfterSaveBehavior(PropertySaveBehavior.Ignore);",
+            db);
+        // The using needed for PropertySaveBehavior.
+        Assert.Contains("using Microsoft.EntityFrameworkCore.Metadata;", db);
+        // The writable field is not ignored.
+        Assert.DoesNotContain("x => x.Name).Metadata.SetAfterSaveBehavior", db);
+    }
+
+    [Fact]
+    public void Entity_and_dbcontext_compile_together()
+    {
+        var root = Load();
+        var files = new EntityGenerator().Generate(Ctx(root))
+            .Concat(new DbContextGenerator().Generate(Ctx(root)))
+            .ToList();
+
+        var trees = files
+            .Where(f => f.Path.EndsWith(".g.cs"))
+            .Select(f => CSharpSyntaxTree.ParseText(f.Content))
+            .ToList();
+
+        var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var tpa = (string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!;
+        foreach (var p in tpa.Split(Path.PathSeparator))
+            if (p.Length > 0) paths.Add(p);
+        paths.Add(typeof(Microsoft.EntityFrameworkCore.DbContext).Assembly.Location);
+        paths.Add(typeof(Microsoft.EntityFrameworkCore.ModelBuilder).Assembly.Location);
+        paths.Add(typeof(Microsoft.EntityFrameworkCore.RelationalDatabaseFacadeExtensions).Assembly.Location);
+        var refs = paths
+            .Where(File.Exists)
+            .Select(p => (MetadataReference)MetadataReference.CreateFromFile(p))
+            .ToList();
+
+        var compilation = CSharpCompilation.Create(
+            "Fr013Compile",
+            trees,
+            refs,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        var errors = compilation.GetDiagnostics()
+            .Where(d => d.Severity == DiagnosticSeverity.Error)
+            .Select(d => d.ToString())
+            .ToList();
+        Assert.True(errors.Count == 0, "compile errors:\n" + string.Join("\n", errors));
+    }
+}

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

@@ -0,0 +1,150 @@
+// Fr015CodegenTests — FR-015 @parameterRef callable-wrapper C# codegen emission.
+//
+// A source.rdb @kind:"storedProc" | "tableFunction" entity gets a generated calling
+// method (one <Entity>.callable.cs per callable entity). Per the FR-015 spec, the C#
+// emission uses EF Core FromSqlInterpolated:
+//
+//   public static Task<IReadOnlyList<PhaseSummary>> Call(AppDbContext db, PhaseSummaryArgs args)
+//       => db.Set<PhaseSummary>()
+//             .FromSqlInterpolated($"SELECT * FROM analytics.fn_phase_summary({args.CaseId}, {args.AsOfDate})")
+//             .ToListAsync()...;
+//
+// Args bind in the @parameterRef value-object's field DECLARATION order. A callable
+// with no @parameterRef emits a zero-arg overload calling fn_x().
+//
+// Mirrors the TS reference (codegen-ts templates/callable-file.ts), which emits one
+// call<Entity>(db, args) per callable with the same SQL arg-order contract.
+
+using MetaObjects.Codegen;
+using MetaObjects.Codegen.Generators;
+using MetaObjects.Loader;
+using MetaObjects.Meta;
+using Xunit;
+
+namespace MetaObjects.Codegen.Tests;
+
+public class Fr015CodegenTests
+{
+    // One value-object (the proc args, two fields in declaration order), a storedProc
+    // entity referencing it via @parameterRef, a tableFunction entity, and a zero-arg
+    // storedProc entity (no @parameterRef).
+    private const string Model = """
+    { "metadata.root": { "package": "acme::analytics", "children": [
+      { "object.value": { "name": "PhaseSummaryArgs", "children": [
+        { "field.int":       { "name": "caseId", "@required": true } },
+        { "field.timestamp": { "name": "asOfDate" } }
+      ]}},
+      { "object.entity": { "name": "PhaseSummary", "children": [
+        { "source.rdb":  { "@kind": "storedProc", "@proc": "fn_phase_summary", "@schema": "analytics", "@parameterRef": "PhaseSummaryArgs" } },
+        { "field.long":   { "name": "phaseId" } },
+        { "field.string": { "name": "phaseName" } }
+      ]}},
+      { "object.entity": { "name": "ActivePhases", "children": [
+        { "source.rdb":  { "@kind": "tableFunction", "@function": "fn_active_phases", "@parameterRef": "PhaseSummaryArgs" } },
+        { "field.long":   { "name": "phaseId" } }
+      ]}},
+      { "object.entity": { "name": "AllPhases", "children": [
+        { "source.rdb":  { "@kind": "storedProc", "@proc": "fn_all_phases" } },
+        { "field.long":   { "name": "phaseId" } }
+      ]}},
+      { "object.entity": { "name": "Plain", "children": [
+        { "source.rdb":  { "@table": "plains" } },
+        { "field.long":   { "name": "id" } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}}
+    ]}}
+    """;
+
+    private static GenContext Ctx(MetaRoot root) => new()
+    {
+        Entities = root.Objects(),
+        Root = root,
+        Config = new GenConfig { OutDir = "/tmp", Namespace = "Acme.Generated", ColumnNamingStrategy = ColumnNamingStrategy.Literal },
+    };
+
+    private static MetaRoot Load()
+    {
+        var r = new MetaDataLoader().Load([new InMemoryStringSource(Model, id: "fr015.json")]);
+        Assert.Empty(r.Errors);
+        return r.Root;
+    }
+
+    private static IReadOnlyList<EmittedFile> Files()
+        => new CallableGenerator().Generate(Ctx(Load())).ToList();
+
+    private static string Content(IEnumerable<EmittedFile> files, string path) =>
+        files.Single(f => f.Path == path).Content;
+
+    [Fact]
+    public void Source_ParameterRef_and_IsCallable_reflect_attrs()
+    {
+        var root = Load();
+        var ps = root.FindObject("PhaseSummary")!.Sources()[0];
+        Assert.True(ps.IsCallable());
+        Assert.Equal("PhaseSummaryArgs", ps.ParameterRef);
+
+        var plain = root.FindObject("Plain")!.Sources()[0];
+        Assert.False(plain.IsCallable());
+        Assert.Null(plain.ParameterRef);
+    }
+
+    [Fact]
+    public void Only_callable_entities_emit_a_callable_file()
+    {
+        var files = Files();
+        var paths = files.Select(f => f.Path).OrderBy(p => p, StringComparer.Ordinal).ToList();
+        Assert.Equal(
+            ["ActivePhases.callable.g.cs", "AllPhases.callable.g.cs", "PhaseSummary.callable.g.cs"],
+            paths);
+    }
+
+    [Fact]
+    public void StoredProc_with_parameterRef_emits_FromSqlInterpolated_in_declaration_order()
+    {
+        var c = Content(Files(), "PhaseSummary.callable.g.cs");
+
+        // Method signature: db + the args value-object.
+        Assert.Contains("AppDbContext db, PhaseSummaryArgs args", c);
+        // Returns the projection rows.
+        Assert.Contains("Task<IReadOnlyList<PhaseSummary>>", c);
+        // FromSqlInterpolated with schema-qualified proc name + args in declaration
+        // order (caseId, asOfDate → CaseId, AsOfDate).
+        Assert.Contains(
+            "FromSqlInterpolated($\"SELECT * FROM analytics.fn_phase_summary({args.CaseId}, {args.AsOfDate})\")",
+            c);
+        Assert.Contains("db.Set<PhaseSummary>()", c);
+        Assert.Contains("ToListAsync", c);
+    }
+
+    [Fact]
+    public void TableFunction_with_parameterRef_emits_unqualified_proc_name()
+    {
+        var c = Content(Files(), "ActivePhases.callable.g.cs");
+        // No @schema → bare function name.
+        Assert.Contains(
+            "FromSqlInterpolated($\"SELECT * FROM fn_active_phases({args.CaseId}, {args.AsOfDate})\")",
+            c);
+        Assert.Contains("AppDbContext db, PhaseSummaryArgs args", c);
+    }
+
+    [Fact]
+    public void ZeroArg_callable_emits_no_args_method()
+    {
+        var c = Content(Files(), "AllPhases.callable.g.cs");
+        // No args parameter.
+        Assert.Contains("AppDbContext db)", c);
+        Assert.DoesNotContain("args", c);
+        // Empty parameter list in the SQL.
+        Assert.Contains("FromSqlInterpolated($\"SELECT * FROM fn_all_phases()\")", c);
+        Assert.Contains("Task<IReadOnlyList<AllPhases>>", c);
+    }
+
+    [Fact]
+    public void Registry_exposes_callable_for_csharp()
+    {
+        Assert.True(GeneratorRegistry.Entries.ContainsKey("callable"));
+        var built = GeneratorRegistry.Resolve(["callable"]);
+        Assert.Single(built);
+        Assert.IsType<CallableGenerator>(built[0]);
+    }
+}

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

@@ -18,12 +18,14 @@ public sealed class GeneratorRegistryTests
     [
         "entity", "db-context", "routes", "output-parser", "extractor",
         "output-prompt", "render-helper", "filter-allowlist", "template",
+        // FR-015 — per-entity callable wrapper (storedProc / tableFunction).
+        "callable",
     ];
 
     [Fact]
-    public void Registry_contains_all_nine_generators_with_stable_names()
+    public void Registry_contains_all_expected_generators_with_stable_names()
     {
-        Assert.Equal(9, GeneratorRegistry.Entries.Count);
+        Assert.Equal(ExpectedNames.Length, GeneratorRegistry.Entries.Count);
         foreach (var name in ExpectedNames)
             Assert.True(GeneratorRegistry.Entries.ContainsKey(name), $"missing stable name: {name}");
     }
@@ -55,7 +57,7 @@ public void Every_factory_constructs_without_throwing_for_list()
     public void List_returns_all_entries_native_first_alphabetical_within_tier()
     {
         var list = GeneratorRegistry.List();
-        Assert.Equal(9, list.Count);
+        Assert.Equal(GeneratorRegistry.Entries.Count, list.Count);
         var native = list.Where(e => e.Tier == GeneratorTier.Native).Select(e => e.Name).ToList();
         Assert.Equal(native.OrderBy(n => n, StringComparer.Ordinal).ToList(), native);
     }

server/csharp/MetaObjects.Codegen/GeneratorRegistry.cs

@@ -155,6 +155,16 @@ private static IGenerator RenderHelper(GeneratorBuildContext ctx) =>
                 Factory = TemplatePrimitive,
                 Options = "name, walk, template, format? (config-only)",
             },
+            // FR-015 — per-entity typed EF Core calling method for a callable source
+            // (storedProc / tableFunction). Same stable name as the TS callable
+            // generator (cross-port contract).
+            ["callable"] = new()
+            {
+                Name = "callable",
+                Description = "Per-entity callable wrapper (storedProc / tableFunction FromSqlInterpolated method).",
+                Tier = GeneratorTier.Native,
+                Factory = _ => new CallableGenerator(),
+            },
         };
 
     /// <summary>All entries, native first then neutral, alphabetical within tier.</summary>