merge: C# meta migrate — Postgres schema DDL [P2d]

dmealing · dmealing · commit 5c523bd096a5 · 2026-05-23T14:00:44.000-04:00
diff --git a/server/csharp/MetaObjects.Cli.Tests/MigrateCommandTests.cs b/server/csharp/MetaObjects.Cli.Tests/MigrateCommandTests.cs
@@ -0,0 +1,43 @@
+using MetaObjects.Cli;
+using Xunit;
+
+namespace MetaObjects.Cli.Tests;
+
+/// <summary>End-to-end `meta migrate`: a metadata dir -> a Postgres schema .sql file.</summary>
+public sealed class MigrateCommandTests : IDisposable
+{
+    private readonly string _tmp = Path.Combine(Path.GetTempPath(), "meta-migrate-" + Guid.NewGuid().ToString("N"));
+    private string MetaDir => Path.Combine(_tmp, "metaobjects");
+    private string OutFile => Path.Combine(_tmp, "schema.sql");
+
+    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 MigrateCommandTests()
+    {
+        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 Migrate_writes_postgres_ddl()
+    {
+        var outcome = MigrateCommand.Run(MetaDir, OutFile);
+        Assert.True(outcome.Ok, string.Join("; ", outcome.LoadErrors));
+        Assert.True(File.Exists(OutFile));
+        var sql = File.ReadAllText(OutFile);
+        Assert.Contains("CREATE TABLE subscribers (", sql);
+        Assert.Contains("email text NOT NULL", sql);
+        Assert.Contains("PRIMARY KEY (id)", sql);
+    }
+}
diff --git a/server/csharp/MetaObjects.Cli/MigrateCommand.cs b/server/csharp/MetaObjects.Cli/MigrateCommand.cs
@@ -0,0 +1,30 @@
+// `meta migrate` — emit Postgres schema DDL (CREATE TABLE + CREATE VIEW) from
+// metadata. (Schema diff against a live database is a later increment; this emits
+// the create-schema DDL deterministically from the model.)
+
+using MetaObjects.Codegen.Schema;
+using MetaObjects.Loader;
+
+namespace MetaObjects.Cli;
+
+/// <summary>The migrate command's pure logic (no console I/O), so it is testable.</summary>
+public static class MigrateCommand
+{
+    public sealed record Outcome(IReadOnlyList<string> LoadErrors, string? Sql, IReadOnlyList<string> Warnings)
+    {
+        public bool Ok => LoadErrors.Count == 0 && Sql is not null;
+    }
+
+    public static Outcome Run(string metadataDir, string outFile)
+    {
+        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 warnings = new List<string>();
+        var sql = PostgresSchema.BuildSchema(load.Root, warnings.Add);
+        File.WriteAllText(outFile, sql);
+        return new Outcome(loadErrors, sql, warnings);
+    }
+}
diff --git a/server/csharp/MetaObjects.Cli/Program.cs b/server/csharp/MetaObjects.Cli/Program.cs
@@ -9,17 +9,46 @@
         "usage: meta <command> [options]\n" +
         "  commands:\n" +
         "    gen <metadataDir> --out <dir> --namespace <ns>   generate EF Core code from metadata\n" +
+        "    migrate <metadataDir> --out <file.sql>           emit Postgres schema DDL from metadata\n" +
         "    verify <metadataDir> --templates <root>          drift-check templates against their payloads");
     return 2;
 }
 
 return args[0] switch
 {
     "gen" => RunGen(args[1..]),
+    "migrate" => RunMigrate(args[1..]),
     "verify" => RunVerify(args[1..]),
     _ => Unknown(args[0]),
 };
 
+static int RunMigrate(string[] rest)
+{
+    string? metadataDir = null;
+    string? outFile = null;
+    for (int i = 0; i < rest.Length; i++)
+    {
+        if (rest[i] == "--out" && i + 1 < rest.Length) outFile = rest[++i];
+        else if (!rest[i].StartsWith('-')) metadataDir ??= rest[i];
+    }
+    if (metadataDir is null || outFile is null)
+    {
+        Console.Error.WriteLine("usage: meta migrate <metadataDir> --out <file.sql>");
+        return 2;
+    }
+
+    var outcome = MigrateCommand.Run(metadataDir, outFile);
+    if (!outcome.Ok)
+    {
+        foreach (var e in outcome.LoadErrors) Console.Error.WriteLine($"  load error: {e}");
+        Console.Error.WriteLine("meta migrate: FAILED (metadata did not load cleanly)");
+        return 1;
+    }
+    foreach (var w in outcome.Warnings) Console.Error.WriteLine($"  warning: {w}");
+    Console.WriteLine($"meta migrate: wrote {outFile}");
+    return 0;
+}
+
 static int RunGen(string[] rest)
 {
     string? metadataDir = null;
diff --git a/server/csharp/MetaObjects.Codegen.Tests/PostgresSchemaTests.cs b/server/csharp/MetaObjects.Codegen.Tests/PostgresSchemaTests.cs
@@ -0,0 +1,80 @@
+using MetaObjects.Codegen.Schema;
+using MetaObjects.Loader;
+using MetaObjects.Meta;
+using Xunit;
+
+namespace MetaObjects.Codegen.Tests;
+
+public class PostgresSchemaTests
+{
+    // Week + Program (tables); ProgramView (passthrough projection from Program);
+    // ProgramStat (aggregate projection -> needs join/aggregate SQL -> TODO).
+    private const string Model = """
+    { "metadata.root": { "package": "acme", "children": [
+      { "object.entity": { "name": "Week", "children": [
+        { "source.dbTable": { "@name": "weeks" } },
+        { "field.long": { "name": "id" } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}},
+      { "object.entity": { "name": "Program", "children": [
+        { "source.dbTable": { "@name": "programs" } },
+        { "field.long":   { "name": "id" } },
+        { "field.string": { "name": "title", "@required": true, "@maxLength": 200 } },
+        { "relationship.aggregation": { "name": "weeks", "@objectRef": "Week", "@cardinality": "many" } },
+        { "identity.primary": { "@fields": "id" } },
+        { "identity.secondary": { "name": "byTitle", "@fields": "title", "@unique": true } }
+      ]}},
+      { "object.value": { "name": "ProgramView", "children": [
+        { "source.dbView": { "@name": "v_program" } },
+        { "field.long":   { "name": "id",    "children": [ { "origin.passthrough": { "@from": "Program.id" } } ] } },
+        { "field.string": { "name": "title", "children": [ { "origin.passthrough": { "@from": "Program.title" } } ] } }
+      ]}},
+      { "object.value": { "name": "ProgramStat", "children": [
+        { "source.dbView": { "@name": "v_program_stat" } },
+        { "field.int": { "name": "weekCount", "children": [
+          { "origin.aggregate": { "@agg": "count", "@of": "Week.id", "@via": "Program.weeks" } }
+        ]}}
+      ]}}
+    ]}}
+    """;
+
+    private static MetaRoot Load()
+    {
+        var r = new MetaDataLoader().Load([new InMemorySource(Model, id: "schema.json")]);
+        Assert.Empty(r.Errors);
+        return r.Root;
+    }
+
+    [Fact]
+    public void CreateTable_emits_columns_pk_notnull_and_unique_index()
+    {
+        var warns = new List<string>();
+        var sql = PostgresSchema.BuildSchema(Load(), warns.Add);
+
+        Assert.Contains("CREATE TABLE programs (", sql);
+        Assert.Contains("id bigint NOT NULL", sql);
+        Assert.Contains("title varchar(200) NOT NULL", sql);
+        Assert.Contains("PRIMARY KEY (id)", sql);
+        Assert.Contains("CREATE UNIQUE INDEX programs_byTitle_uniq ON programs (title);", sql);
+        Assert.Contains("CREATE TABLE weeks (", sql);
+    }
+
+    [Fact]
+    public void CreateView_emits_select_for_passthrough_projection()
+    {
+        var sql = PostgresSchema.BuildSchema(Load());
+        Assert.Contains("CREATE VIEW v_program AS", sql);
+        Assert.Contains("id AS id", sql);
+        Assert.Contains("title AS title", sql);
+        Assert.Contains("FROM programs;", sql); // base entity Program -> its table "programs"
+    }
+
+    [Fact]
+    public void Aggregate_projection_is_flagged_todo_not_wrong_sql()
+    {
+        var warns = new List<string>();
+        var sql = PostgresSchema.BuildSchema(Load(), warns.Add);
+        Assert.Contains("-- TODO CREATE VIEW v_program_stat", sql);
+        Assert.Contains(warns, w => w.Contains("v_program_stat"));
+    }
+}
diff --git a/server/csharp/MetaObjects.Codegen/Schema/PostgresSchema.cs b/server/csharp/MetaObjects.Codegen/Schema/PostgresSchema.cs
@@ -0,0 +1,134 @@
+// PostgresSchema — emits Postgres DDL from metadata: CREATE TABLE per entity
+// (columns/PK/NOT NULL/UNIQUE) and CREATE VIEW per read-only projection.
+//
+// Column + table names mirror the EF Core generators ([Table]/[Column] use the
+// dbTable/dbColumn override or the raw name), so the generated entities map onto
+// this schema. View SELECTs are derived from field origins for the common case
+// (passthrough from a single base, no relationship hop); aggregate / @via /
+// collection origins are flagged as a TODO rather than emitting incorrect SQL.
+
+using System.Text;
+using MetaObjects.Meta;
+using static MetaObjects.Core.Field.FieldConstants;
+using static MetaObjects.Shared.BaseTypes;
+
+namespace MetaObjects.Codegen.Schema;
+
+/// <summary>Postgres DDL generation from a loaded model.</summary>
+public static class PostgresSchema
+{
+    /// <summary>Field subtype -> Postgres column type (varchar(n) when @maxLength is set).</summary>
+    public static string PgType(MetaField field) => field.SubType switch
+    {
+        FIELD_SUBTYPE_STRING or FIELD_SUBTYPE_CLASS =>
+            field.MaxLength is long n ? $"varchar({n})" : "text",
+        FIELD_SUBTYPE_INT       => "integer",
+        FIELD_SUBTYPE_SHORT     => "smallint",
+        FIELD_SUBTYPE_BYTE      => "smallint",
+        FIELD_SUBTYPE_LONG      => "bigint",
+        FIELD_SUBTYPE_CURRENCY  => "bigint",      // integer minor units
+        FIELD_SUBTYPE_DOUBLE    => "double precision",
+        FIELD_SUBTYPE_FLOAT     => "real",
+        FIELD_SUBTYPE_DECIMAL   => field.Precision is long p
+            ? $"numeric({p}, {field.Scale ?? 0})" : "numeric",
+        FIELD_SUBTYPE_BOOLEAN   => "boolean",
+        FIELD_SUBTYPE_DATE      => "date",
+        FIELD_SUBTYPE_TIME      => "time",
+        FIELD_SUBTYPE_TIMESTAMP => "timestamp",
+        _ => "text",
+    };
+
+    private static string Col(MetaField f) => f.DbColumn ?? f.Name;
+
+    /// <summary>CREATE TABLE for a writable entity (columns + PK + NOT NULL + UNIQUE).</summary>
+    public static string CreateTable(MetaObject entity)
+    {
+        var table = entity.DbTable ?? entity.Name;
+        var pk = entity.PrimaryIdentity();
+        var pkCols = (pk?.Fields ?? []).ToHashSet(StringComparer.Ordinal);
+
+        var lines = new List<string>();
+        foreach (var f in entity.Fields().Where(f => CSharpNaming.ScalarFor(f.SubType) is not null))
+        {
+            var notNull = CSharpNaming.IsRequired(entity, f) ? " NOT NULL" : string.Empty;
+            lines.Add($"  {Col(f)} {PgType(f)}{notNull}");
+        }
+        if (pk is not null && pk.Fields.Count > 0)
+        {
+            var cols = entity.Fields().Where(f => pkCols.Contains(f.Name)).Select(Col);
+            lines.Add($"  PRIMARY KEY ({string.Join(", ", cols)})");
+        }
+
+        var sb = new StringBuilder();
+        sb.AppendLine($"CREATE TABLE {table} (");
+        sb.AppendLine(string.Join(",\n", lines));
+        sb.AppendLine(");");
+
+        // UNIQUE indexes from secondary identities marked unique.
+        foreach (var sec in entity.SecondaryIdentities().Where(i => i.Unique))
+        {
+            var cols = entity.Fields().Where(f => sec.Fields.Contains(f.Name)).Select(Col);
+            sb.AppendLine($"CREATE UNIQUE INDEX {table}_{sec.Name}_uniq ON {table} ({string.Join(", ", cols)});");
+        }
+        return sb.ToString();
+    }
+
+    /// <summary>CREATE VIEW for a projection; best-effort SELECT from passthrough origins.</summary>
+    public static string CreateView(MetaObject projection, MetaRoot root, Action<string> warn)
+    {
+        var view = projection.DbView!;
+        var cols = new List<string>();
+        string? baseEntity = null;
+        bool complex = false;
+
+        foreach (var f in projection.Fields().Where(f => CSharpNaming.ScalarFor(f.SubType) is not null))
+        {
+            var origin = f.OwnChildren().FirstOrDefault(c => c.Type == TYPE_ORIGIN);
+            if (origin is MetaPassthroughOrigin pt && pt.Via is null && pt.From is { } from && from.Contains('.'))
+            {
+                var dot = from.IndexOf('.');
+                var ent = from[..dot];
+                var srcCol = from[(dot + 1)..];
+                baseEntity ??= ent;
+                if (ent != baseEntity) { complex = true; break; }
+                cols.Add($"  {srcCol} AS {Col(f)}");
+            }
+            else
+            {
+                complex = true; // aggregate / @via / collection / no origin -> needs join/agg SQL
+                break;
+            }
+        }
+
+        if (complex || baseEntity is null || cols.Count == 0)
+        {
+            warn($"meta migrate: view \"{view}\" needs aggregate/relationship-path SQL — emitted as TODO.");
+            return $"-- TODO CREATE VIEW {view}: derive SELECT from aggregate/@via/collection origins\n" +
+                   $"--      (passthrough-from-single-base views are generated; this projection needs join/aggregate SQL).\n";
+        }
+
+        var baseTable = root.FindObject(baseEntity)?.DbTable ?? baseEntity;
+        return $"CREATE VIEW {view} AS\nSELECT\n{string.Join(",\n", cols)}\nFROM {baseTable};\n";
+    }
+
+    /// <summary>Full schema DDL: tables for writable entities, then views for projections.</summary>
+    public static string BuildSchema(MetaRoot root, Action<string>? warn = null)
+    {
+        var warnFn = warn ?? (_ => { });
+        var sb = new StringBuilder();
+        sb.AppendLine("-- Generated by MetaObjects meta migrate (Postgres). Do not edit by hand.");
+        sb.AppendLine();
+
+        foreach (var e in root.Objects().Where(o => o.IsEntity() && !o.IsReadOnlyProjection())
+                     .OrderBy(o => o.Name, StringComparer.Ordinal))
+        {
+            sb.AppendLine(CreateTable(e));
+        }
+        foreach (var p in root.Objects().Where(o => o.IsReadOnlyProjection())
+                     .OrderBy(o => o.Name, StringComparer.Ordinal))
+        {
+            sb.AppendLine(CreateView(p, root, warnFn));
+        }
+        return sb.ToString();
+    }
+}
