@happyvertical/smrt-core 0.43.10 → 0.44.0

package/dist/migrations/differ.js

@@ -2,6 +2,7 @@ import { normalizeForeignKeyAction, requireForeignKeyAction } from "../schema/fo
 import { isJsonPathIndex, isStiSubtypeUniqueIndex, renderIndexTarget } from "../schema/index-utils.js";
 import { foreignKeyConstraintName, foreignKeyRelationshipKey, renderForeignKeyConstraint, renderForeignKeyOrphanDetector, renderForeignKeyOrphanRepair, schemaForeignKeys, schemaForeignKeysForEngine } from "../schema/foreign-key-ddl.js";
 import { detectEngine, getDDLStrategy } from "../schema/ddl/index.js";
+import { describeForeignKeyTypeConflict, planUuidConvergence, renderUuidConvergenceRepairHint, renderUuidShapeProbe } from "../schema/uuid-convergence.js";
 import "../schema/utils.js";
 import { planSqliteTableRebuilds, sqliteRebuildPlaceholderSql } from "./sqlite-rebuild.js";
 import { createLogger } from "@happyvertical/logger";
@@ -291,6 +292,15 @@ var SchemaComparer = class {
 	options;
 	engine;
 	ddlStrategy;
+	/**
+	* Live schemas read during one `compare()` run. The uuid convergence plan
+	* (#2608) needs the same introspection the per-table comparison does, and
+	* re-reading `getTableSchema` per relationship would multiply catalog
+	* round-trips on a wide schema.
+	*/
+	liveSchemas = /* @__PURE__ */ new Map();
+	/** Convergence plan for this run; `null` on non-PostgreSQL engines. */
+	uuidConvergence = null;
 	constructor(db, options = {}) {
 		this.db = db;
 		this.options = {
@@ -313,7 +323,13 @@ var SchemaComparer = class {
 			changes: [],
 			has_changes: false
 		};
+		this.liveSchemas.clear();
 		const existingTables = await this.getExistingTables();
+		this.uuidConvergence = await this.buildUuidConvergencePlan(manifestSchemas, existingTables);
+		for (const change of this.uuidConvergenceChanges(manifestSchemas)) {
+			diff.changes.push(change);
+			if (!isInfoOnlyChange(change)) diff.has_changes = true;
+		}
 		for (const [tableName, schema] of Object.entries(manifestSchemas)) if (!existingTables.has(tableName)) {
 			diff.added_tables.push(schema);
 			diff.has_changes = true;
@@ -342,7 +358,7 @@ var SchemaComparer = class {
 	*/
 	async compareTable(tableName, manifest, manifestSchemas = {}) {
 		const changes = [];
-		const dbSchema = await this.db.getTableSchema?.(tableName);
+		const dbSchema = await this.getLiveSchema(tableName);
 		if (!dbSchema) return changes;
 		const columnChanges = await this.compareColumns(tableName, manifest, dbSchema);
 		changes.push(...this.engine === "sqlite" ? await planSqliteTableRebuilds({
@@ -357,6 +373,173 @@ var SchemaComparer = class {
 		changes.push(...await this.compareForeignKeys(tableName, manifest, dbSchema, manifestSchemas));
 		return changes;
 	}
+	/**
+	* Read (and memoize for this run) one table's live schema. Returns
+	* `undefined` when the table does not exist or the adapter cannot
+	* introspect it.
+	*/
+	async getLiveSchema(tableName) {
+		if (this.liveSchemas.has(tableName)) return this.liveSchemas.get(tableName) ?? void 0;
+		const schema = await this.db.getTableSchema?.(tableName);
+		this.liveSchemas.set(tableName, schema);
+		return schema ?? void 0;
+	}
+	/**
+	* Plan the pre-R11 `text` -> `uuid` convergence (#2608).
+	*
+	* PostgreSQL only: SQLite stores UUIDs as text by design and DuckDB cannot
+	* rewrite a column type in place, so both engines return `null` and emit
+	* nothing for this drift.
+	*/
+	async buildUuidConvergencePlan(manifestSchemas, existingTables) {
+		if (this.engine !== "postgres") return null;
+		for (const tableName of Object.keys(manifestSchemas)) {
+			if (!existingTables.has(tableName)) continue;
+			await this.getLiveSchema(tableName);
+		}
+		const relationships = Object.entries(manifestSchemas).flatMap(([tableName, schema]) => schemaForeignKeysForEngine(schema, "postgres").map((foreignKey) => ({
+			childTable: tableName,
+			childColumn: foreignKey.column,
+			parentTable: foreignKey.referencesTable,
+			parentColumn: foreignKey.referencesColumn
+		})));
+		const conversionCandidates = /* @__PURE__ */ new Set();
+		for (const relationship of relationships) {
+			const childManifest = manifestSchemas[relationship.childTable]?.columns[relationship.childColumn];
+			const parentManifest = manifestSchemas[relationship.parentTable]?.columns[relationship.parentColumn];
+			if (childManifest?.type !== "UUID" || parentManifest?.type !== "UUID") continue;
+			for (const [table, column] of [[relationship.childTable, relationship.childColumn], [relationship.parentTable, relationship.parentColumn]]) {
+				if (!existingTables.has(table)) continue;
+				const live = this.liveSchemas.get(table)?.columns[column];
+				if (!live) continue;
+				if (this.normalizeType(live.type) !== "TEXT") continue;
+				conversionCandidates.add(`${table} ${column}`);
+			}
+		}
+		if (conversionCandidates.size > 0) for (const tableName of existingTables) {
+			if (manifestSchemas[tableName]) continue;
+			if (tableName.startsWith("sqlite_")) continue;
+			await this.getLiveSchema(tableName);
+		}
+		const liveForeignKeys = [];
+		for (const [tableName, schema] of this.liveSchemas) for (const live of schema?.foreignKeys ?? []) liveForeignKeys.push({
+			table: tableName,
+			column: live.column,
+			referencesTable: live.referencesTable,
+			referencesColumn: live.referencesColumn
+		});
+		return planUuidConvergence({
+			manifestSchemas,
+			relationships,
+			liveForeignKeys,
+			getLiveColumn: (table, column) => {
+				if (!existingTables.has(table)) return void 0;
+				const live = this.liveSchemas.get(table)?.columns[column];
+				if (!live) return void 0;
+				return {
+					normalizedType: this.normalizeType(live.type),
+					rawType: live.type,
+					hasDefault: live.defaultValue !== null && live.defaultValue !== void 0,
+					exists: true
+				};
+			},
+			probeUuidShape: (table, column) => this.probeUuidShape(table, column)
+		});
+	}
+	/**
+	* Count values a legacy `text` identifier column holds that cannot be
+	* reinterpreted as `uuid`. Any failure resolves to `unavailable`, which the
+	* planner treats as a block — SMRT never coerces identifier values.
+	*/
+	async probeUuidShape(tableName, columnName) {
+		try {
+			const result = await this.db.query(renderUuidShapeProbe(tableName, columnName));
+			const rows = Array.isArray(result) ? result : result.rows || [];
+			const count = Number(rows[0]?.invalid_count ?? 0);
+			if (!Number.isFinite(count)) return {
+				status: "unavailable",
+				reason: "probe returned a non-numeric count"
+			};
+			if (count === 0) return { status: "clean" };
+			const sample = rows[0]?.sample_value;
+			return {
+				status: "dirty",
+				count,
+				...typeof sample === "string" ? { sample } : {}
+			};
+		} catch (error) {
+			return {
+				status: "unavailable",
+				reason: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	/**
+	* Turn the convergence plan into diff entries: executable `type_upgrade`
+	* conversions marked `phase: 'pre_foreign_key'`, plus report-only warnings
+	* for components the planner refused.
+	*/
+	uuidConvergenceChanges(manifestSchemas) {
+		const plan = this.uuidConvergence;
+		if (!plan) return [];
+		const manifestColumn = (table, column) => manifestSchemas[table]?.columns[column] ?? { type: "UUID" };
+		const changes = [];
+		for (const conversion of plan.conversions) changes.push({
+			type: "type_upgrade",
+			table: conversion.table,
+			name: conversion.column,
+			column: manifestColumn(conversion.table, conversion.column),
+			phase: "pre_foreign_key",
+			mismatch: {
+				expected: "UUID",
+				actual: conversion.liveType
+			},
+			sql: conversion.statements[0],
+			sqlStatements: conversion.statements
+		});
+		for (const block of plan.blocks) {
+			const [first] = block.targets.length > 0 ? block.targets : block.nodes;
+			changes.push({
+				type: "type_upgrade",
+				table: first?.table ?? "",
+				name: first?.column,
+				column: manifestColumn(first?.table ?? "", first?.column ?? ""),
+				phase: "pre_foreign_key",
+				mismatch: {
+					expected: "UUID",
+					actual: "mixed uuid/text"
+				},
+				advisory: {
+					severity: "warning",
+					message: `blocked: incompatible column types. The manifest declares UUID for ${block.nodes.map((node) => `${node.table}.${node.column}`).join(", ")}, but ${block.reason}.`,
+					suggestedSql: block.suggestedSql
+				}
+			});
+		}
+		return changes;
+	}
+	/**
+	* Live-type verdict for one foreign key once this run's conversions land.
+	* `undefined` means the pair is compatible (or unknowable) and the ordinary
+	* add path applies.
+	*/
+	async describeForeignKeyTypeBlock(tableName, dbSchema, foreignKey) {
+		if (this.engine !== "postgres") return void 0;
+		const parentSchema = foreignKey.referencesTable === tableName ? dbSchema : await this.getLiveSchema(foreignKey.referencesTable);
+		const childType = dbSchema.columns[foreignKey.column]?.type;
+		const parentType = parentSchema?.columns[foreignKey.referencesColumn]?.type;
+		if (!childType || !parentType) return void 0;
+		const plan = this.uuidConvergence;
+		if ((plan?.effectiveType(tableName, foreignKey.column) ?? this.normalizeType(childType)) === (plan?.effectiveType(foreignKey.referencesTable, foreignKey.referencesColumn) ?? this.normalizeType(parentType))) return void 0;
+		return describeForeignKeyTypeConflict({
+			childTable: tableName,
+			childColumn: foreignKey.column,
+			childType,
+			parentTable: foreignKey.referencesTable,
+			parentColumn: foreignKey.referencesColumn,
+			parentType
+		});
+	}
 	async compareForeignKeys(tableName, manifest, dbSchema, manifestSchemas) {
 		const changes = [];
 		const liveForeignKeys = dbSchema.foreignKeys || [];
@@ -433,6 +616,29 @@ var SchemaComparer = class {
 				});
 				continue;
 			}
+			const typeBlock = await this.describeForeignKeyTypeBlock(tableName, dbSchema, foreignKey);
+			if (typeBlock) {
+				const textNodes = manifest.columns[foreignKey.column]?.type === "UUID" && manifestSchemas[foreignKey.referencesTable]?.columns[foreignKey.referencesColumn]?.type === "UUID" ? [this.normalizeType(dbSchema.columns[foreignKey.column]?.type ?? "") === "TEXT" ? {
+					table: tableName,
+					column: foreignKey.column
+				} : void 0, this.normalizeType((foreignKey.referencesTable === tableName ? dbSchema : this.liveSchemas.get(foreignKey.referencesTable))?.columns[foreignKey.referencesColumn]?.type ?? "") === "TEXT" ? {
+					table: foreignKey.referencesTable,
+					column: foreignKey.referencesColumn
+				} : void 0].filter((node) => node !== void 0) : [];
+				const suggestedSql = renderUuidConvergenceRepairHint(textNodes);
+				changes.push({
+					type: "add_foreign_key",
+					table: tableName,
+					name: foreignKeyConstraintName(tableName, foreignKey),
+					foreignKey,
+					advisory: {
+						severity: "warning",
+						message: `blocked: incompatible column types. ${typeBlock}. ` + (textNodes.length > 0 ? "Converge the columns to UUID, then rerun the migration." : "Align both columns on one physical type deliberately, then rerun the migration."),
+						...suggestedSql.length > 0 ? { suggestedSql } : {}
+					}
+				});
+				continue;
+			}
 			if (Boolean(dbSchema.columns[foreignKey.column]) && await this.foreignKeyHasOrphans(tableName, foreignKey, orphanOptions)) {
 				changes.push({
 					type: "add_foreign_key",
@@ -480,7 +686,7 @@ var SchemaComparer = class {
 			nullable,
 			uuidComparison
 		};
-		const parentSchema = foreignKey.referencesTable === tableName ? dbSchema : await this.db.getTableSchema?.(foreignKey.referencesTable);
+		const parentSchema = foreignKey.referencesTable === tableName ? dbSchema : await this.getLiveSchema(foreignKey.referencesTable);
 		const childType = dbSchema.columns[foreignKey.column]?.type;
 		const parentType = parentSchema?.columns[foreignKey.referencesColumn]?.type;
 		if (!childType || !parentType) return {
@@ -1389,11 +1595,21 @@ function hasActionableChanges(diff) {
 * they already do for `type_upgrade`.
 */
 function getSQLFromDiff(diff) {
+	return getSQLFromChanges(diff.changes);
+}
+/**
+* Executable SQL for an explicit subset of changes, in the order given.
+* Callers that have to interleave diff changes with statements produced
+* elsewhere — the orchestrator, which emits `CREATE TABLE` and deferred
+* foreign keys of its own — partition `diff.changes` by
+* {@link SchemaChange.phase} and render each part through this helper.
+*/
+function getSQLFromChanges(changes) {
 	const statements = [];
-	for (const change of diff.changes) if (change.type !== "type_mismatch" && !isAdvisoryOnlyChange(change)) statements.push(...change.sqlStatements ?? (change.sql ? [change.sql] : []));
+	for (const change of changes) if (change.type !== "type_mismatch" && !isAdvisoryOnlyChange(change)) statements.push(...change.sqlStatements ?? (change.sql ? [change.sql] : []));
 	return statements;
 }
 //#endregion
-export { SchemaComparer, canonicalizeDefault, extractIndexPredicate, generateSchemaDiff, getSQLFromDiff, hasActionableChanges, isAdvisoryOnlyChange, isInfoOnlyChange, isManualOrAdvisoryChange, normalizeIndexPredicate, uniqueColumnIndexName };
+export { SchemaComparer, canonicalizeDefault, extractIndexPredicate, generateSchemaDiff, getSQLFromChanges, getSQLFromDiff, hasActionableChanges, isAdvisoryOnlyChange, isInfoOnlyChange, isManualOrAdvisoryChange, normalizeIndexPredicate, uniqueColumnIndexName };
 
 //# sourceMappingURL=differ.js.map