@apso/cli 0.43.3 → 0.44.0

package/dist/lib/verify/index.js

@@ -1,12 +1,12 @@
 "use strict";
 /**
  * Pre-deploy checks for a generated service: generate the migration from the
- * deployed schema, run it and check for drift (TypeScript only, on PGlite),
- * and smoke test the endpoints. The CLI and the in-browser editor (which runs
+ * deployed schema, run it and check for drift (on PGlite), and smoke test the
+ * endpoints. The CLI and the in-browser editor (which runs
  * the CLI in a WebContainer) share these steps.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.report = exports.cliBinPath = exports.readDotEnv = exports.smokeTest = exports.entityRoute = exports.verifyMigration = exports.supportsPglite = exports.generateMigration = exports.migrateUnsupported = exports.buildBaseline = exports.pgliteEnv = exports.run = void 0;
+exports.report = exports.cliBinPath = exports.readDotEnv = exports.smokeTest = exports.entityRoute = exports.verifyMigration = exports.supportsPglite = exports.unaccepted = exports.dataLoss = exports.generateMigration = exports.buildBaseline = exports.pgliteEnv = exports.run = void 0;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
@@ -15,8 +15,13 @@ const net = tslib_1.__importStar(require("net"));
 const os = tslib_1.__importStar(require("os"));
 const path = tslib_1.__importStar(require("path"));
 const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
+const apsorc_parser_1 = require("../apsorc-parser");
+const ddl_1 = require("../ddl");
+const catalog_1 = require("../ddl/catalog");
+const migration_file_1 = require("../ddl/migration-file");
 const casing_1 = require("../utils/casing");
 const crud_plan_1 = require("./crud-plan");
+const review_1 = require("./review");
 // eslint-disable-next-line no-control-regex
 const plain = (s) => s.replace(/\u001B\[[\d;]*m/g, "");
 const tail = (s, n = 4000) => {
@@ -85,19 +90,6 @@ async function buildBaseline(projectDir, baselineApsorc, dataDir, cliBin) {
     }
 }
 exports.buildBaseline = buildBaseline;
-/**
- * Why `apso migrate` can't run for this project's language, or undefined.
- * ponytail: Python (Alembic) and Go (goose) have no local scratch database to
- * build the baseline on; add when they get one like PGlite for TypeScript.
- */
-const migrateUnsupported = (language = "typescript") => {
-    if (language === "python")
-        return "apso migrate supports TypeScript services only for now. This is a Python service: use Alembic directly (alembic revision --autogenerate, alembic upgrade head, alembic check).";
-    if (language === "go")
-        return "apso migrate supports TypeScript services only for now. This is a Go service: write goose migrations in migrations/ and run them with `go run cmd/migrate/main.go up`.";
-    return undefined;
-};
-exports.migrateUnsupported = migrateUnsupported;
 /** Generate a migration from the deployed schema (baselineApsorc) to the project's entities. */
 async function generateMigration(projectDir, baselineApsorc, name, cliBin) {
     const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
@@ -129,6 +121,9 @@ async function generateMigration(projectDir, baselineApsorc, name, cliBin) {
             needed: true,
             file: file && path.join("src", "migrations", file),
             steps,
+            findings: file
+                ? (0, review_1.reviewMigration)(fs.readFileSync(path.join(migrationsDir, file), "utf8"))
+                : undefined,
         };
     }
     finally {
@@ -148,6 +143,96 @@ ds.initialize()
   .then((ran) => { console.log("ran " + ran.map((m) => m.name).join(", ")); return ds.destroy(); })
   .catch((e) => { console.error(e && e.message ? e.message : e); process.exit(1); });
 `;
+// Row and non-null value counts per table and column of the PGlite database
+// at PGLITE_DATA_DIR, after running the SQL file in argv[1] if given, plus each
+// column's distinct values (as text) so data moved to another table is found.
+const COUNT_ROWS = `
+const fs = require("fs");
+const { PGlite } = require("@electric-sql/pglite");
+(async () => {
+  const db = new PGlite(process.env.PGLITE_DATA_DIR);
+  if (process.argv[1]) await db.exec(fs.readFileSync(process.argv[1], "utf8"));
+  const cols = (await db.query("SELECT table_name, column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name <> 'migrations'")).rows;
+  const out = {};
+  for (const { table_name: t, column_name: c } of cols) {
+    const q = '"' + c + '"';
+    const r = (await db.query("SELECT count(*)::int AS rows, count(" + q + ")::int AS vals, (SELECT array_agg(v) FROM (SELECT DISTINCT " + q + "::text AS v FROM \\"" + t + "\\" WHERE " + q + " IS NOT NULL LIMIT 1000) d) AS dv FROM \\"" + t + "\\"")).rows[0];
+    out[t] = out[t] || { rows: r.rows, values: {}, distinct: {} };
+    out[t].values[c] = r.vals;
+    out[t].distinct[c] = r.dv || [];
+  }
+  console.log(JSON.stringify(out));
+  await db.close();
+})().catch((e) => { console.error(e.message); process.exit(1); });
+`;
+// Assertions the user wrote for this migration: each SELECT returns rows with a
+// boolean "ok" and a "label", the same format as the eval checks.
+const RUN_CHECKS = `
+const fs = require("fs");
+const { PGlite } = require("@electric-sql/pglite");
+(async () => {
+  const db = new PGlite(process.env.PGLITE_DATA_DIR);
+  const failed = [];
+  for (const r of await db.exec(fs.readFileSync(process.argv[1], "utf8")))
+    for (const row of r.rows) if ("ok" in row && row.ok !== true) failed.push(row.label || JSON.stringify(row));
+  await db.close();
+  if (failed.length) { console.error("Failed checks:\\n" + failed.join("\\n")); process.exit(1); }
+})().catch((e) => { console.error(e.message); process.exit(1); });
+`;
+// Filled in by the database on insert, so a moved row gets new ones.
+const GENERATED = new Set(["created_at", "updated_at"]);
+/**
+ * Rows and values present before the migration and missing after it,
+ * following the tables and columns the migration renames. A column or table
+ * whose values all turn up in another column after the migration was moved,
+ * not lost (a field moved to a new table, a foreign key moved to a join table).
+ */
+function dataLoss(before, after, source) {
+    var _a, _b, _c, _d;
+    const tables = new Map([...source.matchAll(/ALTER TABLE "([^"]+)" RENAME TO "([^"]+)"/g)].map((m) => [m[1], m[2]]));
+    const columns = new Map([...source.matchAll(/ALTER TABLE "([^"]+)" RENAME COLUMN "([^"]+)" TO "([^"]+)"/g)].map((m) => [`${m[1]}.${m[2]}`, m[3]]));
+    // Only tables the migration creates count, and not their ids: small integer
+    // values (foreign keys) would otherwise match any existing id column.
+    const afterValues = Object.entries(after)
+        .filter(([t]) => !before[t] && ![...tables.values()].includes(t))
+        .flatMap(([, a]) => {
+        var _a;
+        return Object.entries((_a = a.distinct) !== null && _a !== void 0 ? _a : {})
+            .filter(([c]) => c !== "id")
+            .map(([, v]) => new Set(v));
+    });
+    const moved = (t, c) => {
+        var _a, _b;
+        const vals = (_b = (_a = before[t].distinct) === null || _a === void 0 ? void 0 : _a[c]) !== null && _b !== void 0 ? _b : [];
+        return vals.length > 0 && afterValues.some((s) => vals.every((v) => s.has(v)));
+    };
+    const lost = [];
+    for (const [t, { rows, values }] of Object.entries(before)) {
+        if (!rows)
+            continue;
+        const t2 = (_a = tables.get(t)) !== null && _a !== void 0 ? _a : t;
+        const now = after[t2];
+        if (!now) {
+            const gone = Object.keys(values).filter((c) => values[c] > 0 && !GENERATED.has(c) && !moved(t, c));
+            if (gone.length > 0)
+                lost.push(`table ${t}: all ${rows} rows`);
+            continue;
+        }
+        if (now.rows < rows)
+            lost.push(`table ${t}: ${rows - now.rows} of ${rows} rows`);
+        for (const [c, n] of Object.entries(values)) {
+            const c2 = (_c = (_b = columns.get(`${t}.${c}`)) !== null && _b !== void 0 ? _b : columns.get(`${t2}.${c}`)) !== null && _c !== void 0 ? _c : c;
+            const kept = (_d = now.values[c2]) !== null && _d !== void 0 ? _d : 0;
+            if (n > kept && !(kept === 0 && moved(t, c)))
+                lost.push(`${t}.${c}: ${n - kept} of ${n} values`);
+        }
+    }
+    return lost;
+}
+exports.dataLoss = dataLoss;
+/** Losses the user accepted by name: a table, or table.column. */
+const unaccepted = (lost, accept) => lost.filter((l) => !accept.some((a) => l.startsWith(`${a}:`) || l.startsWith(`table ${a}:`)));
+exports.unaccepted = unaccepted;
 /**
  * Projects from the v1 template have no PGlite support in src/orm.config.ts,
  * so the checks cannot run locally. They pass as skipped rather than block a
@@ -176,9 +261,17 @@ exports.supportsPglite = supportsPglite;
  * Run a migration on a fresh copy of the deployed schema, then check that the
  * database matches the project's entities (a second generate finds nothing).
  */
-async function verifyMigration(projectDir, baselineApsorc, migrationFile, cliBin, skipBuild = false) {
+async function verifyMigration(projectDir, baselineApsorc, migrationFile, cliBin, { skipBuild = false, seedFile, checkFile, acceptLoss = [], } = {}) {
+    if (/\.(py|sql)$/.test(migrationFile))
+        return verifySqlMigration(projectDir, baselineApsorc, migrationFile, cliBin, {
+            seedFile,
+            checkFile,
+            acceptLoss,
+        });
     if (!supportsPglite(projectDir))
         return NO_PGLITE;
+    const source = fs.readFileSync(path.resolve(projectDir, migrationFile), "utf8");
+    const findings = (0, review_1.reviewMigration)(source);
     const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
     const steps = [];
     const done = (s) => {
@@ -187,25 +280,157 @@ async function verifyMigration(projectDir, baselineApsorc, migrationFile, cliBin
     };
     try {
         if (!done(await buildBaseline(projectDir, baselineApsorc, dataDir, cliBin)))
-            return { ok: false, steps };
+            return { ok: false, steps, findings };
+        const count = async (name, sql) => {
+            const r = await run(process.execPath, ["-e", COUNT_ROWS, ...(sql ? [sql] : [])], projectDir, (0, exports.pgliteEnv)(dataDir));
+            done(step(name, r));
+            return r.ok ? JSON.parse(r.output.trim().split("\n").pop()) : undefined;
+        };
+        // Seed rows make the migration face the data it will meet in production.
+        const before = seedFile ? await count("seed", path.resolve(seedFile)) : undefined;
+        if (seedFile && !before)
+            return { ok: false, steps, findings };
         const compiled = path
             .join("dist", path.relative("src", migrationFile))
             .replace(/\.ts$/, ".js");
         // --skip-build still builds when the migration isn't compiled yet.
         const needsBuild = !skipBuild || !fs.existsSync(path.join(projectDir, compiled));
         if (needsBuild && !done(step("build", await build(projectDir))))
-            return { ok: false, steps };
+            return { ok: false, steps, findings };
         const migrate = await run(process.execPath, ["-e", RUN_ONE_MIGRATION, compiled], projectDir, (0, exports.pgliteEnv)(dataDir));
         if (!done({ ...step("migrate", migrate), output: tail(migrate.output) }))
-            return { ok: false, steps };
+            return { ok: false, steps, findings };
+        if (before) {
+            const after = await count("count");
+            if (!after)
+                return { ok: false, steps, findings };
+            const lost = dataLoss(before, after, source);
+            const ok = (0, exports.unaccepted)(lost, acceptLoss).length === 0;
+            done({
+                name: "data",
+                ok,
+                output: lost.length > 0
+                    ? `The migration lost seeded data:\n${lost.join("\n")}${ok ? "" : "\nFix the migration. If data moved somewhere the check can't follow (e.g. a field split in two), prove it with --check and rerun with --accept-loss <table.column>."}`
+                    : undefined,
+            });
+            if (!ok)
+                return { ok: false, steps, findings };
+        }
+        if (checkFile &&
+            !done(step("check", await run(process.execPath, ["-e", RUN_CHECKS, path.resolve(checkFile)], projectDir, (0, exports.pgliteEnv)(dataDir)))))
+            return { ok: false, steps, findings };
         const drift = await typeorm(projectDir, ["migration:generate", "./src/migrations/drift", "--check"], (0, exports.pgliteEnv)(dataDir));
-        return { ok: done(step("drift", drift)), steps };
+        return { ok: done(step("drift", drift)), steps, findings };
     }
     finally {
         fs.rmSync(dataDir, { recursive: true, force: true });
     }
 }
 exports.verifyMigration = verifyMigration;
+const ddlOf = (apsorcFile) => (0, ddl_1.schemaDdl)((0, apsorc_parser_1.parseApsorcV2)(JSON.parse(fs.readFileSync(apsorcFile).toString()))).join(";\n");
+/**
+ * verifyMigration for an Alembic or goose migration. Python and Go services
+ * have no TypeORM, so Apso's DDL writer builds the deployed schema, the
+ * migration's SQL runs as written, and drift is a catalog diff against a
+ * fresh build of the new .apsorc. down then runs and must give back the
+ * deployed schema.
+ */
+async function verifySqlMigration(projectDir, baselineApsorc, migrationFile, cliBin, { seedFile, checkFile, acceptLoss = [] }) {
+    const { PGlite } = await Promise.resolve().then(() => tslib_1.__importStar(require("@electric-sql/pglite")));
+    const steps = [];
+    const done = (s) => {
+        steps.push(s);
+        return s.ok;
+    };
+    let sql;
+    try {
+        sql = (0, migration_file_1.migrationSql)(migrationFile, fs.readFileSync(path.resolve(projectDir, migrationFile), "utf8"));
+    }
+    catch (error) {
+        done({ name: "read", ok: false, output: error.message });
+        return { ok: false, steps };
+    }
+    const findings = (0, review_1.reviewMigration)((0, migration_file_1.typeormMigration)("Migration", [sql.up], { down: [] }));
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
+    // The CLI's own PGlite: the project has no node_modules to load one from.
+    const cliRoot = path.dirname(path.dirname(cliBin));
+    const script = (name, code, arg) => run(process.execPath, ["-e", code, ...(arg ? [path.resolve(arg)] : [])], cliRoot, (0, exports.pgliteEnv)(dataDir)).then((r) => {
+        done(step(name, r));
+        return r;
+    });
+    const exec = async (name, statements) => {
+        const db = new PGlite(dataDir);
+        try {
+            await db.exec(statements);
+            return done({ name, ok: true });
+        }
+        catch (error) {
+            return done({ name, ok: false, output: error.message });
+        }
+        finally {
+            await db.close();
+        }
+    };
+    const drift = async (name, apsorcFile) => {
+        const db = new PGlite(dataDir);
+        const fresh = new PGlite();
+        try {
+            await fresh.exec(ddlOf(apsorcFile));
+            const diff = (0, catalog_1.catalogDiff)(await (0, catalog_1.readCatalog)(fresh), await (0, catalog_1.readCatalog)(db));
+            return done({
+                name,
+                ok: diff.length === 0,
+                output: diff.length > 0 ? `The database differs from ${path.basename(apsorcFile)} (- missing, + extra):\n${diff.join("\n")}` : undefined,
+            });
+        }
+        finally {
+            await db.close();
+            await fresh.close();
+        }
+    };
+    try {
+        if (!(await exec("baseline", ddlOf(baselineApsorc))))
+            return { ok: false, steps, findings };
+        const count = async (name, file) => {
+            const r = await script(name, COUNT_ROWS, file);
+            return r.ok ? JSON.parse(r.output.trim().split("\n").pop()) : undefined;
+        };
+        const before = seedFile ? await count("seed", seedFile) : undefined;
+        if (seedFile && !before)
+            return { ok: false, steps, findings };
+        if (!(await exec("migrate", sql.up)))
+            return { ok: false, steps, findings };
+        if (before) {
+            const after = await count("count");
+            if (!after)
+                return { ok: false, steps, findings };
+            const lost = dataLoss(before, after, sql.up);
+            const ok = (0, exports.unaccepted)(lost, acceptLoss).length === 0;
+            done({
+                name: "data",
+                ok,
+                output: lost.length > 0
+                    ? `The migration lost seeded data:\n${lost.join("\n")}${ok ? "" : "\nFix the migration. If data moved somewhere the check can't follow (e.g. a field split in two), prove it with --check and rerun with --accept-loss <table.column>."}`
+                    : undefined,
+            });
+            if (!ok)
+                return { ok: false, steps, findings };
+        }
+        const checked = checkFile ? await script("check", RUN_CHECKS, checkFile) : undefined;
+        if (checked && !checked.ok)
+            return { ok: false, steps, findings };
+        if (!(await drift("drift", path.join(projectDir, ".apsorc"))))
+            return { ok: false, steps, findings };
+        if (sql.down === undefined)
+            done({ name: "down", ok: true, output: "down refuses to run (irreversible), so it was not tested." });
+        else if (!(await exec("down", sql.down)) || !(await drift("down drift", baselineApsorc)))
+            return { ok: false, steps, findings };
+        return { ok: true, steps, findings };
+    }
+    finally {
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+}
 const freePort = () => new Promise((resolve, reject) => {
     const s = net.createServer();
     s.listen(0, () => {
@@ -492,6 +717,7 @@ const cliBinPath = (root) => path.join(root, "bin", "run");
 exports.cliBinPath = cliBinPath;
 /** Print a check's steps (or JSON) through the command's logger. */
 function report(log, result, json, summary) {
+    var _a;
     if (json) {
         log(JSON.stringify(result));
         return;
@@ -501,6 +727,8 @@ function report(log, result, json, summary) {
         if (s.output)
             log(s.output.replace(/^/gm, "     "));
     }
+    for (const f of (_a = result.findings) !== null && _a !== void 0 ? _a : [])
+        log(`WARN ${f.code}: ${f.message}`);
     if (summary)
         log(summary);
 }

package/dist/lib/verify/review.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Review a TypeORM-generated migration for statements that lose data or fail
+ * on a populated database. TypeORM changes a column type by DROP + ADD, casts
+ * enums without remapping removed values, and adds NOT NULL columns as if the
+ * table were empty. The generated file is kept; each finding names a
+ * statement to rewrite.
+ */
+export interface Finding {
+    code: string;
+    table: string;
+    column?: string;
+    message: string;
+}
+export declare function reviewMigration(source: string): Finding[];

package/dist/lib/verify/review.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Review a TypeORM-generated migration for statements that lose data or fail
+ * on a populated database. TypeORM changes a column type by DROP + ADD, casts
+ * enums without remapping removed values, and adds NOT NULL columns as if the
+ * table were empty. The generated file is kept; each finding names a
+ * statement to rewrite.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewMigration = void 0;
+/** The SQL of each queryRunner.query call in a method body. */
+const queries = (body) => [...body.matchAll(/queryRunner\.query\(\s*`([\S\s]*?)`/g)].map((m) => m[1]);
+const enumValues = (sql) => {
+    var _a, _b;
+    return new Set([...((_b = (_a = sql === null || sql === void 0 ? void 0 : sql.match(/ENUM\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "").matchAll(/'([^']*)'/g)].map((v) => v[1]));
+};
+const typeSql = (sqls, type) => sqls.find((s) => s.startsWith(`CREATE TYPE "public"."${type}" AS ENUM`));
+const list = (values) => values.map((v) => `"${v}"`).join(", ");
+function reviewMigration(source) {
+    var _a, _b, _c, _d, _e;
+    const [upBody, downBody = ""] = source.split(/public\s+async\s+down\s*\(/);
+    const up = queries(upBody);
+    const down = queries(downBody);
+    const findings = [];
+    const add = (code, table, column, message) => findings.push({ code, table, column, message });
+    // Statements on tables this migration creates touch no existing rows.
+    const created = new Set(up.map((q) => { var _a; return (_a = q.match(/^CREATE TABLE "([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1]; }).filter(Boolean));
+    const existing = (table) => !created.has(table);
+    // An UPDATE or INSERT before a statement that names the column means the
+    // migration already moves or backfills its data.
+    const handled = (i, col) => up.slice(0, i).some((q) => /^(UPDATE|INSERT)\b/.test(q) && q.includes(`"${col}"`));
+    const dropped = new Map();
+    const added = new Map();
+    for (const [i, q] of up.entries()) {
+        const d = q.match(/^ALTER TABLE "([^"]+)" DROP COLUMN "([^"]+)"/);
+        if (d && !handled(i, d[2]))
+            dropped.set(d[1], [...((_a = dropped.get(d[1])) !== null && _a !== void 0 ? _a : []), d[2]]);
+        const a = q.match(/^ALTER TABLE "([^"]+)" ADD "([^"]+)"/);
+        if (a)
+            added.set(a[1], [...((_b = added.get(a[1])) !== null && _b !== void 0 ? _b : []), a[2]]);
+    }
+    for (const [table, cols] of dropped) {
+        const adds = (_c = added.get(table)) !== null && _c !== void 0 ? _c : [];
+        const newCols = adds.filter((a) => !cols.includes(a));
+        for (const col of cols) {
+            if (adds.includes(col))
+                add("TYPE_CHANGE_DROPS_DATA", table, col, `${table}.${col}: TypeORM drops and re-adds the column to change its type, deleting every value. Replace the DROP and ADD with ALTER COLUMN "${col}" TYPE ... USING a cast that converts the existing values.`);
+            else if (newCols.length > 0)
+                add("POSSIBLE_RENAME", table, col, `${table}.${col} is dropped while ${list(newCols)} is added. If that is a rename, replace the DROP and ADD with RENAME COLUMN to keep the data; otherwise every value in "${col}" is deleted.`);
+            else
+                add("DROPS_COLUMN", table, col, created.size > 0
+                    ? `${table}.${col} is dropped with all its values while this migration creates ${list([...created])}. If the data moves there, copy it with INSERT ... SELECT before the DROP; otherwise confirm the loss.`
+                    : `${table}.${col} is dropped with all its values. Confirm the loss, or copy the data first.`);
+        }
+    }
+    for (const [i, q] of up.entries()) {
+        let m = q.match(/^DROP TABLE "([^"]+)"/);
+        if (m)
+            add("DROPS_TABLE", m[1], undefined, `Table ${m[1]} is dropped with all its rows. Confirm the loss, or rename the table if an entity was renamed.`);
+        m = q.match(/^ALTER TABLE "([^"]+)" ADD "([^"]+)" [^,]*\bNOT NULL\b(.*)$/);
+        if (m && existing(m[1])) {
+            const def = (_d = m[3].match(/DEFAULT (.+)$/)) === null || _d === void 0 ? void 0 : _d[1].trim();
+            if (def)
+                add("DEFAULT_BACKFILLS_ROWS", m[1], m[2], `${m[1]}.${m[2]} is added NOT NULL DEFAULT ${def}, so every existing row gets ${def}. Confirm that is right for existing rows, or add the column nullable, backfill it, then SET NOT NULL.`);
+            else
+                add("NOT_NULL_WITHOUT_BACKFILL", m[1], m[2], `${m[1]}.${m[2]} is added NOT NULL with no default, which fails if ${m[1]} has any rows. Add it nullable, backfill it, then SET NOT NULL.`);
+        }
+        m = q.match(/^ALTER TABLE "([^"]+)" ALTER COLUMN "([^"]+)" SET NOT NULL/);
+        if (m && existing(m[1]) && !handled(i, m[2]))
+            add("SET_NOT_NULL", m[1], m[2], `${m[1]}.${m[2]} becomes NOT NULL, which fails on any row where it is null. Backfill those rows first.`);
+        m = q.match(/^ALTER TABLE "([^"]+)" ALTER COLUMN "([^"]+)" TYPE (?!"public"\."[^"]+_enum")/);
+        if (m && existing(m[1]))
+            add("TYPE_CAST", m[1], m[2], `${m[1]}.${m[2]} changes type in place; a value the cast cannot convert fails the migration. Check the USING clause handles every existing value.`);
+        m =
+            (_e = q.match(/^CREATE UNIQUE INDEX "[^"]+" ON "([^"]+)" \(([^)]+)\)/)) !== null && _e !== void 0 ? _e : q.match(/^ALTER TABLE "([^"]+)" ADD CONSTRAINT "[^"]+" UNIQUE \(([^)]+)\)/);
+        if (m && existing(m[1]))
+            add("UNIQUE_ON_EXISTING_ROWS", m[1], m[2].replace(/"/g, ""), `A unique constraint on ${m[1]} (${m[2].replace(/"/g, "")}) fails if existing rows hold duplicates. Check for duplicates first and decide which row wins.`);
+        m = q.match(/^ALTER TABLE "([^"]+)" ADD CONSTRAINT "[^"]+" FOREIGN KEY \("([^"]+)"\) REFERENCES "([^"]+)"/);
+        if (m && existing(m[1]) && created.has(m[3]))
+            add("FOREIGN_KEY_TO_NEW_TABLE", m[1], m[2], `Existing ${m[1]} rows must point at ${m[3]}, which this migration creates empty, so the foreign key fails on any row with ${m[2]} set. If ${m[3]} replaces an existing entity, replace the CREATE TABLE with ALTER TABLE "<old table>" RENAME TO "${m[3]}" and ALTER SEQUENCE "<old table>_id_seq" RENAME TO "${m[3]}_id_seq"; TypeORM leaves the old table in place.`);
+    }
+    // TypeORM swaps an enum by renaming the old type to *_old, creating the new
+    // one and casting through text; down() recreates *_old with the old values.
+    for (const q of up) {
+        const m = q.match(/^ALTER TYPE "public"\."([^"]+)" RENAME TO "([^"]+_old)"/);
+        if (!m)
+            continue;
+        const now = enumValues(typeSql(up, m[1]));
+        const cast = up.find((s) => s.includes(`TYPE "public"."${m[1]}" USING`));
+        // A USING clause that names a removed value maps it; the rest still fail.
+        const removed = [...enumValues(typeSql(down, m[2]))].filter((v) => !now.has(v) && !(cast === null || cast === void 0 ? void 0 : cast.includes(`'${v}'`)));
+        const col = cast === null || cast === void 0 ? void 0 : cast.match(/^ALTER TABLE "([^"]+)" ALTER COLUMN "([^"]+)"/);
+        if (removed.length > 0 && col)
+            add("ENUM_VALUES_REMOVED", col[1], col[2], `${col[1]}.${col[2]} drops enum value ${removed.map((v) => `'${v}'`).join(", ")}; the cast fails on any row that still holds it. Map those rows to a remaining value in the USING clause, e.g. CASE "${col[2]}"::text WHEN '${removed[0]}' THEN '...' ELSE "${col[2]}"::text END.`);
+    }
+    return findings;
+}
+exports.reviewMigration = reviewMigration;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@apso/cli",
-  "version": "0.43.3",
+  "version": "0.44.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.43.3",
+      "version": "0.44.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@apso/schema-tools": "^0.2.0",