@apso/cli 0.43.4 → 0.44.0

package/dist/lib/plan/baseline.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baselineFile = exports.resolveBaseline = exports.latestPlannedMigration = exports.migrationExtension = exports.migrationsDir = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Find the deployed schema without being told. Every migration
+ * `apso migrate generate` writes is committed with its plan, and the plan
+ * records the schema before and after it, so the newest one says what the
+ * database looks like once the migrations run. A service whose migrations
+ * predate this falls back to the .apsorc from the last commit that touched
+ * its migrations.
+ */
+const child_process_1 = require("child_process");
+const fs = tslib_1.__importStar(require("fs"));
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+/** Where each language's migrations live, and the extension of one. */
+const migrationsDir = (projectDir, apsorc) => (apsorc === null || apsorc === void 0 ? void 0 : apsorc.language) === "python"
+    ? path.join(projectDir, "alembic", "versions")
+    : (apsorc === null || apsorc === void 0 ? void 0 : apsorc.language) === "go"
+        ? path.join(projectDir, "migrations")
+        : path.join(projectDir, (apsorc === null || apsorc === void 0 ? void 0 : apsorc.rootFolder) || "src", "migrations");
+exports.migrationsDir = migrationsDir;
+const migrationExtension = (apsorc) => (apsorc === null || apsorc === void 0 ? void 0 : apsorc.language) === "python"
+    ? ".py"
+    : (apsorc === null || apsorc === void 0 ? void 0 : apsorc.language) === "go"
+        ? ".sql"
+        : ".ts";
+exports.migrationExtension = migrationExtension;
+/** The newest migration with a saved plan, by its timestamp prefix. */
+function latestPlannedMigration(projectDir, apsorc) {
+    const dir = (0, exports.migrationsDir)(projectDir, apsorc);
+    if (!fs.existsSync(dir))
+        return undefined;
+    const plans = fs
+        .readdirSync(dir)
+        .filter((f) => /^\d+[_-].+\.plan\.json$/.test(f))
+        .sort((a, b) => Number(b.split(/[_-]/)[0]) - Number(a.split(/[_-]/)[0]));
+    for (const planFile of plans) {
+        const saved = JSON.parse(fs.readFileSync(path.join(dir, planFile)).toString());
+        if (!saved.before || !saved.after)
+            continue;
+        const file = planFile.replace(/\.plan\.json$/, (0, exports.migrationExtension)(apsorc));
+        return {
+            file: path.relative(projectDir, path.join(dir, file)),
+            planFile: path.relative(projectDir, path.join(dir, planFile)),
+            saved,
+        };
+    }
+    return undefined;
+}
+exports.latestPlannedMigration = latestPlannedMigration;
+const git = (cwd, args) => (0, child_process_1.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+});
+function resolveBaseline(projectDir, apsorc, explicit, planPath) {
+    if (explicit)
+        return {
+            schema: JSON.parse(fs.readFileSync(path.resolve(explicit)).toString()),
+            source: explicit,
+        };
+    // A plan in progress remembers the baseline it was started from.
+    if (planPath && fs.existsSync(planPath)) {
+        const working = JSON.parse(fs.readFileSync(planPath).toString());
+        if (working.before)
+            return {
+                schema: working.before,
+                source: path.relative(projectDir, planPath),
+            };
+    }
+    const latest = latestPlannedMigration(projectDir, apsorc);
+    if (latest)
+        return { schema: latest.saved.after, source: latest.planFile };
+    try {
+        const dir = path.relative(projectDir, (0, exports.migrationsDir)(projectDir, apsorc));
+        const sha = git(projectDir, ["log", "-1", "--format=%H", "--", dir]).trim();
+        if (sha) {
+            // "<sha>:./.apsorc" is relative to cwd, so symlinked paths don't matter.
+            const schema = JSON.parse(git(projectDir, ["show", `${sha}:./.apsorc`]));
+            return {
+                schema,
+                source: `.apsorc at ${sha.slice(0, 7)}, the last commit that changed ${dir}`,
+            };
+        }
+    }
+    catch {
+        // No git, no history for the migrations, or no .apsorc in that commit.
+    }
+    throw new Error("Can't tell which schema is deployed: no migration from apso migrate generate yet, and no git history for the migrations folder. Pass the deployed .apsorc once with --baseline; later runs find it on their own.");
+}
+exports.resolveBaseline = resolveBaseline;
+/** A baseline as a file, for steps that scaffold it into a project copy. */
+function baselineFile(baseline) {
+    const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "apso-baseline-")), ".apsorc");
+    fs.writeFileSync(file, JSON.stringify(baseline.schema, null, 2));
+    return file;
+}
+exports.baselineFile = baselineFile;

package/dist/lib/plan/index.d.ts

@@ -0,0 +1,52 @@
+interface PlanField {
+    name: string;
+    type: string;
+    values?: string[];
+    nullable?: boolean;
+    default?: string | null;
+}
+interface PlanEntity {
+    name: string;
+    fields?: PlanField[];
+}
+interface PlanRelationship {
+    from: string;
+    to: string;
+    type: string;
+}
+export interface PlanSchema {
+    entities: PlanEntity[];
+    relationships?: PlanRelationship[];
+}
+export type QuestionKind = "removedField" | "removedEntity" | "enumValue" | "backfill" | "cast" | "relation";
+export interface Question {
+    id: string;
+    kind: QuestionKind;
+    /** What changed, in words, for the agent and the person reading the plan. */
+    subject: string;
+    /** Allowed answers. "sql" and "split:..." also need `sql`. */
+    options: string[];
+    /** Set only when exactly one reading fits; still needs an answer. */
+    suggested?: string;
+    answer?: string;
+    /** A SQL expression, or one per target field for a split. */
+    sql?: string | Record<string, string>;
+}
+export interface Plan {
+    version: 1;
+    from: string;
+    to: string;
+    questions: Question[];
+}
+export declare const hashSchema: (s: PlanSchema) => string;
+/** Every answer this question will accept is valid; anything else stays open. */
+export declare function isAnswered(q: Question): boolean;
+export declare const openQuestions: (plan: Plan) => Question[];
+export declare function planMigration(before: PlanSchema, after: PlanSchema, previous?: Plan): Plan;
+/**
+ * Plan with --answer values (<question id>=<option>) applied on top of the
+ * plan in progress. Throws a message for the user when an answer is malformed,
+ * names no question, or is not one of its options.
+ */
+export declare function planWithAnswers(before: PlanSchema, after: PlanSchema, previous: Plan | undefined, answers: string[]): Plan;
+export {};

package/dist/lib/plan/index.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planWithAnswers = exports.planMigration = exports.openQuestions = exports.isAnswered = exports.hashSchema = void 0;
+/**
+ * The migration plan: compare the deployed .apsorc with the new one and list
+ * every change whose intent the schema alone can't settle (a removed field
+ * might be renamed, split, moved or dropped). Each becomes a question; the
+ * user's own agent answers it, and the answers are kept in the plan file so
+ * the same plan always renders the same migration.
+ *
+ * Question ids come from the change itself, so re-planning after another
+ * .apsorc edit keeps every answer whose question still exists.
+ */
+const crypto_1 = require("crypto");
+const field_1 = require("../utils/field");
+const hashSchema = (s) => {
+    var _a;
+    return "sha256:" +
+        (0, crypto_1.createHash)("sha256")
+            .update(JSON.stringify({
+            entities: s.entities,
+            relationships: (_a = s.relationships) !== null && _a !== void 0 ? _a : [],
+        }))
+            .digest("hex");
+};
+exports.hashSchema = hashSchema;
+const STRING_TYPES = new Set(["text", "varchar", "char", "string"]);
+const sameType = (a, b) => {
+    const ta = (0, field_1.normalizeFieldType)(a.type);
+    const tb = (0, field_1.normalizeFieldType)(b.type);
+    return ta === tb || (STRING_TYPES.has(ta) && STRING_TYPES.has(tb));
+};
+const fieldsOf = (e) => { var _a; return (_a = e === null || e === void 0 ? void 0 : e.fields) !== null && _a !== void 0 ? _a : []; };
+const byName = (list, name) => list.find((x) => x.name === name);
+const fieldSignature = (e) => fieldsOf(e)
+    .map((f) => `${f.name}:${(0, field_1.normalizeFieldType)(f.type)}`)
+    .sort()
+    .join(",");
+const relates = (rels, a, b) => rels.some((r) => (r.from === a && r.to === b) || (r.from === b && r.to === a));
+/** Every answer this question will accept is valid; anything else stays open. */
+function isAnswered(q) {
+    if (!q.answer || !q.options.includes(q.answer))
+        return false;
+    if (q.answer === "sql")
+        return typeof q.sql === "string" && q.sql.trim() !== "";
+    if (q.answer.startsWith("split:")) {
+        const targets = q.answer.slice("split:".length).split(",");
+        const sql = q.sql;
+        return (typeof sql === "object" &&
+            sql !== null &&
+            targets.every((t) => typeof sql[t] === "string" && sql[t].trim() !== ""));
+    }
+    return true;
+}
+exports.isAnswered = isAnswered;
+const openQuestions = (plan) => plan.questions.filter((q) => !isAnswered(q));
+exports.openQuestions = openQuestions;
+/** Added fields an answer already accounts for (a rename, split or move target). */
+function claimedTargets(questions) {
+    const claimed = new Set();
+    for (const q of questions) {
+        if (!q.answer)
+            continue;
+        const entity = q.id.slice(q.id.indexOf(":") + 1).split(".")[0];
+        if (q.answer.startsWith("rename:"))
+            claimed.add(`${entity}.${q.answer.slice(7)}`);
+        if (q.answer.startsWith("split:"))
+            for (const t of q.answer.slice(6).split(","))
+                claimed.add(`${entity}.${t}`);
+        if (q.answer.startsWith("move:"))
+            claimed.add(q.answer.slice(5));
+    }
+    return claimed;
+}
+/** Added fields some still-open question may yet claim. */
+function pendingTargets(questions) {
+    const pending = new Set();
+    for (const q of questions) {
+        if (q.answer || q.kind !== "removedField")
+            continue;
+        const entity = q.id.slice(q.id.indexOf(":") + 1).split(".")[0];
+        for (const o of q.options) {
+            if (o.startsWith("rename:"))
+                pending.add(`${entity}.${o.slice(7)}`);
+            if (o.startsWith("split:"))
+                for (const t of o.slice(6).split(","))
+                    pending.add(`${entity}.${t}`);
+            if (o.startsWith("move:"))
+                pending.add(o.slice(5));
+        }
+    }
+    return pending;
+}
+function planMigration(before, after, previous) {
+    var _a, _b, _c;
+    const questions = [];
+    const beforeRels = (_a = before.relationships) !== null && _a !== void 0 ? _a : [];
+    const afterRels = (_b = after.relationships) !== null && _b !== void 0 ? _b : [];
+    const added = after.entities.filter((e) => !byName(before.entities, e.name));
+    // Removed entities: rename to an added entity with the same fields, or drop.
+    for (const old of before.entities.filter((e) => !byName(after.entities, e.name))) {
+        const matches = added.filter((e) => fieldSignature(e) === fieldSignature(old));
+        questions.push({
+            id: `entity:${old.name}`,
+            kind: "removedEntity",
+            subject: `Entity ${old.name} is gone`,
+            options: [...matches.map((e) => `rename:${e.name}`), "drop"],
+            ...(matches.length === 1
+                ? { suggested: `rename:${matches[0].name}` }
+                : {}),
+        });
+    }
+    for (const now of after.entities) {
+        const was = byName(before.entities, now.name);
+        if (!was)
+            continue;
+        const addedFields = fieldsOf(now).filter((f) => !byName(fieldsOf(was), f.name));
+        for (const old of fieldsOf(was)) {
+            const cur = byName(fieldsOf(now), old.name);
+            if (!cur) {
+                // Removed field: rename, split, move to a new related entity, or drop.
+                const same = addedFields.filter((f) => sameType(f, old));
+                const moves = added
+                    .filter((e) => relates(afterRels, e.name, now.name))
+                    .flatMap((e) => fieldsOf(e)
+                    .filter((f) => sameType(f, old))
+                    .map((f) => `move:${e.name}.${f.name}`));
+                const options = [
+                    ...same.map((f) => `rename:${f.name}`),
+                    ...(same.length > 1
+                        ? [`split:${same.map((f) => f.name).join(",")}`]
+                        : []),
+                    ...moves,
+                    "drop",
+                ];
+                const readings = options.length - 1;
+                questions.push({
+                    id: `field:${now.name}.${old.name}`,
+                    kind: "removedField",
+                    subject: `Field ${now.name}.${old.name} (${old.type}) is gone`,
+                    options,
+                    ...(readings === 1 && same.length === 1
+                        ? { suggested: options[0] }
+                        : {}),
+                });
+                continue;
+            }
+            if (!sameType(cur, old)) {
+                questions.push({
+                    id: `cast:${now.name}.${old.name}`,
+                    kind: "cast",
+                    subject: `Field ${now.name}.${old.name} changes type from ${old.type} to ${cur.type}`,
+                    options: ["cast", "sql"],
+                });
+            }
+            else if (old.values && cur.values) {
+                for (const v of old.values.filter((v) => !cur.values.includes(v))) {
+                    questions.push({
+                        id: `enum:${now.name}.${old.name}:${v}`,
+                        kind: "enumValue",
+                        subject: `Enum value '${v}' is removed from ${now.name}.${old.name}`,
+                        options: [...cur.values],
+                    });
+                }
+            }
+            if (old.nullable && !cur.nullable && cur.default === undefined) {
+                questions.push({
+                    id: `backfill:${now.name}.${old.name}`,
+                    kind: "backfill",
+                    subject: `Field ${now.name}.${old.name} becomes required; rows where it is null need a value`,
+                    options: cur.values ? [...cur.values, "sql"] : ["sql"],
+                });
+            }
+        }
+    }
+    // Relationships between the same two entities that change kind or vanish.
+    for (const r of beforeRels.filter((r) => r.type === "ManyToOne")) {
+        if (!byName(after.entities, r.from) || !byName(after.entities, r.to))
+            continue;
+        const kept = afterRels.some((x) => x.type === "ManyToOne" && x.from === r.from && x.to === r.to);
+        if (kept)
+            continue;
+        const toMany = afterRels.some((x) => x.type === "ManyToMany" &&
+            ((x.from === r.from && x.to === r.to) ||
+                (x.from === r.to && x.to === r.from)));
+        questions.push({
+            id: `relation:${r.from}.${r.to}`,
+            kind: "relation",
+            subject: toMany
+                ? `${r.from} ManyToOne ${r.to} becomes ManyToMany`
+                : `${r.from} ManyToOne ${r.to} is removed`,
+            options: toMany ? ["copy-links", "drop-links"] : ["drop-links"],
+        });
+    }
+    // Carry answers over from the previous plan before deciding on backfills,
+    // which depend on what the removed-field answers claimed.
+    const prev = new Map(((_c = previous === null || previous === void 0 ? void 0 : previous.questions) !== null && _c !== void 0 ? _c : []).map((q) => [q.id, q]));
+    const carry = (q) => {
+        const p = prev.get(q.id);
+        if (!(p === null || p === void 0 ? void 0 : p.answer) || !q.options.includes(p.answer))
+            return q;
+        return {
+            ...q,
+            answer: p.answer,
+            ...(p.sql === undefined ? {} : { sql: p.sql }),
+        };
+    };
+    const answeredSoFar = questions.map((q) => carry(q));
+    // New required fields on existing tables need a value for existing rows,
+    // unless a rename, split or move fills them, or an open question still might.
+    const claimed = claimedTargets(answeredSoFar);
+    const pending = pendingTargets(answeredSoFar);
+    for (const now of after.entities) {
+        const was = byName(before.entities, now.name);
+        if (!was)
+            continue;
+        for (const f of fieldsOf(now)) {
+            if (byName(fieldsOf(was), f.name) ||
+                f.nullable ||
+                f.default !== undefined)
+                continue;
+            const key = `${now.name}.${f.name}`;
+            if (claimed.has(key) || pending.has(key))
+                continue;
+            answeredSoFar.push(carry({
+                id: `backfill:${key}`,
+                kind: "backfill",
+                subject: `New required field ${key} needs a value for existing rows`,
+                options: f.values ? [...f.values, "sql"] : ["sql"],
+            }));
+        }
+    }
+    return {
+        version: 1,
+        from: (0, exports.hashSchema)(before),
+        to: (0, exports.hashSchema)(after),
+        questions: answeredSoFar,
+    };
+}
+exports.planMigration = planMigration;
+/**
+ * Plan with --answer values (<question id>=<option>) applied on top of the
+ * plan in progress. Throws a message for the user when an answer is malformed,
+ * names no question, or is not one of its options.
+ */
+function planWithAnswers(before, after, previous, answers) {
+    const given = new Map();
+    for (const a of answers) {
+        const eq = a.indexOf("=");
+        if (eq < 1)
+            throw new Error(`--answer must be <question id>=<option>, got "${a}"`);
+        given.set(a.slice(0, eq), a.slice(eq + 1));
+    }
+    const seed = previous !== null && previous !== void 0 ? previous : { version: 1, from: "", to: "", questions: [] };
+    for (const [id, answer] of given) {
+        const q = seed.questions.find((x) => x.id === id);
+        if (q)
+            q.answer = answer;
+        else
+            seed.questions.push({ id, kind: "removedField", subject: "", options: [], answer });
+    }
+    const plan = planMigration(before, after, seed);
+    for (const [id, answer] of given) {
+        const q = plan.questions.find((x) => x.id === id);
+        if (!q)
+            throw new Error(`No question "${id}" in this plan.`);
+        if (!q.options.includes(answer))
+            throw new Error(`"${answer}" is not an option for ${id}. Options: ${q.options.join(", ")}`);
+    }
+    return plan;
+}
+exports.planWithAnswers = planWithAnswers;

package/dist/lib/plan/prompts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Words for asking a plan question in a terminal: what each option does to
+ * the data, a hint for SQL answers, and a starting rule for a two-way split.
+ */
+import { Question } from ".";
+export declare function optionLabel(q: Question, o: string): string;
+export declare function sqlHint(q: Question): string;
+/** A two-way split on the first space: "Ada Lovelace" -> Ada / Lovelace, "Cher" -> Cher / null. */
+export declare function splitDefaults(q: Question, targets: string[]): Record<string, string>;
+/**
+ * A question as an app or agent shows it: each option's words, a hint when an
+ * option needs SQL, and a starting rule for each two-way split option.
+ */
+export declare function describeQuestion(q: Question): Question & {
+    labels: Record<string, string>;
+    sqlHint?: string;
+    splitDefaults?: Record<string, Record<string, string>>;
+};

package/dist/lib/plan/prompts.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeQuestion = exports.splitDefaults = exports.sqlHint = exports.optionLabel = void 0;
+const after = (o, prefix) => o.slice(prefix.length);
+function optionLabel(q, o) {
+    let label = o;
+    switch (q.kind) {
+        case "removedField":
+            if (o.startsWith("rename:"))
+                label = `Renamed to ${after(o, "rename:")} (keeps the data)`;
+            else if (o.startsWith("split:"))
+                label = `Split into ${after(o, "split:").split(",").join(" and ")} (you give the rule)`;
+            else if (o.startsWith("move:"))
+                label = `Moved to ${after(o, "move:")} (copies the existing values)`;
+            else if (o === "drop")
+                label = "Dropped (deletes its data)";
+            break;
+        case "removedEntity":
+            if (o.startsWith("rename:"))
+                label = `Renamed to ${after(o, "rename:")} (keeps its rows)`;
+            else if (o === "drop")
+                label = "Dropped (deletes its rows)";
+            break;
+        case "enumValue":
+            label = `Change those rows to '${o}'`;
+            break;
+        case "backfill":
+            label = o === "sql" ? "Use a SQL expression" : `Set existing rows to '${o}'`;
+            break;
+        case "cast":
+            label = o === "sql" ? "Use a SQL expression to convert" : "Convert each value as it is (fails on values that don't convert)";
+            break;
+        case "relation":
+            label = o === "copy-links" ? "Copy each existing link into the new join table" : "Start with no links (deletes them)";
+            break;
+        default:
+            break;
+    }
+    return o === q.suggested ? `${label} (suggested)` : label;
+}
+exports.optionLabel = optionLabel;
+const fieldOf = (q) => { var _a, _b; return (_b = (_a = q.id.slice(q.id.indexOf(":") + 1).split(".")[1]) === null || _a === void 0 ? void 0 : _a.split(":")[0]) !== null && _b !== void 0 ? _b : ""; };
+function sqlHint(q) {
+    const f = fieldOf(q);
+    return q.kind === "cast"
+        ? `SQL that converts "${f}", e.g. NULLIF("${f}", '')::integer`
+        : `SQL for "${f}" on existing rows, e.g. 'unknown' or another column`;
+}
+exports.sqlHint = sqlHint;
+/** A two-way split on the first space: "Ada Lovelace" -> Ada / Lovelace, "Cher" -> Cher / null. */
+function splitDefaults(q, targets) {
+    if (targets.length !== 2)
+        return {};
+    const src = `"${fieldOf(q)}"`;
+    const first = `split_part(btrim(${src}), ' ', 1)`;
+    return {
+        [targets[0]]: first,
+        [targets[1]]: `NULLIF(btrim(substr(btrim(${src}), length(${first}) + 1)), '')`,
+    };
+}
+exports.splitDefaults = splitDefaults;
+/**
+ * A question as an app or agent shows it: each option's words, a hint when an
+ * option needs SQL, and a starting rule for each two-way split option.
+ */
+function describeQuestion(q) {
+    const splits = q.options.filter((o) => o.startsWith("split:"));
+    return {
+        ...q,
+        labels: Object.fromEntries(q.options.map((o) => [o, optionLabel(q, o)])),
+        ...(q.options.includes("sql") && { sqlHint: sqlHint(q) }),
+        ...(splits.length > 0 && {
+            splitDefaults: Object.fromEntries(splits.map((o) => [o, splitDefaults(q, after(o, "split:").split(","))])),
+        }),
+    };
+}
+exports.describeQuestion = describeQuestion;

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

@@ -1,7 +1,7 @@
 /**
  * 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.
  */
 /// <reference types="node" />
@@ -16,6 +16,7 @@
 import { Entity } from "../types/entity";
 import { TargetLanguage } from "../types/generator";
 import { RelationshipMap } from "../types/relationship";
+import { Finding } from "./review";
 export interface Step {
     name: string;
     ok: boolean;
@@ -33,30 +34,46 @@ export declare const pgliteEnv: (dataDir: string) => NodeJS.ProcessEnv;
  * it, and schema:sync.
  */
 export declare function buildBaseline(projectDir: string, baselineApsorc: string, dataDir: string, cliBin: string): Promise<Step>;
-/**
- * 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.
- */
-export declare const migrateUnsupported: (language?: TargetLanguage) => string | undefined;
 export interface GenerateResult {
     ok: boolean;
     needed: boolean;
     file?: string;
     steps: Step[];
+    /** Statements in the generated migration that lose data or fail on rows. */
+    findings?: Finding[];
 }
 /** Generate a migration from the deployed schema (baselineApsorc) to the project's entities. */
 export declare function generateMigration(projectDir: string, baselineApsorc: string, name: string, cliBin: string): Promise<GenerateResult>;
 export interface CheckResult {
     ok: boolean;
     steps: Step[];
+    findings?: Finding[];
 }
+type Counts = Record<string, {
+    rows: number;
+    values: Record<string, number>;
+    distinct?: Record<string, string[]>;
+}>;
+/**
+ * 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).
+ */
+export declare function dataLoss(before: Counts, after: Counts, source: string): string[];
+/** Losses the user accepted by name: a table, or table.column. */
+export declare const unaccepted: (lost: string[], accept: string[]) => string[];
 export declare function supportsPglite(projectDir: string): boolean;
 /**
  * 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).
  */
-export declare function verifyMigration(projectDir: string, baselineApsorc: string, migrationFile: string, cliBin: string, skipBuild?: boolean): Promise<CheckResult>;
+export declare function verifyMigration(projectDir: string, baselineApsorc: string, migrationFile: string, cliBin: string, { skipBuild, seedFile, checkFile, acceptLoss, }?: {
+    skipBuild?: boolean;
+    seedFile?: string;
+    checkFile?: string;
+    acceptLoss?: string[];
+}): Promise<CheckResult>;
 /** The route each language's generated controller serves an entity on. */
 export declare const entityRoute: (language: TargetLanguage, name: string) => string;
 export interface SmokeOptions {
@@ -77,3 +94,4 @@ export declare function readDotEnv(projectDir: string): Record<string, string>;
 export declare const cliBinPath: (root: string) => string;
 /** Print a check's steps (or JSON) through the command's logger. */
 export declare function report(log: (s: string) => void, result: CheckResult, json: boolean, summary?: string): void;
+export {};