@supawatch/target-seed 0.5.0 → 0.7.0

package/dist/index.js

@@ -130,6 +130,12 @@ export class SeedTarget {
         ];
         const tables = snapshot.tables.filter((t) => t.kind === "table");
         const byName = new Map(tables.map((t) => [`${t.schema}.${t.name}`, t]));
+        // A base-type literal for a constrained domain is a guess against a
+        // CHECK the snapshot does not parse. Never guess: let the database
+        // fill nullable or defaulted columns of constrained domains, and
+        // skip tables that require one. Unconstrained domains behave as
+        // their base type and seed normally.
+        const constrainedDomains = new Set(snapshot.domains.filter((d) => d.hasConstraints).map((d) => d.name));
         // The literal a table's Nth row uses for its single-column primary
         // key. Children reuse this for their FK cells, so uuid and numeric
         // parents both reference correctly. Deterministic by construction.
@@ -155,9 +161,10 @@ export class SeedTarget {
         for (const t of cyclic) {
             lines.push(`-- skipped ${t.schema}.${t.name}: required foreign keys form a cycle`);
         }
+        // Pass 1: plan each table's insertable columns and its own skip
+        // reasons, without emitting yet.
+        const plans = [];
         for (const table of ordered) {
-            const q = (s) => '"' + s.replace(/"/g, '""') + '"';
-            const ident = `${q(table.schema)}.${q(table.name)}`;
             const pk = table.primaryKey.length === 1 ? table.primaryKey[0] : null;
             const skipReasons = [];
             const cols = [];
@@ -175,6 +182,15 @@ export class SeedTarget {
                     }
                     continue;
                 }
+                if (constrainedDomains.has(col.pgTypeName)) {
+                    if (col.name === pk) {
+                        skipReasons.push(`primary key ${col.name} has a constrained domain type`);
+                    }
+                    else if (!col.nullable && !col.hasDefault) {
+                        skipReasons.push(`constrained domain type on ${col.name}`);
+                    }
+                    continue;
+                }
                 if (col.name === pk) {
                     cols.push(col);
                     continue;
@@ -192,6 +208,45 @@ export class SeedTarget {
                 }
                 cols.push(col);
             }
+            plans.push({ table, cols, skipReasons });
+        }
+        // A required single-column FK into a table that is not seeded (its
+        // own reasons, a cycle, or outside the snapshot) makes the child
+        // unseedable too; propagate to a fixpoint so seed.sql always
+        // applies.
+        const skipped = new Set(cyclic.map((t) => `${t.schema}.${t.name}`));
+        for (const p of plans) {
+            if (p.skipReasons.length > 0)
+                skipped.add(`${p.table.schema}.${p.table.name}`);
+        }
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const p of plans) {
+                const key = `${p.table.schema}.${p.table.name}`;
+                if (skipped.has(key))
+                    continue;
+                for (const fk of p.table.foreignKeys) {
+                    if (f_multi(fk))
+                        continue;
+                    const col = p.table.columns.find((c) => fk.columns.includes(c.name));
+                    if (!col || col.nullable || col.hasDefault)
+                        continue;
+                    const parentKey = `${fk.referencedSchema}.${fk.referencedTable}`;
+                    if (skipped.has(parentKey) || !byName.has(parentKey)) {
+                        p.skipReasons.push(`required foreign key ${col.name} references ${parentKey}, which is not seeded`);
+                        skipped.add(key);
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+        }
+        // Pass 2: emit.
+        for (const { table, cols, skipReasons } of plans) {
+            const q = (s) => '"' + s.replace(/"/g, '""') + '"';
+            const ident = `${q(table.schema)}.${q(table.name)}`;
+            const pk = table.primaryKey.length === 1 ? table.primaryKey[0] : null;
             if (skipReasons.length > 0) {
                 lines.push(`-- skipped ${table.schema}.${table.name}: ${skipReasons.join("; ")}`);
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supawatch/target-seed",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Deterministic FK-aware seed.sql generated from live Postgres by supawatch: topological order, identity overriding, sequence resync.",
   "keywords": [
     "supabase",
@@ -34,7 +34,7 @@
     "dist"
   ],
   "dependencies": {
-    "@supawatch/core": "0.5.0"
+    "@supawatch/core": "0.7.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",