feat(migrate-ts): thread relationship @onDelete/@onUpdate into FK descriptors

buildForeignKeys now correlates each identity.reference with its sibling
relationship to derive onDelete/onUpdate per the rollout-decided defaults
(composition->cascade, aggregation->set-null, association->restrict; onUpdate
default cascade). Explicit @onDelete/@onUpdate on the relationship override.
Resolved 'no-action' is omitted from the FkDescriptor to match the
introspectors and keep round-trip diffs clean.

Existing FK-shape assertions updated to include the derived defaults.

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

Author: dmealing

server/typescript/packages/migrate-ts/src/expected-schema.ts

@@ -34,6 +34,7 @@ import type { SqlType } from "./sql-type.js";
 import type {
   SchemaSnapshot, TableDescriptor, ColumnDescriptor, IndexDescriptor, FkDescriptor,
 } from "./types.js";
+import { resolveReferentialActions } from "./referential-actions.js";
 
 export interface BuildExpectedSchemaOptions {
   /**
@@ -242,12 +243,16 @@ function buildForeignKeys(
       ? explicitTargetFields.map(toSnake)
       : [toSnake(refChild.resolvedTargetPkField(root) ?? "id")];
 
-    fks.push({
+    const { onDelete, onUpdate } = resolveReferentialActions(entity, refChild);
+    const fk: FkDescriptor = {
       name: `${tableName}_${fkCols[0]}_fk`,
       columns: fkCols,
       refTable,
       refColumns,
-    });
+    };
+    if (onDelete !== undefined) fk.onDelete = onDelete;
+    if (onUpdate !== undefined) fk.onUpdate = onUpdate;
+    fks.push(fk);
   }
   return fks;
 }

server/typescript/packages/migrate-ts/test/unit/expected-schema.test.ts

@@ -111,14 +111,16 @@ describe("buildExpectedSchema — indexes + FKs", () => {
     expect(programs?.indexes.find((i) => i.name === "programs_pk")).toBeUndefined();
   });
 
-  test("many-to-one relationship → FK on child table", () => {
+  test("many-to-one relationship → FK on child table (association → restrict/cascade defaults)", () => {
     const weeks = snapshot.tables.find((t) => t.name === "weeks");
     expect(weeks?.foreignKeys).toEqual([
       {
         name: "weeks_program_id_fk",
         columns: ["program_id"],
         refTable: "programs",
         refColumns: ["id"],
+        onDelete: "restrict",
+        onUpdate: "cascade",
       },
     ]);
   });

server/typescript/packages/migrate-ts/test/unit/referential-actions.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import { resolveReferentialActions } from "../../src/referential-actions.js";
+import { buildExpectedSchema } from "../../src/expected-schema.js";
+import { diff } from "../../src/diff/index.js";
+import { emit } from "../../src/emit/index.js";
 import { MetaDataLoader, InMemorySource } from "@metaobjectsdev/metadata";
 
 async function loadDoc(doc: unknown) {
@@ -65,3 +68,88 @@ describe("resolveReferentialActions", () => {
     expect(resolveReferentialActions(week, ref)).toEqual({ onDelete: undefined, onUpdate: undefined });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Round-trip: buildExpectedSchema → diff (against empty) → emit
+//
+// Asserts that the relationship-derived defaults (and explicit overrides)
+// flow all the way through to the emitted DDL — for both Postgres
+// (ALTER TABLE … ADD CONSTRAINT) and SQLite (inline FOREIGN KEY clause).
+// ---------------------------------------------------------------------------
+
+const EMPTY_SCHEMA = { tables: [], views: [] };
+
+function makeDoc(rel: Record<string, unknown>) {
+  return {
+    "metadata.root": {
+      package: "acme",
+      children: [
+        { "object.entity": { name: "Program", children: [
+          { "field.long": { name: "id" } },
+          { "identity.primary": { "@fields": "id" } },
+        ] } },
+        { "object.entity": { name: "Week", children: [
+          { "field.long": { name: "id" } },
+          { "field.long": { name: "programId" } },
+          rel,
+          { "identity.reference": { name: "ref_program", "@fields": ["programId"], "@references": "Program" } },
+          { "identity.primary": { "@fields": "id" } },
+        ] } },
+      ],
+    },
+  };
+}
+
+async function buildSnapshotForRel(rel: Record<string, unknown>) {
+  const { root, errors } = await new MetaDataLoader().load([
+    new InMemorySource(JSON.stringify(makeDoc(rel))),
+  ]);
+  expect(errors).toHaveLength(0);
+  return buildExpectedSchema(root);
+}
+
+describe("end-to-end FK actions in emitted DDL", () => {
+  test("composition default → ON DELETE CASCADE / ON UPDATE CASCADE (Postgres ADD CONSTRAINT)", async () => {
+    const snapshot = await buildSnapshotForRel({
+      "relationship.composition": { name: "program", "@objectRef": "Program", "@cardinality": "one" },
+    });
+    const { changes } = await diff(snapshot, EMPTY_SCHEMA);
+    const { up } = emit(changes, { dialect: "postgres" });
+    expect(up).toContain('ADD CONSTRAINT "weeks_program_id_fk"');
+    expect(up).toContain('REFERENCES "programs" ("id") ON DELETE CASCADE ON UPDATE CASCADE');
+  });
+
+  test("composition default → inline FOREIGN KEY … ON DELETE CASCADE ON UPDATE CASCADE (SQLite CREATE TABLE)", async () => {
+    const snapshot = await buildSnapshotForRel({
+      "relationship.composition": { name: "program", "@objectRef": "Program", "@cardinality": "one" },
+    });
+    const { changes } = await diff(snapshot, EMPTY_SCHEMA);
+    const { up } = emit(changes, { dialect: "sqlite" });
+    expect(up).toContain('FOREIGN KEY ("program_id") REFERENCES "programs" ("id") ON DELETE CASCADE ON UPDATE CASCADE');
+  });
+
+  test("explicit @onDelete: set-null overrides composition default; @onUpdate stays cascade (Postgres)", async () => {
+    const snapshot = await buildSnapshotForRel({
+      "relationship.composition": {
+        name: "program", "@objectRef": "Program", "@cardinality": "one",
+        "@onDelete": "set-null", "@onUpdate": "cascade",
+      },
+    });
+    const { changes } = await diff(snapshot, EMPTY_SCHEMA);
+    const { up } = emit(changes, { dialect: "postgres" });
+    expect(up).toContain('REFERENCES "programs" ("id") ON DELETE SET NULL ON UPDATE CASCADE');
+    expect(up).not.toContain("ON DELETE CASCADE");
+  });
+
+  test("explicit @onDelete: set-null overrides composition default (SQLite inline)", async () => {
+    const snapshot = await buildSnapshotForRel({
+      "relationship.composition": {
+        name: "program", "@objectRef": "Program", "@cardinality": "one",
+        "@onDelete": "set-null", "@onUpdate": "cascade",
+      },
+    });
+    const { changes } = await diff(snapshot, EMPTY_SCHEMA);
+    const { up } = emit(changes, { dialect: "sqlite" });
+    expect(up).toContain('FOREIGN KEY ("program_id") REFERENCES "programs" ("id") ON DELETE SET NULL ON UPDATE CASCADE');
+  });
+});