merge: C# codegen pillar foundation — EF Core entity + DbContext + meta gen [P2a]

dmealing · dmealing · commit c68c0db56ddc · 2026-05-23T13:44:35.000-04:00
diff --git a/server/csharp/MetaObjects.Cli.Tests/GenCommandTests.cs b/server/csharp/MetaObjects.Cli.Tests/GenCommandTests.cs
@@ -0,0 +1,42 @@
+using MetaObjects.Cli;
+using Xunit;
+
+namespace MetaObjects.Cli.Tests;
+
+/// <summary>End-to-end `meta gen`: a metadata dir -> generated EF Core files on disk.</summary>
+public sealed class GenCommandTests : IDisposable
+{
+    private readonly string _tmp = Path.Combine(Path.GetTempPath(), "meta-gen-" + Guid.NewGuid().ToString("N"));
+    private string MetaDir => Path.Combine(_tmp, "metaobjects");
+    private string OutDir => Path.Combine(_tmp, "generated");
+
+    private const string Metadata = """
+    { "metadata.root": { "package": "acme", "children": [
+      { "object.entity": { "name": "Subscriber", "children": [
+        { "source.dbTable": { "@name": "subscribers" } },
+        { "field.long":   { "name": "id" } },
+        { "field.string": { "name": "email", "@required": true } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}}
+    ]}}
+    """;
+
+    public GenCommandTests()
+    {
+        Directory.CreateDirectory(MetaDir);
+        File.WriteAllText(Path.Combine(MetaDir, "meta.acme.json"), Metadata);
+    }
+
+    public void Dispose() { try { Directory.Delete(_tmp, recursive: true); } catch { } }
+
+    [Fact]
+    public void Gen_writes_entity_and_dbcontext()
+    {
+        var outcome = GenCommand.Run(MetaDir, OutDir, "Acme.Generated");
+        Assert.True(outcome.Ok, string.Join("; ", outcome.LoadErrors));
+        Assert.True(File.Exists(Path.Combine(OutDir, "Subscriber.g.cs")));
+        Assert.True(File.Exists(Path.Combine(OutDir, "AppDbContext.g.cs")));
+        Assert.Contains("public class Subscriber", File.ReadAllText(Path.Combine(OutDir, "Subscriber.g.cs")));
+        Assert.Contains(outcome.Result!.Files, f => f.Status == "written");
+    }
+}
diff --git a/server/csharp/MetaObjects.Cli/GenCommand.cs b/server/csharp/MetaObjects.Cli/GenCommand.cs
@@ -0,0 +1,36 @@
+// `meta gen` — generate idiomatic C# (EF Core) code from metadata.
+//
+// Loads metadata from a directory and runs the codegen generator set, writing
+// files under the @generated-header guard. Generated today: EF Core entity
+// classes + a DbContext. Routes / projections / migrations layer on next.
+
+using MetaObjects.Codegen;
+using MetaObjects.Codegen.Generators;
+using MetaObjects.Loader;
+
+namespace MetaObjects.Cli;
+
+/// <summary>The gen command's pure logic (no console I/O), so it is testable.</summary>
+public static class GenCommand
+{
+    public sealed record Outcome(IReadOnlyList<string> LoadErrors, CodegenRunner.RunResult? Result)
+    {
+        public bool Ok => LoadErrors.Count == 0 && Result is not null;
+    }
+
+    /// <summary>The default generator set (data layer). Extended as more generators land.</summary>
+    public static IReadOnlyList<IGenerator> DefaultGenerators() =>
+        [new EntityGenerator(), new DbContextGenerator()];
+
+    public static Outcome Run(string metadataDir, string outDir, string ns)
+    {
+        var load = new FileMetaDataLoader().LoadDirectory(metadataDir);
+        var loadErrors = load.Errors.Select(e => e.Code.ToString()).ToList();
+        if (loadErrors.Count > 0)
+            return new Outcome(loadErrors, null);
+
+        var config = new GenConfig { OutDir = outDir, Namespace = ns };
+        var result = CodegenRunner.Run(config, load.Root, DefaultGenerators());
+        return new Outcome(loadErrors, result);
+    }
+}
diff --git a/server/csharp/MetaObjects.Cli/Program.cs b/server/csharp/MetaObjects.Cli/Program.cs
@@ -8,16 +8,48 @@
     Console.Error.WriteLine(
         "usage: meta <command> [options]\n" +
         "  commands:\n" +
-        "    verify <metadataDir> --templates <root>   drift-check templates against their payloads");
+        "    gen <metadataDir> --out <dir> --namespace <ns>   generate EF Core code from metadata\n" +
+        "    verify <metadataDir> --templates <root>          drift-check templates against their payloads");
     return 2;
 }
 
 return args[0] switch
 {
+    "gen" => RunGen(args[1..]),
     "verify" => RunVerify(args[1..]),
     _ => Unknown(args[0]),
 };
 
+static int RunGen(string[] rest)
+{
+    string? metadataDir = null;
+    string? outDir = null;
+    string ns = "Generated";
+    for (int i = 0; i < rest.Length; i++)
+    {
+        if (rest[i] == "--out" && i + 1 < rest.Length) outDir = rest[++i];
+        else if (rest[i] == "--namespace" && i + 1 < rest.Length) ns = rest[++i];
+        else if (!rest[i].StartsWith('-')) metadataDir ??= rest[i];
+    }
+    if (metadataDir is null || outDir is null)
+    {
+        Console.Error.WriteLine("usage: meta gen <metadataDir> --out <dir> [--namespace <ns>]");
+        return 2;
+    }
+
+    var outcome = GenCommand.Run(metadataDir, outDir, ns);
+    if (!outcome.Ok)
+    {
+        foreach (var e in outcome.LoadErrors) Console.Error.WriteLine($"  load error: {e}");
+        Console.Error.WriteLine("meta gen: FAILED (metadata did not load cleanly)");
+        return 1;
+    }
+    foreach (var f in outcome.Result!.Files) Console.WriteLine($"  {f.Status}: {f.Path}");
+    foreach (var w in outcome.Result!.Warnings) Console.Error.WriteLine($"  warning: {w}");
+    Console.WriteLine($"meta gen: {outcome.Result!.Files.Count(f => f.Status == "written")} file(s) written");
+    return 0;
+}
+
 static int Unknown(string cmd)
 {
     Console.Error.WriteLine($"meta: unknown command \"{cmd}\"");
diff --git a/server/csharp/MetaObjects.Codegen.Tests/EntityGeneratorTests.cs b/server/csharp/MetaObjects.Codegen.Tests/EntityGeneratorTests.cs
@@ -0,0 +1,114 @@
+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 EntityGeneratorTests
+{
+    private const string Model = """
+    { "metadata.root": { "package": "acme", "children": [
+      { "object.entity": { "name": "Subscriber", "children": [
+        { "source.dbTable": { "@name": "subscribers" } },
+        { "field.long":    { "name": "id" } },
+        { "field.string":  { "name": "email", "@required": true, "@maxLength": 255 } },
+        { "field.boolean": { "name": "subscribed" } },
+        { "field.timestamp": { "name": "createdAt" } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}}
+    ]}}
+    """;
+
+    private static MetaRoot Load()
+    {
+        var r = new MetaDataLoader().Load([new InMemorySource(Model, id: "gen.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.Generated" },
+    };
+
+    [Fact]
+    public void Entity_class_has_table_key_columns_and_nullability()
+    {
+        var ctx = Ctx(Load());
+        var file = Assert.Single(new EntityGenerator().Generate(ctx));
+        Assert.Equal("Subscriber.g.cs", file.Path);
+        var src = file.Content;
+
+        Assert.Contains("namespace Acme.Generated;", src);
+        Assert.Contains("[Table(\"subscribers\")]", src);
+        Assert.Contains("public class Subscriber", src);
+        // PK long, required -> non-nullable, [Key] + [Column]
+        Assert.Contains("[Key]", src);
+        Assert.Contains("[Column(\"id\")]", src);
+        Assert.Contains("public long Id { get; set; }", src);
+        // required string -> [Required] + [MaxLength] + non-nullable w/ default!
+        Assert.Contains("[Column(\"email\")]", src);
+        Assert.Contains("[MaxLength(255)]", src);
+        Assert.Contains("public string Email { get; set; } = default!;", src);
+        // optional value types -> nullable
+        Assert.Contains("public bool? Subscribed { get; set; }", src);
+        Assert.Contains("public DateTime? CreatedAt { get; set; }", src);
+    }
+
+    [Fact]
+    public void Generated_entity_compiles()
+    {
+        var ctx = Ctx(Load());
+        var src = new EntityGenerator().Generate(ctx).Single().Content;
+
+        var tree = CSharpSyntaxTree.ParseText(src, new CSharpParseOptions(LanguageVersion.CSharp12));
+        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("entitycompile_" + Guid.NewGuid().ToString("N"),
+            [tree], 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 entity should compile, got: " + string.Join("; ", errors));
+    }
+
+    [Fact]
+    public void DbContext_exposes_a_dbset_per_entity()
+    {
+        var ctx = Ctx(Load());
+        var file = Assert.Single(new DbContextGenerator().Generate(ctx));
+        Assert.Equal("AppDbContext.g.cs", file.Path);
+        Assert.Contains("public class AppDbContext : DbContext", file.Content);
+        Assert.Contains("public DbSet<Subscriber> Subscribers { get; set; } = default!;", file.Content);
+    }
+
+    [Fact]
+    public void Runner_writes_generated_files_but_refuses_handwritten()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "mo-gen-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            var config = new GenConfig { OutDir = dir, Namespace = "Acme.Generated" };
+            var r1 = CodegenRunner.Run(config, Load(), [new EntityGenerator()]);
+            Assert.Contains(r1.Files, f => f.Path == "Subscriber.g.cs" && f.Status == "written");
+            Assert.True(File.Exists(Path.Combine(dir, "Subscriber.g.cs")));
+
+            // Re-run overwrites the @generated file.
+            var r2 = CodegenRunner.Run(config, Load(), [new EntityGenerator()]);
+            Assert.Contains(r2.Files, f => f.Path == "Subscriber.g.cs" && f.Status == "written");
+
+            // A hand-written file (no marker) is refused.
+            File.WriteAllText(Path.Combine(dir, "Subscriber.g.cs"), "// my hand-written file\n");
+            var r3 = CodegenRunner.Run(config, Load(), [new EntityGenerator()]);
+            Assert.Contains(r3.Files, f => f.Path == "Subscriber.g.cs" && f.Status == "skipped-handwritten");
+            Assert.Equal("// my hand-written file\n", File.ReadAllText(Path.Combine(dir, "Subscriber.g.cs")));
+        }
+        finally { try { Directory.Delete(dir, true); } catch { } }
+    }
+}
diff --git a/server/csharp/MetaObjects.Codegen/CSharpNaming.cs b/server/csharp/MetaObjects.Codegen/CSharpNaming.cs
@@ -0,0 +1,60 @@
+// Field/entity -> idiomatic C# (EF Core) type + name mapping for codegen.
+//
+// Property names are PascalCase (C# convention); the metadata field name is
+// preserved as the DB column via [Column(...)] so the wire/DB contract is
+// unchanged. Scalar subtypes map to the natural .NET types; date/time/timestamp
+// use the modern DateOnly/TimeOnly/DateTime trio.
+
+using MetaObjects.Meta;
+using static MetaObjects.Core.Field.FieldConstants;
+
+namespace MetaObjects.Codegen;
+
+/// <summary>Field-subtype -> C# type + naming helpers for the EF Core generators.</summary>
+public static class CSharpNaming
+{
+    private static readonly IReadOnlyDictionary<string, string> ScalarType =
+        new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            [FIELD_SUBTYPE_STRING]    = "string",
+            [FIELD_SUBTYPE_CLASS]     = "string",
+            [FIELD_SUBTYPE_INT]       = "int",
+            [FIELD_SUBTYPE_SHORT]     = "short",
+            [FIELD_SUBTYPE_BYTE]      = "byte",
+            [FIELD_SUBTYPE_LONG]      = "long",
+            [FIELD_SUBTYPE_CURRENCY]  = "long",   // integer minor units (wire contract)
+            [FIELD_SUBTYPE_DOUBLE]    = "double",
+            [FIELD_SUBTYPE_FLOAT]     = "float",
+            [FIELD_SUBTYPE_DECIMAL]   = "decimal",
+            [FIELD_SUBTYPE_BOOLEAN]   = "bool",
+            [FIELD_SUBTYPE_DATE]      = "DateOnly",
+            [FIELD_SUBTYPE_TIME]      = "TimeOnly",
+            [FIELD_SUBTYPE_TIMESTAMP] = "DateTime",
+        };
+
+    /// <summary>Value types that take a <c>?</c> suffix when nullable (vs. reference types).</summary>
+    private static readonly HashSet<string> ValueTypes = new(StringComparer.Ordinal)
+        { "int", "short", "byte", "long", "double", "float", "decimal", "bool", "DateOnly", "TimeOnly", "DateTime" };
+
+    /// <summary>The base C# scalar type for a field subtype (no nullability), or null for object fields.</summary>
+    public static string? ScalarFor(string fieldSubType) =>
+        ScalarType.GetValueOrDefault(fieldSubType);
+
+    /// <summary>True when the C# type is a value type (gets <c>?</c> for nullable; needs no <c>= default!</c>).</summary>
+    public static bool IsValueType(string csharpType) => ValueTypes.Contains(csharpType);
+
+    /// <summary>PascalCase the (camelCase) metadata name for a C# member/type identifier.</summary>
+    public static string Pascal(string name) =>
+        name.Length == 0 ? name : char.ToUpperInvariant(name[0]) + name[1..];
+
+    /// <summary>
+    /// Whether a field is non-nullable in the generated entity: explicitly @required,
+    /// or part of the primary identity.
+    /// </summary>
+    public static bool IsRequired(MetaObject entity, MetaField field)
+    {
+        if (field.OwnAttr(FIELD_ATTR_REQUIRED) is true) return true;
+        var pk = entity.PrimaryIdentity();
+        return pk is not null && pk.Fields.Contains(field.Name);
+    }
+}
diff --git a/server/csharp/MetaObjects.Codegen/CodegenRunner.cs b/server/csharp/MetaObjects.Codegen/CodegenRunner.cs
@@ -0,0 +1,54 @@
+// CodegenRunner — runs generators against a loaded model and writes files under
+// an @generated-header guard: a file is overwritten only if it carries the
+// generated marker, so hand-written files are never clobbered. Mirrors the
+// overwrite policy of codegen-ts's runGen (three-way merge can layer on later).
+
+using MetaObjects.Meta;
+
+namespace MetaObjects.Codegen;
+
+/// <summary>Runs a generator set and writes the emitted files.</summary>
+public static class CodegenRunner
+{
+    /// <summary>Files carrying this marker are owned by codegen and safe to overwrite.</summary>
+    public const string GeneratedMarker = "<auto-generated/>";
+
+    public sealed record WriteResult(string Path, string Status);
+    public sealed record RunResult(IReadOnlyList<WriteResult> Files, IReadOnlyList<string> Warnings);
+
+    public static RunResult Run(GenConfig config, MetaRoot root, IReadOnlyList<IGenerator> generators)
+    {
+        var warnings = new List<string>();
+        var ctx = new GenContext
+        {
+            Entities = root.Objects(),
+            Root = root,
+            Config = config,
+            Warn = warnings.Add,
+        };
+
+        Directory.CreateDirectory(config.OutDir);
+        var results = new List<WriteResult>();
+
+        foreach (var generator in generators)
+        {
+            foreach (var file in generator.Generate(ctx))
+            {
+                var full = Path.GetFullPath(Path.Combine(config.OutDir, file.Path));
+                if (File.Exists(full) && !File.ReadAllText(full).Contains(GeneratedMarker, StringComparison.Ordinal))
+                {
+                    warnings.Add($"refusing to overwrite hand-written file: {file.Path}");
+                    results.Add(new WriteResult(file.Path, "skipped-handwritten"));
+                    continue;
+                }
+
+                var dir = Path.GetDirectoryName(full);
+                if (dir is not null) Directory.CreateDirectory(dir);
+                File.WriteAllText(full, file.Content);
+                results.Add(new WriteResult(file.Path, "written"));
+            }
+        }
+
+        return new RunResult(results, warnings);
+    }
+}
diff --git a/server/csharp/MetaObjects.Codegen/Generator.cs b/server/csharp/MetaObjects.Codegen/Generator.cs
diff --git a/server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs b/server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs
diff --git a/server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs b/server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs
