@happyvertical/smrt-core 0.47.2 → 0.49.0

package/dist/migrations/differ.js

@@ -1,7 +1,8 @@
 import { normalizeForeignKeyAction, requireForeignKeyAction } from "../schema/foreign-key-policy.js";
 import { isJsonPathIndex, isStiSubtypeUniqueIndex, renderIndexTarget } from "../schema/index-utils.js";
-import { CANONICAL_UUID_PATTERN, CANONICAL_UUID_SQLITE_GLOB_PATTERN, foreignKeyConstraintName, foreignKeyRelationshipKey, renderForeignKeyConstraint, renderForeignKeyOrphanDetector, renderForeignKeyOrphanRepair, schemaForeignKeys, schemaForeignKeysForEngine } from "../schema/foreign-key-ddl.js";
+import { CANONICAL_UUID_PATTERN, CANONICAL_UUID_SQLITE_GLOB_PATTERN, foreignKeyConstraintName, foreignKeyRelationshipKey, renderForeignKeyAddStatements, renderForeignKeyOrphanDetector, renderForeignKeyOrphanRepair, schemaForeignKeys, schemaForeignKeysForEngine } from "../schema/foreign-key-ddl.js";
 import { detectEngine, getDDLStrategy } from "../schema/ddl/index.js";
+import { maskSampleValue, probeCastSafety, renderJsonbColumnConversion, renderTimestamptzColumnConversion } from "../schema/text-cast-probe.js";
 import { describeForeignKeyTypeConflict, planUuidConvergence, renderUuidConvergenceRepairHint, renderUuidShapeProbe } from "../schema/uuid-convergence.js";
 import "../schema/utils.js";
 import { planSqliteTableRebuilds, sqliteRebuildPlaceholderSql } from "./sqlite-rebuild.js";
@@ -64,6 +65,18 @@ function uniqueColumnIndexName(tableName, columnName) {
 * True when a change is report-only: it carries an advisory and no
 * executable statement. Such changes never reach the migration stream.
 */
+/**
+* Single- vs double-precision float classification for #2770's float-width
+* drift detection. `null` for anything that isn't unambiguously one or the
+* other (DECIMAL/NUMERIC have no fixed binary width and are out of scope).
+*/
+function floatPrecisionOf(type, engine) {
+	const upper = type.toUpperCase().trim().replace(/\(\s*\d+(\s*,\s*\d+)?\s*\)/g, "");
+	if (/^(REAL|FLOAT4)$/.test(upper)) return "single";
+	if (engine === "duckdb" && upper === "FLOAT") return "single";
+	if (/^(FLOAT8|DOUBLE|DOUBLE PRECISION|FLOAT)$/.test(upper)) return "double";
+	return null;
+}
 function isAdvisoryOnlyChange(change) {
 	if (!change.advisory) return false;
 	return (change.sqlStatements ?? (change.sql ? [change.sql] : [])).length === 0;
@@ -475,6 +488,18 @@ var SchemaComparer = class {
 		}
 	}
 	/**
+	* Probe a candidate `text` -> `timestamptz`/`jsonb` column (#2771, #2772)
+	* with a real, exception-safe cast attempt (see `text-cast-probe.ts`).
+	* Unlike {@link probeUuidShape}, a failed/unrealistic probe
+	* (`unavailable`) is the caller's cue to fall back to the pre-existing
+	* behavior for that pair rather than surface a new finding — this keeps
+	* the new convergence strictly additive for every case that isn't
+	* affirmatively confirmed safe or affirmatively confirmed unsafe.
+	*/
+	async probeTextCastShape(tableName, columnName, kind) {
+		return probeCastSafety(this.db, tableName, columnName, kind);
+	}
+	/**
 	* 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.
@@ -608,6 +633,7 @@ var SchemaComparer = class {
 					table: tableName,
 					name: foreignKeyConstraintName(tableName, foreignKey),
 					foreignKey,
+					engineUnsupported: true,
 					advisory: {
 						severity: "warning",
 						message: `${engineReason} Run the orphan detector, repair rows, and rebuild the table with the generated constraint.`,
@@ -645,6 +671,8 @@ var SchemaComparer = class {
 					table: tableName,
 					name: foreignKeyConstraintName(tableName, foreignKey),
 					foreignKey,
+					orphanBlocked: true,
+					orphanNullable: orphanOptions.nullable,
 					advisory: {
 						severity: "warning",
 						message: `Cannot add foreign key ${tableName}.${foreignKey.column}: existing rows do not match ${foreignKey.referencesTable}.${foreignKey.referencesColumn}. Repair them, then rerun.`,
@@ -659,7 +687,7 @@ var SchemaComparer = class {
 				table: tableName,
 				name: constraintName,
 				foreignKey,
-				sqlStatements: [`ALTER TABLE ${this.quoteIdentifier(tableName)} ADD ${renderForeignKeyConstraint(tableName, foreignKey)} NOT VALID`, `ALTER TABLE ${this.quoteIdentifier(tableName)} VALIDATE CONSTRAINT ${this.quoteIdentifier(constraintName)}`]
+				sqlStatements: renderForeignKeyAddStatements(tableName, foreignKey)
 			});
 		}
 		return changes;
@@ -680,7 +708,9 @@ var SchemaComparer = class {
 	async getForeignKeyOrphanOptions(tableName, manifest, dbSchema, foreignKey, manifestSchemas) {
 		const sourceColumn = manifest.columns[foreignKey.column];
 		const targetColumn = manifestSchemas[foreignKey.referencesTable]?.columns[foreignKey.referencesColumn];
-		const nullable = sourceColumn?.notNull !== true;
+		const manifestNullable = sourceColumn?.notNull !== true;
+		const liveNotNull = dbSchema.columns[foreignKey.column]?.notNull === true;
+		const nullable = manifestNullable && !liveNotNull;
 		const uuidComparison = sourceColumn?.type === "UUID" && (targetColumn === void 0 || targetColumn.type === "UUID");
 		if (!uuidComparison) return {
 			nullable,
@@ -743,10 +773,148 @@ var SchemaComparer = class {
 			const expectedEngineType = this.ddlStrategy.mapType(validatedType);
 			const normalizedExpected = this.normalizeType(expectedEngineType);
 			const normalizedActual = this.normalizeType(dbCol.type);
+			if ((this.engine === "postgres" || this.engine === "duckdb") && normalizedExpected === "REAL" && normalizedActual === "REAL") {
+				const expectedPrecision = floatPrecisionOf(expectedEngineType, this.engine);
+				const actualPrecision = floatPrecisionOf(dbCol.type, this.engine);
+				if (expectedPrecision && actualPrecision && expectedPrecision !== actualPrecision) {
+					typeDrifted = true;
+					const table = this.quoteIdentifier(tableName);
+					const column = this.quoteIdentifier(colName);
+					if (expectedPrecision === "double" && actualPrecision === "single") {
+						const targetType = this.engine === "postgres" ? "DOUBLE PRECISION" : "DOUBLE";
+						changes.push({
+							type: "type_upgrade",
+							table: tableName,
+							name: colName,
+							column: colDef,
+							mismatch: {
+								expected: expectedEngineType,
+								actual: dbCol.type
+							},
+							sql: `ALTER TABLE ${table} ALTER COLUMN ${column} TYPE ${targetType} USING ${column}::${targetType}`
+						});
+					} else changes.push({
+						type: "type_upgrade",
+						table: tableName,
+						name: colName,
+						column: colDef,
+						mismatch: {
+							expected: expectedEngineType,
+							actual: dbCol.type
+						},
+						advisory: {
+							severity: "warning",
+							message: `blocked: ${tableName}.${colName} is declared single-precision (${expectedEngineType}) but the live column is double-precision (${dbCol.type}). Narrowing loses precision, so this stays manual: confirm the narrower declaration is intentional, or widen the manifest field instead of the column.`,
+							suggestedSql: [`ALTER TABLE ${table} ALTER COLUMN ${column} TYPE ${expectedEngineType} USING ${column}::${expectedEngineType}`]
+						}
+					});
+				}
+			}
 			const isUuidTextEquivalent = this.isUuidTextEquivalentColumn(colName, colDef, normalizedExpected, normalizedActual);
-			if (normalizedExpected !== normalizedActual && !isUuidTextEquivalent && !(normalizedExpected === "JSON" && normalizedActual === "TEXT" || normalizedExpected === "TEXT" && normalizedActual === "JSON")) {
+			const jsonUpgradeCandidate = this.engine === "postgres" && normalizedExpected === "JSON" && normalizedActual === "TEXT";
+			let jsonProbe;
+			if (jsonUpgradeCandidate) jsonProbe = await this.probeTextCastShape(tableName, colName, "jsonb");
+			const isJsonTextEquivalent = normalizedExpected === "TEXT" && normalizedActual === "JSON" || normalizedExpected === "JSON" && normalizedActual === "TEXT" && (!jsonUpgradeCandidate || jsonProbe?.status === "unavailable");
+			const timestamptzUpgradeCandidate = this.engine === "postgres" && this.normalizeType(colDef.type) === "TIMESTAMP" && normalizedActual === "TEXT" && normalizedExpected === "TIMESTAMPTZ" && !this.isCompatibleTypeUpgrade(colDef.type, dbCol.type);
+			let timestamptzProbe;
+			if (timestamptzUpgradeCandidate) timestamptzProbe = await this.probeTextCastShape(tableName, colName, "timestamptz");
+			if (normalizedExpected !== normalizedActual && !isUuidTextEquivalent && !isJsonTextEquivalent) {
 				typeDrifted = true;
-				if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {
+				const hasLiveDefault = dbCol.defaultValue !== null && dbCol.defaultValue !== void 0;
+				const conversionOptions = {
+					hasLiveDefault,
+					manifestDefaultValue: colDef.defaultValue
+				};
+				const liveOnlyDefaultNeedsRelaxOptIn = hasLiveDefault && colDef.defaultValue === void 0 && !this.options.relaxColumns;
+				if (jsonUpgradeCandidate && jsonProbe?.status === "clean" && liveOnlyDefaultNeedsRelaxOptIn) changes.push({
+					type: "type_upgrade",
+					table: tableName,
+					name: colName,
+					column: colDef,
+					mismatch: {
+						expected: colDef.type,
+						actual: dbCol.type
+					},
+					advisory: {
+						severity: "warning",
+						message: `blocked: ${tableName}.${colName} has a live default (${String(dbCol.defaultValue)}) the manifest no longer declares; converging to jsonb requires dropping it first. ${this.relaxHint("drop it as part of this conversion")}`,
+						suggestedSql: renderJsonbColumnConversion(tableName, colName, conversionOptions)
+					}
+				});
+				else if (jsonUpgradeCandidate && jsonProbe?.status === "clean") {
+					const statements = renderJsonbColumnConversion(tableName, colName, conversionOptions);
+					changes.push({
+						type: "type_upgrade",
+						table: tableName,
+						name: colName,
+						column: colDef,
+						mismatch: {
+							expected: colDef.type,
+							actual: dbCol.type
+						},
+						sql: statements[statements.length - 1],
+						sqlStatements: statements
+					});
+				} else if (jsonUpgradeCandidate && jsonProbe?.status === "dirty") changes.push({
+					type: "type_upgrade",
+					table: tableName,
+					name: colName,
+					column: colDef,
+					mismatch: {
+						expected: colDef.type,
+						actual: dbCol.type
+					},
+					advisory: {
+						severity: "warning",
+						message: `blocked: ${tableName}.${colName} is declared JSON but ${jsonProbe.count} live value(s) are not valid JSON (sample: ${jsonProbe.sample ? maskSampleValue(jsonProbe.sample) : "unavailable"}). Repair or clear the offending value(s), then rerun \`smrt db:migrate\`.`,
+						suggestedSql: renderJsonbColumnConversion(tableName, colName, conversionOptions)
+					}
+				});
+				else if (timestamptzUpgradeCandidate && timestamptzProbe?.status === "clean" && liveOnlyDefaultNeedsRelaxOptIn) changes.push({
+					type: "type_upgrade",
+					table: tableName,
+					name: colName,
+					column: colDef,
+					mismatch: {
+						expected: colDef.type,
+						actual: dbCol.type
+					},
+					advisory: {
+						severity: "warning",
+						message: `blocked: ${tableName}.${colName} has a live default (${String(dbCol.defaultValue)}) the manifest no longer declares; converging to timestamptz requires dropping it first. ${this.relaxHint("drop it as part of this conversion")}`,
+						suggestedSql: renderTimestamptzColumnConversion(tableName, colName, conversionOptions)
+					}
+				});
+				else if (timestamptzUpgradeCandidate && timestamptzProbe?.status === "clean") {
+					const statements = renderTimestamptzColumnConversion(tableName, colName, conversionOptions);
+					changes.push({
+						type: "type_upgrade",
+						table: tableName,
+						name: colName,
+						column: colDef,
+						mismatch: {
+							expected: colDef.type,
+							actual: dbCol.type
+						},
+						sql: statements[statements.length - 1],
+						sqlStatements: statements
+					});
+				} else if (timestamptzUpgradeCandidate && timestamptzProbe?.status === "dirty") changes.push({
+					type: "type_upgrade",
+					table: tableName,
+					name: colName,
+					column: colDef,
+					mismatch: {
+						expected: colDef.type,
+						actual: dbCol.type
+					},
+					advisory: {
+						severity: "warning",
+						message: `blocked: ${tableName}.${colName} is declared TIMESTAMP but ${timestamptzProbe.count} live value(s) do not parse as an unambiguous timestamp (sample: ${timestamptzProbe.sample ? maskSampleValue(timestamptzProbe.sample) : "unavailable"}). Repair the offending value(s), or confirm legacy naive wall-clock provenance with \`smrt db:migrate --postgres-timestamp-legacy-timezone=UTC\`, then rerun.`,
+						suggestedSql: renderTimestamptzColumnConversion(tableName, colName, conversionOptions)
+					}
+				});
+				else if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {
 					const generatedSQL = this.generateTypeUpgradeSQL(tableName, colName, colDef, dbCol.type);
 					changes.push({
 						type: "type_upgrade",