@happyvertical/smrt-core 0.50.0 → 0.51.0

package/dist/migrations/differ.d.ts

@@ -241,23 +241,55 @@ export declare class SchemaComparer {
      */
     private detectRenameDataPending;
     /**
-     * Live-data probe: does the column hold any non-null, non-empty value?
-     * Used by {@link detectRenameDataPending}. Errors propagate to the
-     * caller, which skips the pair rather than guessing (#2752).
-     */
-    private columnHasNonEmptyValue;
-    /**
-     * Live-data probe: are every one of a column's non-empty values
-     * UUID-shaped ({@link CANONICAL_UUID_PATTERN})? PostgreSQL pushes the
-     * check into the query with its regex operator; SQLite has no regex
-     * operator, but its case-sensitive `GLOB` can still express the fixed
-     * 36-character canonical shape ({@link CANONICAL_UUID_SQLITE_GLOB_PATTERN}
-     * against `LOWER(...)`, guarded by an exact `LENGTH(...) = 36` check), so
-     * both engines run one server-side aggregate `count(*)` rather than
-     * fetching every non-empty value into JS to test in a loop — important on
-     * a production table with many rows (#2767 review).
-     */
-    private allNonEmptyValuesUuidShaped;
+     * Live-data probe, batched across every column named: does each hold any
+     * non-null, non-empty value? One round trip regardless of column count
+     * (#2874) — one row of uncorrelated scalar subqueries,
+     * `(SELECT 1 FROM t WHERE ... LIMIT 1) AS "col"`, portable across
+     * PostgreSQL and SQLite. Deliberately *not* an aggregate
+     * (`MAX(CASE WHEN ...)`) over the whole table: an aggregate forces a full
+     * scan for every probed column even when the very first row already
+     * answers it, which would turn a healthy, mostly-populated large table
+     * into a guaranteed full scan on every comparison — worse than the
+     * original per-column probe for exactly the schemas #2874 cares about
+     * (#2874 review finding F1). Each subquery keeps the original
+     * `LIMIT 1` early exit; only the round trip is batched, not the
+     * per-column scan cost.
+     *
+     * Falls back to {@link columnHasNonEmptyValueSingle} per column when the
+     * batched statement itself fails (a column dropped concurrently, or a
+     * `CAST` the engine rejects) — #2874 review finding F2: a single bad
+     * column must withhold only that column's result, not the whole table's
+     * detection. A column absent from the returned map means "could not be
+     * probed"; callers apply their own fail-closed default.
+     */
+    private columnsHaveNonEmptyValueBatch;
+    private columnsHaveNonEmptyValueBatchQuery;
+    /** Single-column fallback for {@link columnsHaveNonEmptyValueBatch}. */
+    private columnHasNonEmptyValueSingle;
+    /**
+     * Live-data probe, batched across every orphan column named: are every
+     * one of each column's non-empty values UUID-shaped
+     * ({@link CANONICAL_UUID_PATTERN})? One round trip regardless of column
+     * count (#2874), mirroring {@link columnsHaveNonEmptyValueBatch}: one row
+     * of uncorrelated scalar subqueries, each
+     * `(SELECT 1 FROM t WHERE <non-empty> AND <invalid> LIMIT 1)` — a live
+     * value is absent from the result exactly when no invalid row exists, so
+     * this also short-circuits on the first invalid row rather than counting
+     * every one (an early-exit improvement over the pre-#2874 per-column
+     * `count(*)` probe, not just a batching change). PostgreSQL pushes the
+     * shape check into its regex operator; SQLite has no regex operator, but
+     * its case-sensitive `GLOB` can still express the fixed 36-character
+     * canonical shape ({@link CANONICAL_UUID_SQLITE_GLOB_PATTERN} against
+     * `LOWER(...)`, guarded by an exact `LENGTH(...) = 36` check).
+     *
+     * Falls back to {@link allNonEmptyValuesUuidShapedSingle} per column on a
+     * batch failure, same posture as {@link columnsHaveNonEmptyValueBatch}
+     * (#2874 review finding F2).
+     */
+    private columnsAllValuesUuidShapedBatch;
+    private columnsAllValuesUuidShapedBatchQuery;
+    /** Single-column fallback for {@link columnsAllValuesUuidShapedBatch}. */
+    private allNonEmptyValuesUuidShapedSingle;
     /**
      * Render the repair for one rename-data-pending pair (#2752): copy
      * non-empty `oldColumn` into `newColumn` only where `newColumn` is still
@@ -272,7 +304,7 @@ export declare class SchemaComparer {
      *   for `integer`/`boolean`/`timestamp`/etc. before a same-type rename
      *   pair of one of those types ever copies anything. Fixed by comparing
      *   `CAST(col AS TEXT) = ''` instead, mirroring the same portable
-     *   emptiness check {@link columnHasNonEmptyValue} already uses for
+     *   emptiness check {@link columnsHaveNonEmptyValueBatch} already uses for
      *   detection, so the predicate is valid for every column type.
      * - (P2) An `UPDATE` unconditionally naming `oldColumn` fails once that
      *   column is gone, on either engine, regardless of the DROP's own

package/dist/migrations/differ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"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"}

package/dist/migrations/differ.js

@@ -982,82 +982,168 @@ var SchemaComparer = class {
 		const manifestColumnNames = new Set(Object.keys(manifest.columns));
 		const orphanColumnNames = [...dbColumnNames].filter((name) => !manifestColumnNames.has(name));
 		if (orphanColumnNames.length === 0) return [];
+		const declaredCandidateNames = Object.keys(manifest.columns).filter((colName) => dbSchema.columns[colName]);
+		if (declaredCandidateNames.length === 0) return [];
+		const declaredHasData = await this.columnsHaveNonEmptyValueBatch(tableName, declaredCandidateNames);
+		const emptyDeclaredNames = declaredCandidateNames.filter((colName) => !(declaredHasData.get(colName) ?? true));
+		if (emptyDeclaredNames.length === 0) return [];
+		const compatibleOrphanNames = orphanColumnNames.filter((orphanName) => {
+			const orphanNormalized = this.normalizeType(dbSchema.columns[orphanName].type);
+			return emptyDeclaredNames.some((colName) => {
+				const validatedType = isValidSQLDataType(manifest.columns[colName].type) ? manifest.columns[colName].type : "TEXT";
+				const declaredNormalized = this.normalizeType(this.ddlStrategy.mapType(validatedType));
+				return validatedType === "UUID" && orphanNormalized === "TEXT" || orphanNormalized === declaredNormalized;
+			});
+		});
+		if (compatibleOrphanNames.length === 0) return [];
+		const orphanHasData = await this.columnsHaveNonEmptyValueBatch(tableName, compatibleOrphanNames);
+		const hasData = new Map([...declaredHasData, ...orphanHasData]);
 		const changes = [];
+		const pending = [];
+		const shapeCheckOrphans = /* @__PURE__ */ new Set();
 		for (const [colName, colDef] of Object.entries(manifest.columns)) {
 			if (!dbSchema.columns[colName]) continue;
-			let declaredHasData;
-			try {
-				declaredHasData = await this.columnHasNonEmptyValue(tableName, colName);
-			} catch {
-				continue;
-			}
-			if (declaredHasData) continue;
+			if (hasData.get(colName) ?? true) continue;
 			const validatedType = isValidSQLDataType(colDef.type) ? colDef.type : "TEXT";
 			const isLogicalUuid = validatedType === "UUID";
 			const declaredNormalized = this.normalizeType(this.ddlStrategy.mapType(validatedType));
-			const candidates = [];
-			for (const orphanName of orphanColumnNames) {
+			for (const orphanName of compatibleOrphanNames) {
 				const orphanCol = dbSchema.columns[orphanName];
 				const orphanNormalized = this.normalizeType(orphanCol.type);
 				const requiresShapeCheck = isLogicalUuid && orphanNormalized === "TEXT";
 				if (!requiresShapeCheck && !(orphanNormalized === declaredNormalized)) continue;
-				let orphanHasData;
-				try {
-					orphanHasData = await this.columnHasNonEmptyValue(tableName, orphanName);
-				} catch {
-					continue;
-				}
-				if (!orphanHasData) continue;
-				if (requiresShapeCheck) {
-					let shaped;
-					try {
-						shaped = await this.allNonEmptyValuesUuidShaped(tableName, orphanName);
-					} catch {
-						continue;
-					}
-					if (!shaped) continue;
-				}
-				candidates.push({
+				if (!(hasData.get(orphanName) ?? false)) continue;
+				if (requiresShapeCheck) shapeCheckOrphans.add(orphanName);
+				pending.push({
+					colName,
 					orphanName,
-					isUuidCast: declaredNormalized === "UUID"
+					isUuidCast: declaredNormalized === "UUID",
+					requiresShapeCheck
 				});
 			}
-			if (candidates.length === 1) changes.push(this.describeRenameDataPending(tableName, colName, candidates[0].orphanName, candidates[0].isUuidCast));
-			else if (candidates.length > 1) changes.push(this.describeRenameDataPendingAmbiguous(tableName, colName, candidates.map((c) => c.orphanName)));
 		}
+		const shaped = shapeCheckOrphans.size > 0 ? await this.columnsAllValuesUuidShapedBatch(tableName, [...shapeCheckOrphans]) : /* @__PURE__ */ new Map();
+		const candidatesByColumn = /* @__PURE__ */ new Map();
+		for (const candidate of pending) {
+			if (candidate.requiresShapeCheck && !(shaped.get(candidate.orphanName) ?? false)) continue;
+			const list = candidatesByColumn.get(candidate.colName) ?? [];
+			list.push({
+				orphanName: candidate.orphanName,
+				isUuidCast: candidate.isUuidCast
+			});
+			candidatesByColumn.set(candidate.colName, list);
+		}
+		for (const [colName, candidates] of candidatesByColumn) if (candidates.length === 1) changes.push(this.describeRenameDataPending(tableName, colName, candidates[0].orphanName, candidates[0].isUuidCast));
+		else if (candidates.length > 1) changes.push(this.describeRenameDataPendingAmbiguous(tableName, colName, candidates.map((c) => c.orphanName)));
 		return changes;
 	}
 	/**
-	* Live-data probe: does the column hold any non-null, non-empty value?
-	* Used by {@link detectRenameDataPending}. Errors propagate to the
-	* caller, which skips the pair rather than guessing (#2752).
+	* Live-data probe, batched across every column named: does each hold any
+	* non-null, non-empty value? One round trip regardless of column count
+	* (#2874) — one row of uncorrelated scalar subqueries,
+	* `(SELECT 1 FROM t WHERE ... LIMIT 1) AS "col"`, portable across
+	* PostgreSQL and SQLite. Deliberately *not* an aggregate
+	* (`MAX(CASE WHEN ...)`) over the whole table: an aggregate forces a full
+	* scan for every probed column even when the very first row already
+	* answers it, which would turn a healthy, mostly-populated large table
+	* into a guaranteed full scan on every comparison — worse than the
+	* original per-column probe for exactly the schemas #2874 cares about
+	* (#2874 review finding F1). Each subquery keeps the original
+	* `LIMIT 1` early exit; only the round trip is batched, not the
+	* per-column scan cost.
+	*
+	* Falls back to {@link columnHasNonEmptyValueSingle} per column when the
+	* batched statement itself fails (a column dropped concurrently, or a
+	* `CAST` the engine rejects) — #2874 review finding F2: a single bad
+	* column must withhold only that column's result, not the whole table's
+	* detection. A column absent from the returned map means "could not be
+	* probed"; callers apply their own fail-closed default.
 	*/
-	async columnHasNonEmptyValue(tableName, colName) {
+	async columnsHaveNonEmptyValueBatch(tableName, colNames) {
+		if (colNames.length === 0) return /* @__PURE__ */ new Map();
+		try {
+			return await this.columnsHaveNonEmptyValueBatchQuery(tableName, colNames);
+		} catch {
+			const hasData = /* @__PURE__ */ new Map();
+			for (const colName of colNames) try {
+				hasData.set(colName, await this.columnHasNonEmptyValueSingle(tableName, colName));
+			} catch {}
+			return hasData;
+		}
+	}
+	async columnsHaveNonEmptyValueBatchQuery(tableName, colNames) {
+		const quotedTable = this.quoteIdentifier(tableName);
+		const selects = colNames.map((colName, index) => {
+			const quotedCol = this.quoteIdentifier(colName);
+			return `(SELECT 1 FROM ${quotedTable} WHERE ${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> '' LIMIT 1) AS c${index}`;
+		});
+		const row = (await this.db.query(`SELECT ${selects.join(", ")}`)).rows?.[0] ?? {};
+		const hasData = /* @__PURE__ */ new Map();
+		colNames.forEach((colName, index) => {
+			hasData.set(colName, row[`c${index}`] != null);
+		});
+		return hasData;
+	}
+	/** Single-column fallback for {@link columnsHaveNonEmptyValueBatch}. */
+	async columnHasNonEmptyValueSingle(tableName, colName) {
 		const quotedTable = this.quoteIdentifier(tableName);
 		const quotedCol = this.quoteIdentifier(colName);
 		return ((await this.db.query(`SELECT 1 AS present FROM ${quotedTable} WHERE ${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> '' LIMIT 1`)).rows?.length ?? 0) > 0;
 	}
 	/**
-	* Live-data probe: are every one of a column's non-empty values
-	* UUID-shaped ({@link CANONICAL_UUID_PATTERN})? PostgreSQL pushes the
-	* check into the query with its regex operator; SQLite has no regex
-	* operator, but its case-sensitive `GLOB` can still express the fixed
-	* 36-character canonical shape ({@link CANONICAL_UUID_SQLITE_GLOB_PATTERN}
-	* against `LOWER(...)`, guarded by an exact `LENGTH(...) = 36` check), so
-	* both engines run one server-side aggregate `count(*)` rather than
-	* fetching every non-empty value into JS to test in a loop — important on
-	* a production table with many rows (#2767 review).
+	* Live-data probe, batched across every orphan column named: are every
+	* one of each column's non-empty values UUID-shaped
+	* ({@link CANONICAL_UUID_PATTERN})? One round trip regardless of column
+	* count (#2874), mirroring {@link columnsHaveNonEmptyValueBatch}: one row
+	* of uncorrelated scalar subqueries, each
+	* `(SELECT 1 FROM t WHERE <non-empty> AND <invalid> LIMIT 1)` — a live
+	* value is absent from the result exactly when no invalid row exists, so
+	* this also short-circuits on the first invalid row rather than counting
+	* every one (an early-exit improvement over the pre-#2874 per-column
+	* `count(*)` probe, not just a batching change). PostgreSQL pushes the
+	* shape check into its regex operator; SQLite has no regex operator, but
+	* its case-sensitive `GLOB` can still express the fixed 36-character
+	* canonical shape ({@link CANONICAL_UUID_SQLITE_GLOB_PATTERN} against
+	* `LOWER(...)`, guarded by an exact `LENGTH(...) = 36` check).
+	*
+	* Falls back to {@link allNonEmptyValuesUuidShapedSingle} per column on a
+	* batch failure, same posture as {@link columnsHaveNonEmptyValueBatch}
+	* (#2874 review finding F2).
 	*/
-	async allNonEmptyValuesUuidShaped(tableName, colName) {
+	async columnsAllValuesUuidShapedBatch(tableName, colNames) {
+		if (colNames.length === 0) return /* @__PURE__ */ new Map();
+		try {
+			return await this.columnsAllValuesUuidShapedBatchQuery(tableName, colNames);
+		} catch {
+			const shaped = /* @__PURE__ */ new Map();
+			for (const colName of colNames) try {
+				shaped.set(colName, await this.allNonEmptyValuesUuidShapedSingle(tableName, colName));
+			} catch {}
+			return shaped;
+		}
+	}
+	async columnsAllValuesUuidShapedBatchQuery(tableName, colNames) {
+		const quotedTable = this.quoteIdentifier(tableName);
+		const selects = colNames.map((colName, index) => {
+			const quotedCol = this.quoteIdentifier(colName);
+			const nonEmptyPredicate = `${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> ''`;
+			const invalidPredicate = this.engine === "postgres" ? `CAST(${quotedCol} AS TEXT) !~* '${CANONICAL_UUID_PATTERN}'` : `NOT (LENGTH(CAST(${quotedCol} AS TEXT)) = 36 AND LOWER(CAST(${quotedCol} AS TEXT)) GLOB '${CANONICAL_UUID_SQLITE_GLOB_PATTERN}')`;
+			return `(SELECT 1 FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND ${invalidPredicate} LIMIT 1) AS c${index}`;
+		});
+		const row = (await this.db.query(`SELECT ${selects.join(", ")}`)).rows?.[0] ?? {};
+		const shaped = /* @__PURE__ */ new Map();
+		colNames.forEach((colName, index) => {
+			shaped.set(colName, row[`c${index}`] == null);
+		});
+		return shaped;
+	}
+	/** Single-column fallback for {@link columnsAllValuesUuidShapedBatch}. */
+	async allNonEmptyValuesUuidShapedSingle(tableName, colName) {
 		const quotedTable = this.quoteIdentifier(tableName);
 		const quotedCol = this.quoteIdentifier(colName);
 		const nonEmptyPredicate = `${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> ''`;
-		if (this.engine === "postgres") {
-			const row = (await this.db.query(`SELECT count(*) AS invalid_count FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND CAST(${quotedCol} AS TEXT) !~* '${CANONICAL_UUID_PATTERN}'`)).rows?.[0];
-			return Number(row?.invalid_count ?? 0) === 0;
-		}
-		const row = (await this.db.query(`SELECT count(*) AS invalid_count FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND NOT (LENGTH(CAST(${quotedCol} AS TEXT)) = 36 AND LOWER(CAST(${quotedCol} AS TEXT)) GLOB '${CANONICAL_UUID_SQLITE_GLOB_PATTERN}')`)).rows?.[0];
-		return Number(row?.invalid_count ?? 0) === 0;
+		const invalidPredicate = this.engine === "postgres" ? `CAST(${quotedCol} AS TEXT) !~* '${CANONICAL_UUID_PATTERN}'` : `NOT (LENGTH(CAST(${quotedCol} AS TEXT)) = 36 AND LOWER(CAST(${quotedCol} AS TEXT)) GLOB '${CANONICAL_UUID_SQLITE_GLOB_PATTERN}')`;
+		return ((await this.db.query(`SELECT 1 AS invalid FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND ${invalidPredicate} LIMIT 1`)).rows?.length ?? 0) === 0;
 	}
 	/**
 	* Render the repair for one rename-data-pending pair (#2752): copy
@@ -1073,7 +1159,7 @@ var SchemaComparer = class {
 	*   for `integer`/`boolean`/`timestamp`/etc. before a same-type rename
 	*   pair of one of those types ever copies anything. Fixed by comparing
 	*   `CAST(col AS TEXT) = ''` instead, mirroring the same portable
-	*   emptiness check {@link columnHasNonEmptyValue} already uses for
+	*   emptiness check {@link columnsHaveNonEmptyValueBatch} already uses for
 	*   detection, so the predicate is valid for every column type.
 	* - (P2) An `UPDATE` unconditionally naming `oldColumn` fails once that
 	*   column is gone, on either engine, regardless of the DROP's own