@happyvertical/smrt-core 0.40.69 → 0.41.0

package/dist/migrations/minor-units.js

@@ -0,0 +1,381 @@
+import { detectEngine } from "../schema/ddl/index.js";
+import { BackfillTracker } from "./backfill-tracker.js";
+import { createLogger } from "@happyvertical/logger";
+//#region src/migrations/minor-units.ts
+/**
+* Money-column rescale: floating-point major units → integer minor units (#2401).
+*
+* SMRT's rule is that money is exact and is stored as **integer minor units**
+* (cents, satoshis) — `$19.99` is `1999`. Packages that predate the rule
+* declared their money fields `= 0.0`, which compiles to a floating-point
+* column holding *major* units. Flipping the declaration to `= 0` changes the
+* column type, and REAL→INTEGER is deliberately **not** one of the differ's
+* whitelisted upgrades: an automatic `ALTER … TYPE integer` would truncate
+* `19.99` to `19`, silently destroying 99 cents on every row.
+*
+* So the conversion is an explicit, opt-in migration with two halves:
+*
+*  1. {@link preflightMinorUnitsRescale} — read-only. Reports, per column,
+*     whether it still needs converting, and lists the rows that would lose
+*     information: values whose scaled form is not a whole number (a half-cent
+*     that has to be rounded away) and values that overflow PostgreSQL's `int4`
+*     once multiplied by the scale. Run it against a production snapshot and
+*     read the summary before converting anything.
+*  2. {@link rescaleMoneyColumnsToMinorUnits} — the conversion itself, guarded
+*     by a {@link BackfillTracker} marker so re-running it can never multiply a
+*     table by 100 twice.
+*
+* Per-engine behaviour:
+*
+* | Engine | Column type | Values |
+* | --- | --- | --- |
+* | PostgreSQL | `ALTER COLUMN … TYPE integer USING round(col * scale)` | converted by the cast |
+* | DuckDB | `ALTER COLUMN … TYPE INTEGER USING round(col * scale)` | converted by the cast |
+* | SQLite | **not changed here** — SQLite cannot alter a column's declared type in place | rescaled with an `UPDATE`, values become exact integers |
+*
+* SQLite's declared type only sets an affinity, so a rescaled column already
+* behaves as integer minor units; bringing the *declaration* into line needs
+* the table-rebuild path (#2370). The result flags that with
+* {@link MinorUnitsRescaleResult.declaredTypeChangePending} rather than
+* pretending the column type moved.
+*/
+var logger = createLogger({ level: "info" });
+/** PostgreSQL `int4` bounds — the ceiling this conversion has to respect. */
+var INT4_MIN = -2147483648;
+var INT4_MAX = 2147483647;
+/**
+* How far a scaled value may sit from a whole number and still count as
+* integral.
+*
+* `19.99 * 100` is `1998.9999999999998` in IEEE-754, so a zero tolerance would
+* report every ordinary two-decimal price as non-integral. A genuine half-cent
+* is off by `0.5`, five orders of magnitude above this bound, so the two cases
+* never blur.
+*/
+var INTEGRALITY_TOLERANCE = 1e-6;
+/** Default minor units per major unit — cents. */
+var DEFAULT_SCALE = 100;
+/**
+* Round half away from zero, the way SQL `round()` does — and the way
+* `Math.round` does not.
+*
+* `Math.round` rounds halves toward +∞, so `Math.round(-0.5)` is `-0` while
+* SQLite's and DuckDB's `round(-0.5)` is `-1`. Money here can legitimately be
+* negative (`BillingAdjustment.amount` is a signed credit), so a preflight that
+* predicted the conversion with `Math.round` would report a value one minor
+* unit above what the database actually stores. The PostgreSQL DDL casts to
+* `numeric` for the same reason — see {@link buildMinorUnitsStatements}.
+*/
+function roundHalfAwayFromZero(value) {
+	return Math.sign(value) * Math.round(Math.abs(value));
+}
+/**
+* A money-losing preflight finding blocked the conversion.
+*
+* Carries the full preflight so a caller can print the summary, fix the data,
+* and retry rather than re-deriving what went wrong.
+*/
+var MinorUnitsPreflightError = class extends Error {
+	preflight;
+	constructor(preflight) {
+		super(`Money minor-units rescale refused: ${preflight.nonIntegralRows} row(s) would be rounded and ${preflight.overflowRows} row(s) would overflow int4. Fix the data or pass \`force: true\` to accept the rounding.
+` + preflight.summary);
+		this.preflight = preflight;
+		this.name = "MinorUnitsPreflightError";
+	}
+};
+function resolveDatabaseUrl(db) {
+	const dbWithConfig = db;
+	return db.url || dbWithConfig.config?.url || "";
+}
+function resolveEngine(db, engineHint) {
+	return typeof db.exportTable === "function" ? "json" : detectEngine(resolveDatabaseUrl(db), engineHint);
+}
+/**
+* Quote an identifier for DDL.
+*
+* Table and column names here come from a package's own migration module, not
+* from user input, but a rejected embedded quote is cheaper than trusting that
+* forever.
+*/
+function quoteIdentifier(name) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error(`Money minor-units rescale: '${name}' is not a plain SQL identifier.`);
+	return `"${name}"`;
+}
+/** Is this declared type a floating-point one that still needs converting? */
+function isFloatingType(declaredType) {
+	return /^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(declaredType.trim());
+}
+/** Is this declared type already an integer one? */
+function isIntegerType(declaredType) {
+	return /^(INTEGER|INT|INT4|INT8|BIGINT|SMALLINT|TINYINT|HUGEINT)\b/i.test(declaredType.trim());
+}
+/**
+* Read declared column types for one table.
+*
+* PostgreSQL and DuckDB both expose `information_schema.columns`; SQLite does
+* not, so it uses `PRAGMA table_info`. Returns an empty map when the table does
+* not exist, which the caller reports as `missing` rather than an error — a
+* package's migration lists its own tables, and a deployment may legitimately
+* not have created all of them yet.
+*/
+async function readColumnTypes(db, engine, table) {
+	const types = /* @__PURE__ */ new Map();
+	try {
+		if (engine === "postgres" || engine === "duckdb") {
+			const result = await db.query("SELECT column_name, data_type FROM information_schema.columns WHERE table_name = ?", table);
+			for (const row of result.rows) if (row.column_name) types.set(row.column_name, row.data_type ?? "");
+			return types;
+		}
+		const result = await db.query(`PRAGMA table_info(${quoteIdentifier(table)})`);
+		for (const row of result.rows) if (row.name) types.set(row.name, row.type ?? "");
+	} catch (error) {
+		logger.debug(`[minor-units] Could not introspect ${table}; treating its columns as missing`, { error: error instanceof Error ? error.message : String(error) });
+	}
+	return types;
+}
+/** Does this table expose an `id` column we can name in problem rows? */
+function hasIdColumn(types) {
+	return types.has("id");
+}
+function toFiniteNumber(value) {
+	if (value == null) return null;
+	const parsed = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+/**
+* Inspect every non-null value in one floating-point money column.
+*
+* Rows are read rather than aggregated in SQL because the integrality test has
+* to survive three dialects' differing `round`/modulo semantics, and a money
+* table small enough to be worth converting by hand is small enough to scan.
+*/
+async function inspectColumn(db, table, column, scale, maxProblemRows, withId) {
+	const quotedTable = quoteIdentifier(table);
+	const quotedColumn = quoteIdentifier(column);
+	const selection = withId ? `"id", ${quotedColumn} AS value` : `${quotedColumn} AS value`;
+	const result = await db.query(`SELECT ${selection} FROM ${quotedTable} WHERE ${quotedColumn} IS NOT NULL`);
+	const nonIntegral = [];
+	const overflow = [];
+	let inspectedRows = 0;
+	for (const row of result.rows) {
+		const value = toFiniteNumber(row.value);
+		if (value === null) continue;
+		inspectedRows += 1;
+		const scaled = value * scale;
+		const rounded = roundHalfAwayFromZero(scaled);
+		const id = row.id == null ? null : String(row.id);
+		if (Math.abs(scaled - rounded) > INTEGRALITY_TOLERANCE) {
+			if (nonIntegral.length < maxProblemRows) nonIntegral.push({
+				id,
+				value,
+				scaled
+			});
+		}
+		if (rounded > INT4_MAX || rounded < INT4_MIN) {
+			if (overflow.length < maxProblemRows) overflow.push({
+				id,
+				value,
+				scaled
+			});
+		}
+	}
+	return {
+		inspectedRows,
+		nonIntegral,
+		overflow
+	};
+}
+function renderSummary(result) {
+	const lines = [
+		`Money minor-units preflight (engine=${result.engine}, scale=${result.scale})`,
+		`  columns: ${result.pendingColumns} pending, ${result.convertedColumns} already integer, ${result.missingColumns} missing`,
+		`  rows that would be rounded: ${result.nonIntegralRows}`,
+		`  rows that would overflow int4: ${result.overflowRows}`
+	];
+	for (const column of result.columns) {
+		const label = `${column.table}.${column.column}`;
+		if (column.state === "missing") {
+			lines.push(`  - ${label}: missing`);
+			continue;
+		}
+		if (column.state === "converted") {
+			lines.push(`  - ${label}: already integer (${column.declaredType ?? "unknown"})`);
+			continue;
+		}
+		lines.push(`  - ${label}: pending (${column.declaredType ?? "unknown"}), ${column.inspectedRows} row(s) inspected, ${column.nonIntegral.length} non-integral, ${column.overflow.length} overflow`);
+		for (const row of column.nonIntegral) lines.push(`      non-integral id=${row.id ?? "<no id>"} value=${row.value} scaled=${row.scaled}`);
+		for (const row of column.overflow) lines.push(`      overflow id=${row.id ?? "<no id>"} value=${row.value} scaled=${row.scaled}`);
+	}
+	return lines.join("\n");
+}
+/**
+* The statements that convert one column, for one engine.
+*
+* Exported so the emitted DDL can be asserted without a live PostgreSQL or
+* DuckDB connection; each owning package's `test:postgres` lane then proves the
+* same SQL runs against a real server.
+*
+* @param engine - `postgres`, `duckdb`, or anything SQLite-shaped.
+* @param table - Physical table name.
+* @param column - Physical column name.
+* @param scale - Minor units per major unit.
+* @returns Statements in execution order.
+*/
+function buildMinorUnitsStatements(engine, table, column, scale) {
+	const quotedTable = quoteIdentifier(table);
+	const quotedColumn = quoteIdentifier(column);
+	if (engine === "postgres" || engine === "duckdb") {
+		const scaled = engine === "postgres" ? `round((${quotedColumn})::numeric * ${scale})` : `round(${quotedColumn} * ${scale})`;
+		return [
+			`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} DROP DEFAULT`,
+			`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} TYPE INTEGER USING ${scaled}`,
+			`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} SET DEFAULT 0`
+		];
+	}
+	return [`UPDATE ${quotedTable} SET ${quotedColumn} = CAST(round(${quotedColumn} * ${scale}) AS INTEGER) WHERE ${quotedColumn} IS NOT NULL`];
+}
+/**
+* Report what {@link rescaleMoneyColumnsToMinorUnits} would do, without
+* writing anything.
+*
+* @param db - Root database handle.
+* @param targets - Tables and money columns owned by the calling package.
+* @param options - Scale, engine hint, problem-row cap.
+* @returns Per-column state plus the rows that would lose information.
+*/
+async function preflightMinorUnitsRescale(db, targets, options = {}) {
+	const scale = options.scale ?? DEFAULT_SCALE;
+	if (!Number.isInteger(scale) || scale <= 0) throw new Error(`Money minor-units rescale: scale must be a positive integer (got ${scale}).`);
+	const engine = resolveEngine(db, options.engineHint);
+	const maxProblemRows = options.maxProblemRows ?? 20;
+	for (const target of targets) {
+		quoteIdentifier(target.table);
+		for (const column of target.columns) quoteIdentifier(column);
+	}
+	const columns = [];
+	for (const target of targets) {
+		const types = await readColumnTypes(db, engine, target.table);
+		const withId = hasIdColumn(types);
+		for (const column of target.columns) {
+			const declaredType = types.get(column) ?? null;
+			if (declaredType === null) {
+				columns.push({
+					table: target.table,
+					column,
+					state: "missing",
+					declaredType: null,
+					inspectedRows: 0,
+					nonIntegral: [],
+					overflow: []
+				});
+				continue;
+			}
+			if (isIntegerType(declaredType) || !isFloatingType(declaredType)) {
+				columns.push({
+					table: target.table,
+					column,
+					state: "converted",
+					declaredType,
+					inspectedRows: 0,
+					nonIntegral: [],
+					overflow: []
+				});
+				continue;
+			}
+			const inspected = await inspectColumn(db, target.table, column, scale, maxProblemRows, withId);
+			columns.push({
+				table: target.table,
+				column,
+				state: "pending",
+				declaredType,
+				...inspected
+			});
+		}
+	}
+	const base = {
+		engine,
+		scale,
+		columns,
+		pendingColumns: columns.filter((c) => c.state === "pending").length,
+		convertedColumns: columns.filter((c) => c.state === "converted").length,
+		missingColumns: columns.filter((c) => c.state === "missing").length,
+		nonIntegralRows: columns.reduce((sum, c) => sum + c.nonIntegral.length, 0),
+		overflowRows: columns.reduce((sum, c) => sum + c.overflow.length, 0)
+	};
+	const ok = base.nonIntegralRows === 0 && base.overflowRows === 0;
+	return {
+		...base,
+		ok,
+		summary: renderSummary({
+			...base,
+			ok
+		})
+	};
+}
+/**
+* Convert floating-point major-unit money columns to integer minor units.
+*
+* Idempotent: the run is wrapped in a {@link BackfillTracker} marker, so a
+* second call is a no-op even on SQLite where the column type cannot record
+* that the conversion already happened.
+*
+* @param db - Root database handle (must support `query`).
+* @param targets - Tables and money columns owned by the calling package.
+* @param options - Marker name, scale, and whether to convert despite
+*   information-losing rows.
+* @throws {MinorUnitsPreflightError} when the preflight found rows that would
+*   be rounded or overflow and `force` was not set.
+*/
+async function rescaleMoneyColumnsToMinorUnits(db, targets, options) {
+	const scale = options.scale ?? DEFAULT_SCALE;
+	const engine = resolveEngine(db, options.engineHint);
+	const tracker = new BackfillTracker({ db });
+	if (await tracker.isApplied(options.backfillName)) return {
+		ran: false,
+		engine,
+		scale,
+		preflight: await preflightMinorUnitsRescale(db, targets, options),
+		rescaledColumns: [],
+		statements: [],
+		declaredTypeChangePending: []
+	};
+	const preflight = await preflightMinorUnitsRescale(db, targets, options);
+	if (!preflight.ok && !options.force) throw new MinorUnitsPreflightError(preflight);
+	const statements = [];
+	const rescaledColumns = [];
+	const declaredTypeChangePending = [];
+	const altersColumnType = engine === "postgres" || engine === "duckdb";
+	for (const report of preflight.columns) {
+		if (report.state !== "pending") continue;
+		for (const sql of buildMinorUnitsStatements(engine, report.table, report.column, scale)) {
+			await db.query(sql);
+			statements.push(sql);
+		}
+		if (!altersColumnType) declaredTypeChangePending.push({
+			table: report.table,
+			column: report.column
+		});
+		rescaledColumns.push({
+			table: report.table,
+			column: report.column
+		});
+	}
+	await tracker.recordApplied(options.backfillName, {
+		description: `Money columns rescaled from major units to integer minor units (scale ${scale}).`,
+		packageName: options.packageName
+	});
+	return {
+		ran: true,
+		engine,
+		scale,
+		preflight,
+		rescaledColumns,
+		statements,
+		declaredTypeChangePending
+	};
+}
+//#endregion
+export { MinorUnitsPreflightError, buildMinorUnitsStatements, preflightMinorUnitsRescale, rescaleMoneyColumnsToMinorUnits };
+
+//# sourceMappingURL=minor-units.js.map

package/dist/migrations/minor-units.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minor-units.js","names":[],"sources":["../../src/migrations/minor-units.ts"],"sourcesContent":["/**\n * Money-column rescale: floating-point major units → integer minor units (#2401).\n *\n * SMRT's rule is that money is exact and is stored as **integer minor units**\n * (cents, satoshis) — `$19.99` is `1999`. Packages that predate the rule\n * declared their money fields `= 0.0`, which compiles to a floating-point\n * column holding *major* units. Flipping the declaration to `= 0` changes the\n * column type, and REAL→INTEGER is deliberately **not** one of the differ's\n * whitelisted upgrades: an automatic `ALTER … TYPE integer` would truncate\n * `19.99` to `19`, silently destroying 99 cents on every row.\n *\n * So the conversion is an explicit, opt-in migration with two halves:\n *\n *  1. {@link preflightMinorUnitsRescale} — read-only. Reports, per column,\n *     whether it still needs converting, and lists the rows that would lose\n *     information: values whose scaled form is not a whole number (a half-cent\n *     that has to be rounded away) and values that overflow PostgreSQL's `int4`\n *     once multiplied by the scale. Run it against a production snapshot and\n *     read the summary before converting anything.\n *  2. {@link rescaleMoneyColumnsToMinorUnits} — the conversion itself, guarded\n *     by a {@link BackfillTracker} marker so re-running it can never multiply a\n *     table by 100 twice.\n *\n * Per-engine behaviour:\n *\n * | Engine | Column type | Values |\n * | --- | --- | --- |\n * | PostgreSQL | `ALTER COLUMN … TYPE integer USING round(col * scale)` | converted by the cast |\n * | DuckDB | `ALTER COLUMN … TYPE INTEGER USING round(col * scale)` | converted by the cast |\n * | SQLite | **not changed here** — SQLite cannot alter a column's declared type in place | rescaled with an `UPDATE`, values become exact integers |\n *\n * SQLite's declared type only sets an affinity, so a rescaled column already\n * behaves as integer minor units; bringing the *declaration* into line needs\n * the table-rebuild path (#2370). The result flags that with\n * {@link MinorUnitsRescaleResult.declaredTypeChangePending} rather than\n * pretending the column type moved.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport { detectEngine } from '../schema/ddl/index.js';\nimport { BackfillTracker } from './backfill-tracker.js';\nimport type { DatabaseInterface } from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/** PostgreSQL `int4` bounds — the ceiling this conversion has to respect. */\nconst INT4_MIN = -2147483648;\nconst INT4_MAX = 2147483647;\n\n/**\n * How far a scaled value may sit from a whole number and still count as\n * integral.\n *\n * `19.99 * 100` is `1998.9999999999998` in IEEE-754, so a zero tolerance would\n * report every ordinary two-decimal price as non-integral. A genuine half-cent\n * is off by `0.5`, five orders of magnitude above this bound, so the two cases\n * never blur.\n */\nconst INTEGRALITY_TOLERANCE = 1e-6;\n\n/** Default minor units per major unit — cents. */\nconst DEFAULT_SCALE = 100;\n\n/**\n * Round half away from zero, the way SQL `round()` does — and the way\n * `Math.round` does not.\n *\n * `Math.round` rounds halves toward +∞, so `Math.round(-0.5)` is `-0` while\n * SQLite's and DuckDB's `round(-0.5)` is `-1`. Money here can legitimately be\n * negative (`BillingAdjustment.amount` is a signed credit), so a preflight that\n * predicted the conversion with `Math.round` would report a value one minor\n * unit above what the database actually stores. The PostgreSQL DDL casts to\n * `numeric` for the same reason — see {@link buildMinorUnitsStatements}.\n */\nfunction roundHalfAwayFromZero(value: number): number {\n  return Math.sign(value) * Math.round(Math.abs(value));\n}\n\n/** A table and the money columns on it that must move to minor units. */\nexport interface MoneyColumnTarget {\n  /** Physical table name, e.g. `payments`. */\n  table: string;\n  /** Physical column names, e.g. `['amount', 'native_amount']`. */\n  columns: string[];\n}\n\n/** What the preflight found about one column. */\nexport type MinorUnitsColumnState =\n  /** Floating-point today: needs converting. */\n  | 'pending'\n  /** Already an integer column: nothing to do. */\n  | 'converted'\n  /** Table or column absent (package not installed, older schema). */\n  | 'missing';\n\n/** One row that cannot be converted without losing information. */\nexport interface MinorUnitsProblemRow {\n  /** Primary key, when the table has an `id` column. */\n  id: string | null;\n  /** The stored major-unit value. */\n  value: number;\n  /** `value * scale`, before rounding. */\n  scaled: number;\n}\n\n/** Preflight findings for a single column. */\nexport interface MinorUnitsColumnReport {\n  table: string;\n  column: string;\n  state: MinorUnitsColumnState;\n  /** Declared column type as the database reports it, when resolvable. */\n  declaredType: string | null;\n  /** Non-null values inspected. `0` unless `state` is `pending`. */\n  inspectedRows: number;\n  /** Values whose scaled form is not a whole number — rounding loses money. */\n  nonIntegral: MinorUnitsProblemRow[];\n  /** Values whose scaled form falls outside PostgreSQL `int4`. */\n  overflow: MinorUnitsProblemRow[];\n}\n\n/** Result of {@link preflightMinorUnitsRescale}. */\nexport interface MinorUnitsPreflightResult {\n  engine: string;\n  scale: number;\n  columns: MinorUnitsColumnReport[];\n  /** Columns still holding floating-point major units. */\n  pendingColumns: number;\n  /** Columns already integer. */\n  convertedColumns: number;\n  /** Columns whose table/column does not exist. */\n  missingColumns: number;\n  /** Total rows that would be rounded. */\n  nonIntegralRows: number;\n  /** Total rows that would overflow `int4`. */\n  overflowRows: number;\n  /** No row would lose information. */\n  ok: boolean;\n  /** Human-readable report, suitable for pasting into a migration log or PR. */\n  summary: string;\n}\n\n/** Options shared by the preflight and the rescale. */\nexport interface MinorUnitsOptions {\n  /** Minor units per major unit. Default `100` (cents). */\n  scale?: number;\n  /** Engine hint for adapters whose URL does not identify the engine. */\n  engineHint?: string;\n  /** Problem rows recorded per column before truncating. Default `20`. */\n  maxProblemRows?: number;\n}\n\n/** Options for {@link rescaleMoneyColumnsToMinorUnits}. */\nexport interface MinorUnitsRescaleOptions extends MinorUnitsOptions {\n  /**\n   * Stable marker name recorded in `_smrt_backfills`, e.g.\n   * `@happyvertical/smrt-commerce:money-minor-units:v1`.\n   *\n   * This is what makes the migration idempotent on SQLite, where the rescale\n   * is an `UPDATE` no column type can distinguish from an unconverted table.\n   */\n  backfillName: string;\n  /** Package recorded alongside the marker. */\n  packageName?: string;\n  /**\n   * Convert even when the preflight found rows that would be rounded or\n   * overflow. Off by default: silently rounding a half-cent away is exactly\n   * the failure this migration exists to prevent.\n   */\n  force?: boolean;\n}\n\n/** Result of {@link rescaleMoneyColumnsToMinorUnits}. */\nexport interface MinorUnitsRescaleResult {\n  /** `false` when the backfill marker was already present. */\n  ran: boolean;\n  engine: string;\n  scale: number;\n  /** The preflight that gated the run. */\n  preflight: MinorUnitsPreflightResult;\n  /** Columns whose values were rescaled. */\n  rescaledColumns: Array<{ table: string; column: string }>;\n  /** Statements executed, in order — useful for logs and tests. */\n  statements: string[];\n  /**\n   * Columns whose values are now minor units but whose *declared* type is\n   * still floating-point. Only ever populated on SQLite, which cannot alter a\n   * column type in place; clearing it needs the table-rebuild path (#2370).\n   */\n  declaredTypeChangePending: Array<{ table: string; column: string }>;\n}\n\n/**\n * A money-losing preflight finding blocked the conversion.\n *\n * Carries the full preflight so a caller can print the summary, fix the data,\n * and retry rather than re-deriving what went wrong.\n */\nexport class MinorUnitsPreflightError extends Error {\n  constructor(readonly preflight: MinorUnitsPreflightResult) {\n    super(\n      `Money minor-units rescale refused: ${preflight.nonIntegralRows} row(s) ` +\n        `would be rounded and ${preflight.overflowRows} row(s) would overflow ` +\n        'int4. Fix the data or pass `force: true` to accept the rounding.\\n' +\n        preflight.summary,\n    );\n    this.name = 'MinorUnitsPreflightError';\n  }\n}\n\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & { config?: { url?: string } };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\nfunction resolveEngine(db: DatabaseInterface, engineHint?: string): string {\n  return typeof (db as { exportTable?: unknown }).exportTable === 'function'\n    ? 'json'\n    : detectEngine(resolveDatabaseUrl(db), engineHint);\n}\n\n/**\n * Quote an identifier for DDL.\n *\n * Table and column names here come from a package's own migration module, not\n * from user input, but a rejected embedded quote is cheaper than trusting that\n * forever.\n */\nfunction quoteIdentifier(name: string): string {\n  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {\n    throw new Error(\n      `Money minor-units rescale: '${name}' is not a plain SQL identifier.`,\n    );\n  }\n  return `\"${name}\"`;\n}\n\n/** Is this declared type a floating-point one that still needs converting? */\nfunction isFloatingType(declaredType: string): boolean {\n  return /^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(\n    declaredType.trim(),\n  );\n}\n\n/** Is this declared type already an integer one? */\nfunction isIntegerType(declaredType: string): boolean {\n  return /^(INTEGER|INT|INT4|INT8|BIGINT|SMALLINT|TINYINT|HUGEINT)\\b/i.test(\n    declaredType.trim(),\n  );\n}\n\n/**\n * Read declared column types for one table.\n *\n * PostgreSQL and DuckDB both expose `information_schema.columns`; SQLite does\n * not, so it uses `PRAGMA table_info`. Returns an empty map when the table does\n * not exist, which the caller reports as `missing` rather than an error — a\n * package's migration lists its own tables, and a deployment may legitimately\n * not have created all of them yet.\n */\nasync function readColumnTypes(\n  db: DatabaseInterface,\n  engine: string,\n  table: string,\n): Promise<Map<string, string>> {\n  const types = new Map<string, string>();\n  try {\n    if (engine === 'postgres' || engine === 'duckdb') {\n      const result = await db.query(\n        'SELECT column_name, data_type FROM information_schema.columns WHERE table_name = ?',\n        table,\n      );\n      for (const row of result.rows as {\n        column_name?: string;\n        data_type?: string;\n      }[]) {\n        if (row.column_name) types.set(row.column_name, row.data_type ?? '');\n      }\n      return types;\n    }\n    // SQLite. `PRAGMA table_info` does not accept a bound parameter, and the\n    // identifier has already been validated by `quoteIdentifier`.\n    const result = await db.query(\n      `PRAGMA table_info(${quoteIdentifier(table)})`,\n    );\n    for (const row of result.rows as { name?: string; type?: string }[]) {\n      if (row.name) types.set(row.name, row.type ?? '');\n    }\n  } catch (error) {\n    logger.debug(\n      `[minor-units] Could not introspect ${table}; treating its columns as missing`,\n      { error: error instanceof Error ? error.message : String(error) },\n    );\n  }\n  return types;\n}\n\n/** Does this table expose an `id` column we can name in problem rows? */\nfunction hasIdColumn(types: Map<string, string>): boolean {\n  return types.has('id');\n}\n\nfunction toFiniteNumber(value: unknown): number | null {\n  if (value == null) return null;\n  const parsed = typeof value === 'number' ? value : Number(value);\n  return Number.isFinite(parsed) ? parsed : null;\n}\n\n/**\n * Inspect every non-null value in one floating-point money column.\n *\n * Rows are read rather than aggregated in SQL because the integrality test has\n * to survive three dialects' differing `round`/modulo semantics, and a money\n * table small enough to be worth converting by hand is small enough to scan.\n */\nasync function inspectColumn(\n  db: DatabaseInterface,\n  table: string,\n  column: string,\n  scale: number,\n  maxProblemRows: number,\n  withId: boolean,\n): Promise<{\n  inspectedRows: number;\n  nonIntegral: MinorUnitsProblemRow[];\n  overflow: MinorUnitsProblemRow[];\n}> {\n  const quotedTable = quoteIdentifier(table);\n  const quotedColumn = quoteIdentifier(column);\n  const selection = withId\n    ? `\"id\", ${quotedColumn} AS value`\n    : `${quotedColumn} AS value`;\n  const result = await db.query(\n    `SELECT ${selection} FROM ${quotedTable} WHERE ${quotedColumn} IS NOT NULL`,\n  );\n\n  const nonIntegral: MinorUnitsProblemRow[] = [];\n  const overflow: MinorUnitsProblemRow[] = [];\n  let inspectedRows = 0;\n\n  for (const row of result.rows as { id?: unknown; value?: unknown }[]) {\n    const value = toFiniteNumber(row.value);\n    if (value === null) continue;\n    inspectedRows += 1;\n    const scaled = value * scale;\n    const rounded = roundHalfAwayFromZero(scaled);\n    const id = row.id == null ? null : String(row.id);\n    if (Math.abs(scaled - rounded) > INTEGRALITY_TOLERANCE) {\n      if (nonIntegral.length < maxProblemRows) {\n        nonIntegral.push({ id, value, scaled });\n      }\n    }\n    if (rounded > INT4_MAX || rounded < INT4_MIN) {\n      if (overflow.length < maxProblemRows) {\n        overflow.push({ id, value, scaled });\n      }\n    }\n  }\n\n  return { inspectedRows, nonIntegral, overflow };\n}\n\nfunction renderSummary(result: Omit<MinorUnitsPreflightResult, 'summary'>) {\n  const lines: string[] = [\n    `Money minor-units preflight (engine=${result.engine}, scale=${result.scale})`,\n    `  columns: ${result.pendingColumns} pending, ${result.convertedColumns} already integer, ${result.missingColumns} missing`,\n    `  rows that would be rounded: ${result.nonIntegralRows}`,\n    `  rows that would overflow int4: ${result.overflowRows}`,\n  ];\n  for (const column of result.columns) {\n    const label = `${column.table}.${column.column}`;\n    if (column.state === 'missing') {\n      lines.push(`  - ${label}: missing`);\n      continue;\n    }\n    if (column.state === 'converted') {\n      lines.push(\n        `  - ${label}: already integer (${column.declaredType ?? 'unknown'})`,\n      );\n      continue;\n    }\n    lines.push(\n      `  - ${label}: pending (${column.declaredType ?? 'unknown'}), ` +\n        `${column.inspectedRows} row(s) inspected, ` +\n        `${column.nonIntegral.length} non-integral, ${column.overflow.length} overflow`,\n    );\n    for (const row of column.nonIntegral) {\n      lines.push(\n        `      non-integral id=${row.id ?? '<no id>'} value=${row.value} scaled=${row.scaled}`,\n      );\n    }\n    for (const row of column.overflow) {\n      lines.push(\n        `      overflow id=${row.id ?? '<no id>'} value=${row.value} scaled=${row.scaled}`,\n      );\n    }\n  }\n  return lines.join('\\n');\n}\n\n/**\n * The statements that convert one column, for one engine.\n *\n * Exported so the emitted DDL can be asserted without a live PostgreSQL or\n * DuckDB connection; each owning package's `test:postgres` lane then proves the\n * same SQL runs against a real server.\n *\n * @param engine - `postgres`, `duckdb`, or anything SQLite-shaped.\n * @param table - Physical table name.\n * @param column - Physical column name.\n * @param scale - Minor units per major unit.\n * @returns Statements in execution order.\n */\nexport function buildMinorUnitsStatements(\n  engine: string,\n  table: string,\n  column: string,\n  scale: number,\n): string[] {\n  const quotedTable = quoteIdentifier(table);\n  const quotedColumn = quoteIdentifier(column);\n  if (engine === 'postgres' || engine === 'duckdb') {\n    // PostgreSQL's `round(double precision)` is banker's rounding — it breaks\n    // ties to even, so `round(-0.5)` is `-0` and `round(2.5)` is `2`. Casting\n    // to `numeric` first selects the half-away-from-zero overload, which is\n    // what SQLite and DuckDB do and what the preflight predicts. Money can be\n    // negative here (a billing credit), so the tie-break is not academic.\n    const scaled =\n      engine === 'postgres'\n        ? `round((${quotedColumn})::numeric * ${scale})`\n        : `round(${quotedColumn} * ${scale})`;\n    // A `0.0` DEFAULT is not assignable to an integer column on PostgreSQL, so\n    // it is dropped before the type change and restored after it. `0` is the\n    // framework default for every money field.\n    return [\n      `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} DROP DEFAULT`,\n      `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} TYPE INTEGER ` +\n        `USING ${scaled}`,\n      `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} SET DEFAULT 0`,\n    ];\n  }\n  // SQLite: the declared type is only an affinity and cannot be altered in\n  // place, so rescale the values and leave the declaration to the table-rebuild\n  // path (#2370).\n  return [\n    `UPDATE ${quotedTable} SET ${quotedColumn} = CAST(round(${quotedColumn} * ${scale}) AS INTEGER) ` +\n      `WHERE ${quotedColumn} IS NOT NULL`,\n  ];\n}\n\n/**\n * Report what {@link rescaleMoneyColumnsToMinorUnits} would do, without\n * writing anything.\n *\n * @param db - Root database handle.\n * @param targets - Tables and money columns owned by the calling package.\n * @param options - Scale, engine hint, problem-row cap.\n * @returns Per-column state plus the rows that would lose information.\n */\nexport async function preflightMinorUnitsRescale(\n  db: DatabaseInterface,\n  targets: MoneyColumnTarget[],\n  options: MinorUnitsOptions = {},\n): Promise<MinorUnitsPreflightResult> {\n  const scale = options.scale ?? DEFAULT_SCALE;\n  if (!Number.isInteger(scale) || scale <= 0) {\n    throw new Error(\n      `Money minor-units rescale: scale must be a positive integer (got ${scale}).`,\n    );\n  }\n  const engine = resolveEngine(db, options.engineHint);\n  const maxProblemRows = options.maxProblemRows ?? 20;\n\n  // Validate every identifier up front. Introspection swallows errors so an\n  // absent table reads as `missing`, and a malformed name must not disappear\n  // down that same path — it is a bug in the caller's migration module.\n  for (const target of targets) {\n    quoteIdentifier(target.table);\n    for (const column of target.columns) quoteIdentifier(column);\n  }\n\n  const columns: MinorUnitsColumnReport[] = [];\n  for (const target of targets) {\n    const types = await readColumnTypes(db, engine, target.table);\n    const withId = hasIdColumn(types);\n    for (const column of target.columns) {\n      const declaredType = types.get(column) ?? null;\n      if (declaredType === null) {\n        columns.push({\n          table: target.table,\n          column,\n          state: 'missing',\n          declaredType: null,\n          inspectedRows: 0,\n          nonIntegral: [],\n          overflow: [],\n        });\n        continue;\n      }\n      if (isIntegerType(declaredType) || !isFloatingType(declaredType)) {\n        // Anything that is not floating-point is either already converted or a\n        // type this migration has no business rewriting.\n        columns.push({\n          table: target.table,\n          column,\n          state: 'converted',\n          declaredType,\n          inspectedRows: 0,\n          nonIntegral: [],\n          overflow: [],\n        });\n        continue;\n      }\n      const inspected = await inspectColumn(\n        db,\n        target.table,\n        column,\n        scale,\n        maxProblemRows,\n        withId,\n      );\n      columns.push({\n        table: target.table,\n        column,\n        state: 'pending',\n        declaredType,\n        ...inspected,\n      });\n    }\n  }\n\n  const base = {\n    engine,\n    scale,\n    columns,\n    pendingColumns: columns.filter((c) => c.state === 'pending').length,\n    convertedColumns: columns.filter((c) => c.state === 'converted').length,\n    missingColumns: columns.filter((c) => c.state === 'missing').length,\n    nonIntegralRows: columns.reduce((sum, c) => sum + c.nonIntegral.length, 0),\n    overflowRows: columns.reduce((sum, c) => sum + c.overflow.length, 0),\n  };\n  const ok = base.nonIntegralRows === 0 && base.overflowRows === 0;\n  return { ...base, ok, summary: renderSummary({ ...base, ok }) };\n}\n\n/**\n * Convert floating-point major-unit money columns to integer minor units.\n *\n * Idempotent: the run is wrapped in a {@link BackfillTracker} marker, so a\n * second call is a no-op even on SQLite where the column type cannot record\n * that the conversion already happened.\n *\n * @param db - Root database handle (must support `query`).\n * @param targets - Tables and money columns owned by the calling package.\n * @param options - Marker name, scale, and whether to convert despite\n *   information-losing rows.\n * @throws {MinorUnitsPreflightError} when the preflight found rows that would\n *   be rounded or overflow and `force` was not set.\n */\nexport async function rescaleMoneyColumnsToMinorUnits(\n  db: DatabaseInterface,\n  targets: MoneyColumnTarget[],\n  options: MinorUnitsRescaleOptions,\n): Promise<MinorUnitsRescaleResult> {\n  const scale = options.scale ?? DEFAULT_SCALE;\n  const engine = resolveEngine(db, options.engineHint);\n  const tracker = new BackfillTracker({ db });\n\n  if (await tracker.isApplied(options.backfillName)) {\n    return {\n      ran: false,\n      engine,\n      scale,\n      preflight: await preflightMinorUnitsRescale(db, targets, options),\n      rescaledColumns: [],\n      statements: [],\n      declaredTypeChangePending: [],\n    };\n  }\n\n  const preflight = await preflightMinorUnitsRescale(db, targets, options);\n  if (!preflight.ok && !options.force) {\n    throw new MinorUnitsPreflightError(preflight);\n  }\n\n  const statements: string[] = [];\n  const rescaledColumns: Array<{ table: string; column: string }> = [];\n  const declaredTypeChangePending: Array<{ table: string; column: string }> =\n    [];\n\n  const altersColumnType = engine === 'postgres' || engine === 'duckdb';\n  for (const report of preflight.columns) {\n    if (report.state !== 'pending') continue;\n    for (const sql of buildMinorUnitsStatements(\n      engine,\n      report.table,\n      report.column,\n      scale,\n    )) {\n      await db.query(sql);\n      statements.push(sql);\n    }\n    if (!altersColumnType) {\n      declaredTypeChangePending.push({\n        table: report.table,\n        column: report.column,\n      });\n    }\n    rescaledColumns.push({ table: report.table, column: report.column });\n  }\n\n  await tracker.recordApplied(options.backfillName, {\n    description:\n      `Money columns rescaled from major units to integer minor units ` +\n      `(scale ${scale}).`,\n    packageName: options.packageName,\n  });\n\n  return {\n    ran: true,\n    engine,\n    scale,\n    preflight,\n    rescaledColumns,\n    statements,\n    declaredTypeChangePending,\n  };\n}\n"],"mappings":"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"}

package/dist/migrations/orchestrate.js

@@ -164,12 +164,37 @@ function isCommentOnlySql(sql) {
 	return lines.every((line) => line.startsWith("--"));
 }
 /**
+* True if `sql` is an advisory comment that says *nothing needs to happen* —
+* as opposed to one that says a human has to act.
+*
+* The differ emits both kinds. "This SQLite column already stores JSON as
+* TEXT" and "#2370: this column is rebuilt together with its sibling" are
+* no-ops; "requires table recreation" / "blocked: …" are real manual drift.
+* Treating the first kind as drift makes a fully auto-repairable migration
+* report `hasManualDrift: true`.
+*
+* Keep in sync with `classifyTypeUpgradeSql`'s `noop` arm in
+* `@happyvertical/smrt-cli` (`src/commands/db-migrate-actions.ts`), which
+* applies the same rule on the CLI side.
+*/
+function isNoOpAdvisorySql(sql) {
+	const trimmed = sql.trim();
+	return /no change needed/i.test(trimmed) || /already stores .* as /i.test(trimmed);
+}
+/**
 * Surface changes the differ produced but that the migrator cannot apply
-* automatically — either `type_mismatch` entries (the differ explicitly
-* gives up on these) or `type_upgrade` entries whose generated SQL is
-* advisory-comment-only (SQLite table-recreation cases, etc.). Callers
-* use this to distinguish "schema is in sync" from "schema is drifted but
-* we can't fix it from here."
+* automatically — `type_mismatch` entries (the differ explicitly gives up on
+* these), `type_upgrade`/`alter_column` entries whose generated SQL is
+* advisory-comment-only (a SQLite rebuild that would be unsafe, an in-place
+* constraint change SQLite cannot perform), and warning-level report-only
+* advisories (an orphan NOT NULL column that will break inserts, a required
+* column that could not be enforced, a stale unique constraint, a relaxation
+* the caller has not opted into). Info-level advisories (a harmless orphan
+* column, a stale default) and comments that mean "already handled" (the
+* no-op advisories a table rebuild leaves on covered siblings, #2370) are
+* deliberately excluded so `hasManualDrift` keeps meaning "something needs
+* an operator". Callers use this to distinguish "schema is in sync" from
+* "schema is drifted but we can't fix it from here".
 */
 function collectUnactionableChanges(diff) {
 	const unactionable = [];
@@ -179,7 +204,11 @@ function collectUnactionableChanges(diff) {
 			continue;
 		}
 		const statements = change.sqlStatements ?? (change.sql ? [change.sql] : []);
-		if (statements.length > 0 && statements.every((stmt) => isCommentOnlySql(stmt.trim()))) unactionable.push(change);
+		if (statements.length === 0) {
+			if (change.advisory?.severity === "warning") unactionable.push(change);
+			continue;
+		}
+		if (statements.every((stmt) => isCommentOnlySql(stmt.trim())) && !statements.every((stmt) => isNoOpAdvisorySql(stmt))) unactionable.push(change);
 	}
 	return unactionable;
 }

package/dist/migrations/orchestrate.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrate.js","names":[],"sources":["../../src/migrations/orchestrate.ts"],"sourcesContent":["/**\n * High-level \"make my SMRT app's schema match its database\" orchestration.\n *\n * Wraps `ObjectRegistry.getAllSchemasAsDefinitions()` → `generateSchemaDiff`\n * → `MigrationTracker.applyAll`. Apps that just want to run pending\n * schema changes call `migrateSmrtSchemas({ db, packageName, version })`\n * and don't have to assemble the migration definition by hand.\n *\n * The migration name is timestamped, so re-running on an up-to-date\n * database is a no-op (the diff is empty, no statements are generated,\n * `applied: false` is returned).\n */\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport { ObjectRegistry } from '../registry.js';\nimport { detectEngine, getDDLStrategy } from '../schema/ddl/index.js';\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type { MigrationResult, SchemaChange } from '../schema/types.js';\nimport {\n  generateSchemaDiff,\n  getSQLFromDiff,\n  hasActionableChanges,\n} from './differ.js';\nimport {\n  createMigrationDefinition,\n  generateMigrationTimestamp,\n} from './generator.js';\nimport { MigrationTracker } from './tracker.js';\n\nexport interface MigrateSmrtSchemasOptions {\n  db: DatabaseInterface;\n  /** Stored on the migration record so the audit log shows which app applied it. */\n  packageName: string;\n  /**\n   * Stored on the migration record. Typically the app's package.json\n   * version. Optional because most apps don't have a runtime-readable\n   * version handy and would hardcode a stale string if forced to supply\n   * one — `'unknown'` is honest. Pass an explicit value when you can\n   * (e.g. `version: process.env.APP_VERSION`).\n   */\n  version?: string;\n  /** Override the description on the synthetic migration definition. */\n  description?: string;\n  /** Override the migration name (default: `<timestamp>_smrt_schema_sync`). */\n  name?: string;\n  /** Forwarded to MigrationTracker — defaults to true for pg-safe runs. */\n  postgresSafe?: boolean;\n  /** Forwarded to MigrationTracker — defaults to true. */\n  reconcile?: boolean;\n  /** Forwarded to MigrationTracker — defaults to true for `CREATE INDEX CONCURRENTLY`. */\n  useConcurrentIndexes?: boolean;\n  /**\n   * Forwarded to MigrationTracker (Postgres lock timeout, milliseconds).\n   * Lets apps that customize tracker timeouts directly preserve their\n   * tuning when going through the orchestrator. Falls back to the\n   * tracker's default (30000ms) when omitted.\n   */\n  lockTimeout?: number;\n  /**\n   * Forwarded to MigrationTracker (Postgres statement timeout, ms). Falls\n   * back to the tracker's default (60000ms) when omitted.\n   */\n  statementTimeout?: number;\n  /**\n   * Explicit engine hint forwarded to `detectEngine`, `SchemaComparer`, and\n   * `MigrationTracker`. Useful when `db.url` doesn't unambiguously identify\n   * the engine (e.g. the JSON adapter, which uses DuckDB internally and may\n   * not be recognizable by URL alone). All three layers honor the same hint\n   * so the generated DDL, drift comparison, and execution path stay\n   * consistent — without it, an empty-URL connection could produce\n   * Postgres-flavored DDL but run through the SQLite tracker path.\n   *\n   * Typed as `DatabaseEngine` so unsupported values (e.g. `'mysql'`) fail at\n   * compile time rather than silently falling back to `'sqlite'` at runtime.\n   */\n  engineHint?: DatabaseEngine;\n  /**\n   * Confirm that historical PostgreSQL Date writers used UTC wall times before\n   * reinterpreting legacy TIMESTAMP/TEXT/JSON columns as TIMESTAMPTZ.\n   */\n  postgresTimestampMigration?: { legacyTimezone: 'UTC' };\n}\n\nexport interface MigrateSmrtSchemasResult {\n  applied: boolean;\n  results: MigrationResult[];\n  statements: string[];\n  schemaCount: number;\n  /**\n   * Schema changes the orchestrator detected but cannot apply automatically\n   * (incompatible type mismatches, SQLite type upgrades that require table\n   * recreation, etc.). Empty when the schema is fully reconciled. Inspect\n   * this to surface a \"manual migration required\" warning in CLI output.\n   */\n  unactionableChanges: SchemaChange[];\n  /**\n   * Convenience: `unactionableChanges.length > 0`. Lets a caller write\n   * `if (result.hasManualDrift) ...` without iterating the array first,\n   * and makes the case visible to anyone scanning the result shape (the\n   * full array is easy to gloss over when `applied: false`).\n   */\n  hasManualDrift: boolean;\n}\n\nexport interface PendingSchemaStatementsResult {\n  diff: Awaited<ReturnType<typeof generateSchemaDiff>>;\n  statements: string[];\n  schemaCount: number;\n  hasChanges: boolean;\n  /**\n   * Schema changes the differ detected but that have no executable SQL\n   * (incompatible `type_mismatch` entries, or `type_upgrade` entries whose\n   * only generated SQL is an advisory comment because the engine cannot\n   * upgrade the column in place — e.g. SQLite type widening). Surfacing\n   * these lets status commands distinguish \"no drift\" from \"drift the\n   * orchestrator can't fix on its own.\"\n   */\n  unactionableChanges: SchemaChange[];\n  /**\n   * Convenience: `unactionableChanges.length > 0`. Mirrors the\n   * `MigrateSmrtSchemasResult.hasManualDrift` shortcut.\n   */\n  hasManualDrift: boolean;\n}\n\n/**\n * Compute the SQL statements needed to bring `db` in sync with the\n * currently-registered SMRT object schemas. Pure inspection — no writes.\n *\n * Useful for status commands (\"how far behind is the schema?\") and as the\n * inner step of `migrateSmrtSchemas`.\n *\n * **Note on the returned `statements`:** these are the engine-correct DDL\n * statements as the differ + DDL strategy produce them, *prior to* any\n * Postgres-specific rewrites the `MigrationTracker` applies at execution\n * time (e.g. rewriting `CREATE INDEX` → `CREATE INDEX CONCURRENTLY` and\n * moving CONCURRENTLY statements outside the surrounding transaction).\n * The list is suitable for preview/status/\"what would change?\" use cases.\n * For the exact byte-for-byte SQL the tracker ran, inspect the\n * `MigrationResult`s from `migrateSmrtSchemas` or the tracker's own logs.\n */\nexport async function getPendingSchemaStatements(\n  db: DatabaseInterface,\n  options: {\n    engineHint?: DatabaseEngine;\n    postgresTimestampMigration?: { legacyTimezone: 'UTC' };\n  } = {},\n): Promise<PendingSchemaStatementsResult> {\n  const schemas = ObjectRegistry.getAllSchemasAsDefinitions();\n  // Forward engineHint into the diff itself so the SchemaComparer's\n  // existing-table SQL (ALTER/index drift) uses the same DDL strategy\n  // we use for newly-added tables — otherwise the two halves of the\n  // statement list can land on different engines (split-brain) when\n  // `db.url` is empty or ambiguous.\n  const diff = await generateSchemaDiff(db, schemas, {\n    engineHint: options.engineHint,\n    postgresTimestampMigration: options.postgresTimestampMigration,\n  });\n  const statements = collectStatementsFromDiff(diff, db, options.engineHint);\n  const unactionableChanges = collectUnactionableChanges(diff);\n  return {\n    diff,\n    schemaCount: Object.keys(schemas).length,\n    statements,\n    hasChanges: hasActionableChanges(diff),\n    unactionableChanges,\n    hasManualDrift: unactionableChanges.length > 0,\n  };\n}\n\n/**\n * Apply any pending schema changes from `ObjectRegistry` to `db`.\n *\n * Returns `applied: false` (with no error) if the database is already in\n * sync. Throws on the first migration failure with the underlying error\n * preserved (callers should let it propagate to the CLI).\n *\n * **Note on the returned `statements`:** mirrors `getPendingSchemaStatements`\n * — the list is the planned DDL, prior to Postgres-specific tracker rewrites\n * (CONCURRENTLY, transaction reordering). The actual executed SQL is\n * tracked in the returned `results`.\n *\n * **Note on `applied` semantics under `reconcile: true` (the default):**\n * the tracker may re-execute a migration that is already in `completed`\n * state when the checksum matches — that counts as `applied: true` in the\n * returned `MigrationResult`. So `result.applied === true` means \"the\n * tracker ran the migration\", not specifically \"the database changed for\n * the first time.\" Pass `reconcile: false` if you need to distinguish a\n * fresh apply from a reconcile-replay over an existing completed record.\n *\n * **Note on repeated failures:** the migration name defaults to a fresh\n * timestamp on every call, so a sequence of failed runs leaves one\n * `failed` row in `_smrt_schema_migrations` per attempt. Pass an explicit\n * `name` if you want to overwrite the same record across retries.\n *\n * **Note on `unactionableChanges`:** the differ can detect schema drift\n * the migration step can't auto-resolve — incompatible type mismatches,\n * SQLite type widening that needs table recreation, etc. Those changes\n * appear in `result.unactionableChanges` and are NOT applied (the\n * statements list is filtered to executable DDL only). When the diff\n * contains *only* unactionable changes, the function returns\n * `applied: false` with a populated `unactionableChanges` so callers can\n * surface a \"manual migration required\" signal. Without inspecting that\n * field, the result would look indistinguishable from \"already in sync.\"\n */\nexport async function migrateSmrtSchemas(\n  options: MigrateSmrtSchemasOptions,\n): Promise<MigrateSmrtSchemasResult> {\n  const pending = await getPendingSchemaStatements(options.db, {\n    engineHint: options.engineHint,\n    postgresTimestampMigration: options.postgresTimestampMigration,\n  });\n  if (!pending.hasChanges || pending.statements.length === 0) {\n    return {\n      applied: false,\n      results: [],\n      statements: [],\n      schemaCount: pending.schemaCount,\n      unactionableChanges: pending.unactionableChanges,\n      hasManualDrift: pending.hasManualDrift,\n    };\n  }\n\n  const tracker = new MigrationTracker({\n    db: options.db,\n    engineHint: options.engineHint,\n    lockTimeout: options.lockTimeout,\n    statementTimeout: options.statementTimeout,\n    useConcurrentIndexes: options.useConcurrentIndexes ?? true,\n  });\n  const migration = createMigrationDefinition(\n    options.name ?? `${generateMigrationTimestamp()}_smrt_schema_sync`,\n    pending.statements,\n    [],\n    {\n      description: options.description ?? 'Synchronize SMRT object schemas',\n      packageName: options.packageName,\n      version: options.version ?? 'unknown',\n    },\n  );\n\n  const results = await tracker.applyAll([migration], {\n    postgresSafe: options.postgresSafe ?? true,\n    reconcile: options.reconcile ?? true,\n  });\n\n  const failed = results.find((result) => !result.success);\n  if (failed) {\n    throw failed.error instanceof Error\n      ? failed.error\n      : new Error(String(failed.error ?? `Migration ${failed.name} failed`));\n  }\n\n  const applied = results.some(\n    (result) => result.applied !== false && result.skipped !== true,\n  );\n\n  return {\n    applied,\n    results,\n    statements: pending.statements,\n    schemaCount: pending.schemaCount,\n    unactionableChanges: pending.unactionableChanges,\n    hasManualDrift: pending.hasManualDrift,\n  };\n}\n\n/** Mirror of the `getDatabaseUrl` helper in class.ts — some adapters\n * (JSON, certain in-memory wrappers) leave `db.url` undefined and expose\n * the URL on `db.config?.url` instead. Detecting the engine from a raw\n * `db.url` would throw or silently fall through to the sqlite default.\n */\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & {\n    config?: { url?: string };\n  };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\n/**\n * Materialize the diff into the engine-correct SQL statements.\n *\n * For new tables we delegate to the engine's `DDLStrategy` so column types\n * (`REAL` → `DOUBLE PRECISION` on Postgres, `JSON` → `JSONB`, etc.),\n * partial-index `WHERE` clauses, and trigger syntax all match what the\n * SchemaComparer would expect on subsequent runs. Emitting the raw\n * abstract `SchemaDefinition.ddl` here would cause immediate type-drift\n * migrations on Postgres/DuckDB.\n *\n * Column/index/trigger changes for existing tables continue to come from\n * `getSQLFromDiff`, which is already engine-aware via the differ's per-\n * change `sqlStatements`.\n */\nfunction collectStatementsFromDiff(\n  diff: Awaited<ReturnType<typeof generateSchemaDiff>>,\n  db: DatabaseInterface,\n  engineHint?: DatabaseEngine,\n): string[] {\n  const strategy = getDDLStrategy(\n    detectEngine(resolveDatabaseUrl(db), engineHint),\n  );\n  const statements: string[] = [];\n  for (const schema of diff.added_tables) {\n    statements.push(strategy.generateCreateTable(schema));\n    statements.push(...strategy.generateIndexes(schema));\n    statements.push(...strategy.generateTriggers(schema));\n  }\n  statements.push(...getSQLFromDiff(diff));\n  // Drop empty and comment-only entries. SQLite type-widening upgrades\n  // surface as `-- SQLite: Type upgrade for X requires table recreation`\n  // — passing those through to the tracker records a successful migration\n  // without actually fixing the column, so the same drift re-appears on\n  // every subsequent run. Those changes are surfaced separately via\n  // `unactionableChanges` so callers can prompt for manual remediation.\n  return statements.filter((statement) => {\n    const trimmed = statement.trim();\n    if (trimmed.length === 0) return false;\n    return !isCommentOnlySql(trimmed);\n  });\n}\n\n/**\n * True if `sql` contains no executable DDL — only line comments (`--`)\n * and/or block comments (`/* … *​/`). Used to discard advisory comments\n * the differ emits when a column upgrade can't be performed in place\n * (e.g. SQLite type widening). Defensive: strips block comments first so\n * a future differ that emits `/* type_upgrade: no-op *​/` doesn't slip\n * through.\n */\nfunction isCommentOnlySql(sql: string): boolean {\n  // Strip /* ... */ block comments (non-greedy, spans newlines).\n  const withoutBlockComments = sql.replace(/\\/\\*[\\s\\S]*?\\*\\//g, '');\n  const lines = withoutBlockComments\n    .split('\\n')\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0);\n  if (lines.length === 0) return sql.trim().length > 0;\n  return lines.every((line) => line.startsWith('--'));\n}\n\n/**\n * Surface changes the differ produced but that the migrator cannot apply\n * automatically — either `type_mismatch` entries (the differ explicitly\n * gives up on these) or `type_upgrade` entries whose generated SQL is\n * advisory-comment-only (SQLite table-recreation cases, etc.). Callers\n * use this to distinguish \"schema is in sync\" from \"schema is drifted but\n * we can't fix it from here.\"\n */\nfunction collectUnactionableChanges(\n  diff: Awaited<ReturnType<typeof generateSchemaDiff>>,\n): SchemaChange[] {\n  const unactionable: SchemaChange[] = [];\n  for (const change of diff.changes) {\n    if (change.type === 'type_mismatch') {\n      unactionable.push(change);\n      continue;\n    }\n    const statements = change.sqlStatements ?? (change.sql ? [change.sql] : []);\n    if (\n      statements.length > 0 &&\n      statements.every((stmt) => isCommentOnlySql(stmt.trim()))\n    ) {\n      unactionable.push(change);\n    }\n  }\n  return unactionable;\n}\n"],"mappings":"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"}
+{"version":3,"file":"orchestrate.js","names":[],"sources":["../../src/migrations/orchestrate.ts"],"sourcesContent":["/**\n * High-level \"make my SMRT app's schema match its database\" orchestration.\n *\n * Wraps `ObjectRegistry.getAllSchemasAsDefinitions()` → `generateSchemaDiff`\n * → `MigrationTracker.applyAll`. Apps that just want to run pending\n * schema changes call `migrateSmrtSchemas({ db, packageName, version })`\n * and don't have to assemble the migration definition by hand.\n *\n * The migration name is timestamped, so re-running on an up-to-date\n * database is a no-op (the diff is empty, no statements are generated,\n * `applied: false` is returned).\n */\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport { ObjectRegistry } from '../registry.js';\nimport { detectEngine, getDDLStrategy } from '../schema/ddl/index.js';\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type { MigrationResult, SchemaChange } from '../schema/types.js';\nimport {\n  generateSchemaDiff,\n  getSQLFromDiff,\n  hasActionableChanges,\n} from './differ.js';\nimport {\n  createMigrationDefinition,\n  generateMigrationTimestamp,\n} from './generator.js';\nimport { MigrationTracker } from './tracker.js';\n\nexport interface MigrateSmrtSchemasOptions {\n  db: DatabaseInterface;\n  /** Stored on the migration record so the audit log shows which app applied it. */\n  packageName: string;\n  /**\n   * Stored on the migration record. Typically the app's package.json\n   * version. Optional because most apps don't have a runtime-readable\n   * version handy and would hardcode a stale string if forced to supply\n   * one — `'unknown'` is honest. Pass an explicit value when you can\n   * (e.g. `version: process.env.APP_VERSION`).\n   */\n  version?: string;\n  /** Override the description on the synthetic migration definition. */\n  description?: string;\n  /** Override the migration name (default: `<timestamp>_smrt_schema_sync`). */\n  name?: string;\n  /** Forwarded to MigrationTracker — defaults to true for pg-safe runs. */\n  postgresSafe?: boolean;\n  /** Forwarded to MigrationTracker — defaults to true. */\n  reconcile?: boolean;\n  /** Forwarded to MigrationTracker — defaults to true for `CREATE INDEX CONCURRENTLY`. */\n  useConcurrentIndexes?: boolean;\n  /**\n   * Forwarded to MigrationTracker (Postgres lock timeout, milliseconds).\n   * Lets apps that customize tracker timeouts directly preserve their\n   * tuning when going through the orchestrator. Falls back to the\n   * tracker's default (30000ms) when omitted.\n   */\n  lockTimeout?: number;\n  /**\n   * Forwarded to MigrationTracker (Postgres statement timeout, ms). Falls\n   * back to the tracker's default (60000ms) when omitted.\n   */\n  statementTimeout?: number;\n  /**\n   * Explicit engine hint forwarded to `detectEngine`, `SchemaComparer`, and\n   * `MigrationTracker`. Useful when `db.url` doesn't unambiguously identify\n   * the engine (e.g. the JSON adapter, which uses DuckDB internally and may\n   * not be recognizable by URL alone). All three layers honor the same hint\n   * so the generated DDL, drift comparison, and execution path stay\n   * consistent — without it, an empty-URL connection could produce\n   * Postgres-flavored DDL but run through the SQLite tracker path.\n   *\n   * Typed as `DatabaseEngine` so unsupported values (e.g. `'mysql'`) fail at\n   * compile time rather than silently falling back to `'sqlite'` at runtime.\n   */\n  engineHint?: DatabaseEngine;\n  /**\n   * Confirm that historical PostgreSQL Date writers used UTC wall times before\n   * reinterpreting legacy TIMESTAMP/TEXT/JSON columns as TIMESTAMPTZ.\n   */\n  postgresTimestampMigration?: { legacyTimezone: 'UTC' };\n}\n\nexport interface MigrateSmrtSchemasResult {\n  applied: boolean;\n  results: MigrationResult[];\n  statements: string[];\n  schemaCount: number;\n  /**\n   * Schema changes the orchestrator detected but cannot apply automatically\n   * (incompatible type mismatches, SQLite type upgrades that require table\n   * recreation, etc.). Empty when the schema is fully reconciled. Inspect\n   * this to surface a \"manual migration required\" warning in CLI output.\n   */\n  unactionableChanges: SchemaChange[];\n  /**\n   * Convenience: `unactionableChanges.length > 0`. Lets a caller write\n   * `if (result.hasManualDrift) ...` without iterating the array first,\n   * and makes the case visible to anyone scanning the result shape (the\n   * full array is easy to gloss over when `applied: false`).\n   */\n  hasManualDrift: boolean;\n}\n\nexport interface PendingSchemaStatementsResult {\n  diff: Awaited<ReturnType<typeof generateSchemaDiff>>;\n  statements: string[];\n  schemaCount: number;\n  hasChanges: boolean;\n  /**\n   * Schema changes the differ detected but that have no executable SQL\n   * (incompatible `type_mismatch` entries, or `type_upgrade` entries whose\n   * only generated SQL is an advisory comment because the engine cannot\n   * upgrade the column in place — e.g. SQLite type widening). Surfacing\n   * these lets status commands distinguish \"no drift\" from \"drift the\n   * orchestrator can't fix on its own.\"\n   */\n  unactionableChanges: SchemaChange[];\n  /**\n   * Convenience: `unactionableChanges.length > 0`. Mirrors the\n   * `MigrateSmrtSchemasResult.hasManualDrift` shortcut.\n   */\n  hasManualDrift: boolean;\n}\n\n/**\n * Compute the SQL statements needed to bring `db` in sync with the\n * currently-registered SMRT object schemas. Pure inspection — no writes.\n *\n * Useful for status commands (\"how far behind is the schema?\") and as the\n * inner step of `migrateSmrtSchemas`.\n *\n * **Note on the returned `statements`:** these are the engine-correct DDL\n * statements as the differ + DDL strategy produce them, *prior to* any\n * Postgres-specific rewrites the `MigrationTracker` applies at execution\n * time (e.g. rewriting `CREATE INDEX` → `CREATE INDEX CONCURRENTLY` and\n * moving CONCURRENTLY statements outside the surrounding transaction).\n * The list is suitable for preview/status/\"what would change?\" use cases.\n * For the exact byte-for-byte SQL the tracker ran, inspect the\n * `MigrationResult`s from `migrateSmrtSchemas` or the tracker's own logs.\n */\nexport async function getPendingSchemaStatements(\n  db: DatabaseInterface,\n  options: {\n    engineHint?: DatabaseEngine;\n    postgresTimestampMigration?: { legacyTimezone: 'UTC' };\n  } = {},\n): Promise<PendingSchemaStatementsResult> {\n  const schemas = ObjectRegistry.getAllSchemasAsDefinitions();\n  // Forward engineHint into the diff itself so the SchemaComparer's\n  // existing-table SQL (ALTER/index drift) uses the same DDL strategy\n  // we use for newly-added tables — otherwise the two halves of the\n  // statement list can land on different engines (split-brain) when\n  // `db.url` is empty or ambiguous.\n  const diff = await generateSchemaDiff(db, schemas, {\n    engineHint: options.engineHint,\n    postgresTimestampMigration: options.postgresTimestampMigration,\n  });\n  const statements = collectStatementsFromDiff(diff, db, options.engineHint);\n  const unactionableChanges = collectUnactionableChanges(diff);\n  return {\n    diff,\n    schemaCount: Object.keys(schemas).length,\n    statements,\n    hasChanges: hasActionableChanges(diff),\n    unactionableChanges,\n    hasManualDrift: unactionableChanges.length > 0,\n  };\n}\n\n/**\n * Apply any pending schema changes from `ObjectRegistry` to `db`.\n *\n * Returns `applied: false` (with no error) if the database is already in\n * sync. Throws on the first migration failure with the underlying error\n * preserved (callers should let it propagate to the CLI).\n *\n * **Note on the returned `statements`:** mirrors `getPendingSchemaStatements`\n * — the list is the planned DDL, prior to Postgres-specific tracker rewrites\n * (CONCURRENTLY, transaction reordering). The actual executed SQL is\n * tracked in the returned `results`.\n *\n * **Note on `applied` semantics under `reconcile: true` (the default):**\n * the tracker may re-execute a migration that is already in `completed`\n * state when the checksum matches — that counts as `applied: true` in the\n * returned `MigrationResult`. So `result.applied === true` means \"the\n * tracker ran the migration\", not specifically \"the database changed for\n * the first time.\" Pass `reconcile: false` if you need to distinguish a\n * fresh apply from a reconcile-replay over an existing completed record.\n *\n * **Note on repeated failures:** the migration name defaults to a fresh\n * timestamp on every call, so a sequence of failed runs leaves one\n * `failed` row in `_smrt_schema_migrations` per attempt. Pass an explicit\n * `name` if you want to overwrite the same record across retries.\n *\n * **Note on `unactionableChanges`:** the differ can detect schema drift\n * the migration step can't auto-resolve — incompatible type mismatches,\n * SQLite type widening that needs table recreation, etc. Those changes\n * appear in `result.unactionableChanges` and are NOT applied (the\n * statements list is filtered to executable DDL only). When the diff\n * contains *only* unactionable changes, the function returns\n * `applied: false` with a populated `unactionableChanges` so callers can\n * surface a \"manual migration required\" signal. Without inspecting that\n * field, the result would look indistinguishable from \"already in sync.\"\n */\nexport async function migrateSmrtSchemas(\n  options: MigrateSmrtSchemasOptions,\n): Promise<MigrateSmrtSchemasResult> {\n  const pending = await getPendingSchemaStatements(options.db, {\n    engineHint: options.engineHint,\n    postgresTimestampMigration: options.postgresTimestampMigration,\n  });\n  if (!pending.hasChanges || pending.statements.length === 0) {\n    return {\n      applied: false,\n      results: [],\n      statements: [],\n      schemaCount: pending.schemaCount,\n      unactionableChanges: pending.unactionableChanges,\n      hasManualDrift: pending.hasManualDrift,\n    };\n  }\n\n  const tracker = new MigrationTracker({\n    db: options.db,\n    engineHint: options.engineHint,\n    lockTimeout: options.lockTimeout,\n    statementTimeout: options.statementTimeout,\n    useConcurrentIndexes: options.useConcurrentIndexes ?? true,\n  });\n  const migration = createMigrationDefinition(\n    options.name ?? `${generateMigrationTimestamp()}_smrt_schema_sync`,\n    pending.statements,\n    [],\n    {\n      description: options.description ?? 'Synchronize SMRT object schemas',\n      packageName: options.packageName,\n      version: options.version ?? 'unknown',\n    },\n  );\n\n  const results = await tracker.applyAll([migration], {\n    postgresSafe: options.postgresSafe ?? true,\n    reconcile: options.reconcile ?? true,\n  });\n\n  const failed = results.find((result) => !result.success);\n  if (failed) {\n    throw failed.error instanceof Error\n      ? failed.error\n      : new Error(String(failed.error ?? `Migration ${failed.name} failed`));\n  }\n\n  const applied = results.some(\n    (result) => result.applied !== false && result.skipped !== true,\n  );\n\n  return {\n    applied,\n    results,\n    statements: pending.statements,\n    schemaCount: pending.schemaCount,\n    unactionableChanges: pending.unactionableChanges,\n    hasManualDrift: pending.hasManualDrift,\n  };\n}\n\n/** Mirror of the `getDatabaseUrl` helper in class.ts — some adapters\n * (JSON, certain in-memory wrappers) leave `db.url` undefined and expose\n * the URL on `db.config?.url` instead. Detecting the engine from a raw\n * `db.url` would throw or silently fall through to the sqlite default.\n */\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & {\n    config?: { url?: string };\n  };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\n/**\n * Materialize the diff into the engine-correct SQL statements.\n *\n * For new tables we delegate to the engine's `DDLStrategy` so column types\n * (`REAL` → `DOUBLE PRECISION` on Postgres, `JSON` → `JSONB`, etc.),\n * partial-index `WHERE` clauses, and trigger syntax all match what the\n * SchemaComparer would expect on subsequent runs. Emitting the raw\n * abstract `SchemaDefinition.ddl` here would cause immediate type-drift\n * migrations on Postgres/DuckDB.\n *\n * Column/index/trigger changes for existing tables continue to come from\n * `getSQLFromDiff`, which is already engine-aware via the differ's per-\n * change `sqlStatements`.\n */\nfunction collectStatementsFromDiff(\n  diff: Awaited<ReturnType<typeof generateSchemaDiff>>,\n  db: DatabaseInterface,\n  engineHint?: DatabaseEngine,\n): string[] {\n  const strategy = getDDLStrategy(\n    detectEngine(resolveDatabaseUrl(db), engineHint),\n  );\n  const statements: string[] = [];\n  for (const schema of diff.added_tables) {\n    statements.push(strategy.generateCreateTable(schema));\n    statements.push(...strategy.generateIndexes(schema));\n    statements.push(...strategy.generateTriggers(schema));\n  }\n  statements.push(...getSQLFromDiff(diff));\n  // Drop empty and comment-only entries. SQLite type-widening upgrades\n  // surface as `-- SQLite: Type upgrade for X requires table recreation`\n  // — passing those through to the tracker records a successful migration\n  // without actually fixing the column, so the same drift re-appears on\n  // every subsequent run. Those changes are surfaced separately via\n  // `unactionableChanges` so callers can prompt for manual remediation.\n  return statements.filter((statement) => {\n    const trimmed = statement.trim();\n    if (trimmed.length === 0) return false;\n    return !isCommentOnlySql(trimmed);\n  });\n}\n\n/**\n * True if `sql` contains no executable DDL — only line comments (`--`)\n * and/or block comments (`/* … *​/`). Used to discard advisory comments\n * the differ emits when a column upgrade can't be performed in place\n * (e.g. SQLite type widening). Defensive: strips block comments first so\n * a future differ that emits `/* type_upgrade: no-op *​/` doesn't slip\n * through.\n */\nfunction isCommentOnlySql(sql: string): boolean {\n  // Strip /* ... */ block comments (non-greedy, spans newlines).\n  const withoutBlockComments = sql.replace(/\\/\\*[\\s\\S]*?\\*\\//g, '');\n  const lines = withoutBlockComments\n    .split('\\n')\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0);\n  if (lines.length === 0) return sql.trim().length > 0;\n  return lines.every((line) => line.startsWith('--'));\n}\n\n/**\n * True if `sql` is an advisory comment that says *nothing needs to happen* —\n * as opposed to one that says a human has to act.\n *\n * The differ emits both kinds. \"This SQLite column already stores JSON as\n * TEXT\" and \"#2370: this column is rebuilt together with its sibling\" are\n * no-ops; \"requires table recreation\" / \"blocked: …\" are real manual drift.\n * Treating the first kind as drift makes a fully auto-repairable migration\n * report `hasManualDrift: true`.\n *\n * Keep in sync with `classifyTypeUpgradeSql`'s `noop` arm in\n * `@happyvertical/smrt-cli` (`src/commands/db-migrate-actions.ts`), which\n * applies the same rule on the CLI side.\n */\nfunction isNoOpAdvisorySql(sql: string): boolean {\n  const trimmed = sql.trim();\n  return (\n    /no change needed/i.test(trimmed) || /already stores .* as /i.test(trimmed)\n  );\n}\n\n/**\n * Surface changes the differ produced but that the migrator cannot apply\n * automatically — `type_mismatch` entries (the differ explicitly gives up on\n * these), `type_upgrade`/`alter_column` entries whose generated SQL is\n * advisory-comment-only (a SQLite rebuild that would be unsafe, an in-place\n * constraint change SQLite cannot perform), and warning-level report-only\n * advisories (an orphan NOT NULL column that will break inserts, a required\n * column that could not be enforced, a stale unique constraint, a relaxation\n * the caller has not opted into). Info-level advisories (a harmless orphan\n * column, a stale default) and comments that mean \"already handled\" (the\n * no-op advisories a table rebuild leaves on covered siblings, #2370) are\n * deliberately excluded so `hasManualDrift` keeps meaning \"something needs\n * an operator\". Callers use this to distinguish \"schema is in sync\" from\n * \"schema is drifted but we can't fix it from here\".\n */\nfunction collectUnactionableChanges(\n  diff: Awaited<ReturnType<typeof generateSchemaDiff>>,\n): SchemaChange[] {\n  const unactionable: SchemaChange[] = [];\n  for (const change of diff.changes) {\n    if (change.type === 'type_mismatch') {\n      unactionable.push(change);\n      continue;\n    }\n    const statements = change.sqlStatements ?? (change.sql ? [change.sql] : []);\n    if (statements.length === 0) {\n      if (change.advisory?.severity === 'warning') {\n        unactionable.push(change);\n      }\n      continue;\n    }\n    if (\n      statements.every((stmt) => isCommentOnlySql(stmt.trim())) &&\n      !statements.every((stmt) => isNoOpAdvisorySql(stmt))\n    ) {\n      unactionable.push(change);\n    }\n  }\n  return unactionable;\n}\n"],"mappings":"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"}