@happyvertical/smrt-core 0.40.69 → 0.41.0

package/dist/schema/live-parity.js

@@ -0,0 +1,602 @@
+import { detectEngine, getDDLStrategy } from "./ddl/index.js";
+import { RETIRED_SYSTEM_TABLES } from "../system/schema.js";
+import { getSystemTableShapes } from "./system-table-shapes.js";
+//#region src/schema/live-parity.ts
+/**
+* Thrown when the live database cannot be introspected. Callers fail closed:
+* an unreadable database is never reported as "in sync".
+*/
+var LiveSchemaParityError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "LiveSchemaParityError";
+	}
+};
+/**
+* Compare a live database against the expected shape and return every
+* difference found.
+*
+* @throws {LiveSchemaParityError} when the database cannot be reached or the
+*   adapter cannot describe a table. Connection problems must fail closed.
+*/
+async function checkLiveSchemaParity(options) {
+	const { db, schemas = {}, conflictTargets = {}, includeSystemTables = true, engineHint, reportExtraTables = true } = options;
+	const engine = resolveEngine(db, engineHint);
+	const expected = buildExpectedTables({
+		schemas,
+		conflictTargets,
+		includeSystemTables,
+		engine
+	});
+	const liveTableNames = await listLiveTables(db, engine);
+	const indexCatalog = await readIndexCatalog(db, engine);
+	const findings = [];
+	let tablesChecked = 0;
+	let tablesMissing = 0;
+	for (const table of expected) {
+		if (!liveTableNames.has(table.name)) {
+			tablesMissing++;
+			findings.push({
+				kind: "missing_table",
+				severity: "error",
+				table: table.name,
+				origin: table.origin,
+				message: `Table \`${table.name}\` is declared but does not exist in the live database.`,
+				recommendation: table.origin === "system" ? "Initialize SMRT system tables against this database (they are created on framework bootstrap)." : "Run `smrt db:migrate` to create the missing table."
+			});
+			continue;
+		}
+		tablesChecked++;
+		const liveColumns = await readLiveColumns(db, table.name);
+		findings.push(...compareColumns(table, liveColumns, engine));
+		if (indexCatalog) {
+			const liveIndexes = await indexCatalog.forTable(table.name);
+			findings.push(...compareIndexes(table, liveColumns, liveIndexes));
+		}
+	}
+	if (reportExtraTables) {
+		const expectedNames = new Set(expected.map((table) => table.name));
+		for (const liveName of liveTableNames) {
+			if (expectedNames.has(liveName)) continue;
+			if (isInternalTableName(liveName)) continue;
+			if (!includeSystemTables && liveName.startsWith("_smrt_")) continue;
+			const retired = RETIRED_SYSTEM_TABLES.includes(liveName);
+			findings.push({
+				kind: "extra_table",
+				severity: "info",
+				table: liveName,
+				origin: liveName.startsWith("_smrt_") ? "system" : "application",
+				message: retired ? `Live table \`${liveName}\` is a retired SMRT system table; nothing reads or writes it.` : `Live table \`${liveName}\` is not covered by any declared schema.`,
+				recommendation: retired ? `Drop it once you have confirmed it is unused: DROP TABLE IF EXISTS ${liveName};` : "Confirm the table belongs to another application sharing this database, or remove it once its owning model is gone."
+			});
+		}
+	}
+	const counts = {
+		error: 0,
+		warning: 0,
+		info: 0
+	};
+	for (const finding of findings) counts[finding.severity]++;
+	return {
+		engine,
+		tablesChecked,
+		tablesMissing,
+		systemTablesIncluded: includeSystemTables,
+		indexIntrospection: indexCatalog ? "full" : "unavailable",
+		findings,
+		counts,
+		ok: counts.error === 0
+	};
+}
+function buildExpectedTables(input) {
+	const { schemas, conflictTargets, includeSystemTables, engine } = input;
+	const strategy = getDDLStrategy(engine);
+	const tables = [];
+	for (const [key, schema] of Object.entries(schemas)) {
+		const tableName = schema?.tableName || key;
+		if (!tableName) continue;
+		const columns = Object.entries(schema.columns ?? {}).map(([columnName, column]) => ({
+			name: columnName,
+			type: strategy.mapType(column.type),
+			primaryKey: column.primaryKey === true,
+			notNull: column.notNull === true || column.primaryKey === true,
+			unique: column.unique === true,
+			hasDefault: column.defaultValue !== void 0,
+			reference: column.foreignKey ? "foreignKey" : column.referenceKind
+		}));
+		tables.push({
+			name: tableName,
+			origin: "application",
+			columns,
+			indexes: (schema.indexes ?? []).filter((index) => !index.jsonPath && (index.columns?.length ?? 0) > 0).map((index) => ({
+				name: index.name,
+				columns: index.columns,
+				unique: index.unique === true
+			})),
+			conflictTargets: dedupeConflictTargets(conflictTargets[tableName] ?? [])
+		});
+	}
+	if (includeSystemTables) for (const shape of getSystemTableShapes(engine).values()) tables.push({
+		name: shape.tableName,
+		origin: "system",
+		columns: shape.columns.map((column) => ({
+			name: column.name,
+			type: column.type,
+			primaryKey: column.primaryKey,
+			notNull: column.notNull || column.primaryKey,
+			unique: column.unique,
+			hasDefault: column.hasDefault
+		})),
+		indexes: shape.indexes.map((index) => ({
+			name: index.name,
+			columns: index.columns,
+			unique: index.unique
+		})),
+		conflictTargets: dedupeConflictTargets(shape.uniqueConstraints.map((columns) => ({
+			columns,
+			source: `${shape.tableName} DDL`
+		})))
+	});
+	return tables;
+}
+function dedupeConflictTargets(targets) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const target of targets) {
+		const columns = (target.columns ?? []).filter(Boolean);
+		if (columns.length === 0) continue;
+		const key = [...columns].sort().join(",");
+		if (!seen.has(key)) seen.set(key, {
+			columns,
+			source: target.source
+		});
+	}
+	return [...seen.values()];
+}
+function compareColumns(table, liveColumns, engine) {
+	const findings = [];
+	const expectedNames = new Set(table.columns.map((column) => column.name));
+	for (const column of table.columns) {
+		const live = liveColumns.get(column.name);
+		if (!live) {
+			findings.push({
+				kind: "missing_column",
+				severity: "error",
+				table: table.name,
+				target: column.name,
+				origin: table.origin,
+				message: `Column \`${table.name}.${column.name}\` is declared but missing from the live database.`,
+				recommendation: "Run `smrt db:migrate` to add the column before application writes reach this table.",
+				details: { expectedType: column.type }
+			});
+			continue;
+		}
+		if (!typesAreEquivalent(column, live, engine)) findings.push({
+			kind: "column_type_drift",
+			severity: "error",
+			table: table.name,
+			target: column.name,
+			origin: table.origin,
+			message: `Column \`${table.name}.${column.name}\` is \`${live.type}\` in the live database but declared \`${column.type}\`.`,
+			recommendation: "Reconcile the column type with `smrt db:migrate`, or repair the declaration if the live type is correct.",
+			details: {
+				expected: column.type,
+				actual: live.type
+			}
+		});
+		if (!column.primaryKey && column.notNull && !live.notNull) findings.push({
+			kind: "column_nullability_drift",
+			severity: "warning",
+			table: table.name,
+			target: column.name,
+			origin: table.origin,
+			message: `Column \`${table.name}.${column.name}\` is declared NOT NULL but is nullable in the live database.`,
+			recommendation: "Backfill any NULL values and add the NOT NULL constraint, or relax the declaration."
+		});
+		else if (!column.notNull && live.notNull && !live.hasDefault) findings.push({
+			kind: "column_nullability_drift",
+			severity: "error",
+			table: table.name,
+			target: column.name,
+			origin: table.origin,
+			message: `Column \`${table.name}.${column.name}\` is NOT NULL in the live database with no default, but is not declared NOT NULL. Inserts that omit it will fail.`,
+			recommendation: "Drop the orphan NOT NULL constraint, give the column a default, or declare the column required."
+		});
+	}
+	for (const live of liveColumns.values()) {
+		if (expectedNames.has(live.name)) continue;
+		const breaksInserts = live.notNull && !live.hasDefault;
+		findings.push({
+			kind: "extra_column",
+			severity: breaksInserts ? "error" : "info",
+			table: table.name,
+			target: live.name,
+			origin: table.origin,
+			message: breaksInserts ? `Live column \`${table.name}.${live.name}\` is undeclared, NOT NULL, and has no default — every framework insert into this table will fail.` : `Live column \`${table.name}.${live.name}\` is not declared by the current schema.`,
+			recommendation: breaksInserts ? "Drop the orphan column or give it a default; this is the residue of a renamed or removed required field." : "Confirm the column is intentional legacy data, or drop it once nothing reads it.",
+			details: { type: live.type }
+		});
+	}
+	return findings;
+}
+/**
+* Whether a live column type satisfies its declaration.
+*
+* Two tolerances match the model layer's actual conventions, and mirror the
+* migration differ so the two tools never disagree:
+*
+* - `TEXT` ↔ `UUID` for structural identifier/reference columns, because
+*   SQLite has no uuid type and older PostgreSQL deployments legitimately
+*   still carry text ids (R11).
+* - `TEXT` ↔ `JSON`/`JSONB` in both directions, because SMRT serializes JSON
+*   values into text columns and a native json column already holds exactly
+*   that (#1335).
+*/
+function typesAreEquivalent(expected, live, engine) {
+	const expectedType = normalizeSqlType(expected.type);
+	const actualType = normalizeSqlType(live.type);
+	if (expectedType === actualType) return true;
+	if ((expectedType === "UUID" && actualType === "TEXT" || expectedType === "TEXT" && actualType === "UUID") && isStructuralReference(expected)) return true;
+	if (expectedType === "JSON" && actualType === "TEXT" || expectedType === "TEXT" && actualType === "JSON") return true;
+	if (engine === "sqlite") {
+		if (expectedType === "BOOLEAN" && actualType === "INTEGER" || expectedType === "INTEGER" && actualType === "BOOLEAN") return true;
+	}
+	return false;
+}
+function isStructuralReference(column) {
+	return column.primaryKey || column.reference === "id" || column.reference === "foreignKey" || column.reference === "crossPackageRef" || column.reference === "tenantId";
+}
+/** Fold engine-specific type spellings into comparable buckets. */
+function normalizeSqlType(type) {
+	const upper = String(type ?? "").toUpperCase().trim().replace(/\(\s*[^)]*\s*\)/g, "").replace(/\[\]$/, "").trim();
+	if (/^(INTEGER|INT|INT2|INT4|INT8|BIGINT|SMALLINT|TINYINT|SERIAL|BIGSERIAL)$/.test(upper)) return "INTEGER";
+	if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR|CHARACTER|CHARACTER VARYING|NAME)$/.test(upper)) return "TEXT";
+	if (upper === "UUID") return "UUID";
+	if (/^(REAL|FLOAT|FLOAT4|FLOAT8|DOUBLE|DOUBLE PRECISION|DECIMAL|NUMERIC|NUMBER)$/.test(upper)) return "REAL";
+	if (/^(BOOLEAN|BOOL)$/.test(upper)) return "BOOLEAN";
+	if (/^(TIMESTAMPTZ|TIMESTAMP WITH TIME ZONE)$/.test(upper)) return "TIMESTAMPTZ";
+	if (/^(DATETIME|TIMESTAMP|TIMESTAMP WITHOUT TIME ZONE|DATE|TIME)$/.test(upper)) return "TIMESTAMP";
+	if (/^(BLOB|BINARY|BYTEA)$/.test(upper)) return "BLOB";
+	if (/^(JSON|JSONB)$/.test(upper)) return "JSON";
+	return upper;
+}
+function compareIndexes(table, liveColumns, liveIndexes) {
+	const findings = [];
+	const byName = new Map(liveIndexes.map((index) => [index.name, index]));
+	const signatures = new Set(liveIndexes.map((index) => indexSignature(index.columns, index.unique)));
+	for (const index of liveIndexes) {
+		if (index.valid) continue;
+		findings.push({
+			kind: "invalid_index",
+			severity: "error",
+			table: table.name,
+			target: index.name,
+			origin: table.origin,
+			message: `Index \`${index.name}\` on \`${table.name}\` is INVALID — PostgreSQL will not use it and a unique index in this state enforces nothing.`,
+			recommendation: "Drop and rebuild it (`REINDEX INDEX CONCURRENTLY`), then re-run the parity check."
+		});
+	}
+	for (const index of table.indexes) {
+		if (signatures.has(indexSignature(index.columns, index.unique))) continue;
+		if (table.conflictTargets.some((target) => sameColumnSet(index.columns, target.columns))) continue;
+		const sameName = byName.get(index.name);
+		findings.push({
+			kind: "missing_index",
+			severity: "warning",
+			table: table.name,
+			target: index.name,
+			origin: table.origin,
+			message: sameName ? `Index \`${index.name}\` on \`${table.name}\` exists but its shape drifted: declared (${index.columns.join(", ")})${index.unique ? " UNIQUE" : ""}, live (${sameName.columns.join(", ")})${sameName.unique ? " UNIQUE" : ""}.` : `Declared index \`${index.name}\` on \`${table.name}\` (${index.columns.join(", ")}) is missing from the live database.`,
+			recommendation: table.origin === "system" ? "Re-run SMRT system-table initialization to create the missing system index." : "Run `smrt db:migrate` to create the missing index."
+		});
+	}
+	for (const target of table.conflictTargets) {
+		if (target.columns.some((column) => !liveColumns.has(column))) continue;
+		const candidates = liveIndexes.filter((index) => sameColumnSet(index.columns, target.columns));
+		if (candidates.some((index) => index.unique && !index.partial)) continue;
+		const partialUnique = candidates.find((index) => index.unique && index.partial);
+		const nonUnique = candidates.find((index) => !index.unique);
+		const columnList = target.columns.join(", ");
+		const suffix = target.source ? ` (declared by ${target.source})` : "";
+		if (nonUnique) {
+			findings.push({
+				kind: "conflict_target_not_unique",
+				severity: "error",
+				table: table.name,
+				target: nonUnique.name,
+				origin: table.origin,
+				message: `Upsert conflict target \`${table.name}\` (${columnList})${suffix} is backed by \`${nonUnique.name}\`, which is not UNIQUE.`,
+				recommendation: "Recreate the index as UNIQUE (`smrt db:migrate`); until then upserts insert duplicates instead of updating."
+			});
+			continue;
+		}
+		findings.push({
+			kind: "conflict_target_unindexed",
+			severity: "error",
+			table: table.name,
+			target: partialUnique ? partialUnique.name : columnList,
+			origin: table.origin,
+			message: partialUnique ? `Upsert conflict target \`${table.name}\` (${columnList})${suffix} is backed only by the partial index \`${partialUnique.name}\`, which cannot arbitrate the upsert.` : `Upsert conflict target \`${table.name}\` (${columnList})${suffix} has no matching UNIQUE index in the live database.`,
+			recommendation: "Create a full UNIQUE index over exactly these columns (`smrt db:migrate`); PostgreSQL rejects the upsert outright and other engines duplicate rows."
+		});
+	}
+	for (const column of table.columns) {
+		if (!column.unique) continue;
+		if (!liveColumns.has(column.name)) continue;
+		if (liveIndexes.some((index) => index.unique && !index.partial && sameColumnSet(index.columns, [column.name]))) continue;
+		findings.push({
+			kind: "unique_constraint_missing",
+			severity: "error",
+			table: table.name,
+			target: column.name,
+			origin: table.origin,
+			message: `Column \`${table.name}.${column.name}\` is declared unique but no UNIQUE index enforces it in the live database.`,
+			recommendation: "De-duplicate existing values and create the UNIQUE index; the declaration is currently decorative."
+		});
+	}
+	for (const column of table.columns) {
+		if (!column.reference) continue;
+		if (column.reference === "id") continue;
+		if (!liveColumns.has(column.name)) continue;
+		if (liveIndexes.some((index) => index.columns[0] === column.name)) continue;
+		findings.push({
+			kind: "unindexed_reference",
+			severity: "warning",
+			table: table.name,
+			target: column.name,
+			origin: table.origin,
+			message: `Reference column \`${table.name}.${column.name}\` (${column.reference}) leads no index in the live database.`,
+			recommendation: "Add an index led by this column; relationship loads, joins and tenant-scoped reads currently scan the whole table.",
+			details: { referenceKind: column.reference }
+		});
+	}
+	const policyLeadColumns = new Set(table.columns.filter((column) => column.reference && column.reference !== "id").map((column) => column.name));
+	const declaredNames = new Set(table.indexes.map((index) => index.name));
+	const declaredSignatures = new Set(table.indexes.map((index) => indexSignature(index.columns, index.unique)));
+	for (const index of liveIndexes) {
+		if (index.primary) continue;
+		if (isConstraintOwnedIndexName(index.name)) continue;
+		if (policyLeadColumns.has(index.columns[0])) continue;
+		if (declaredNames.has(index.name)) continue;
+		if (declaredSignatures.has(indexSignature(index.columns, index.unique))) continue;
+		if (table.conflictTargets.some((target) => sameColumnSet(index.columns, target.columns))) continue;
+		findings.push({
+			kind: "extra_index",
+			severity: "info",
+			table: table.name,
+			target: index.name,
+			origin: table.origin,
+			message: `Live index \`${index.name}\` on \`${table.name}\` (${index.columns.join(", ") || "expression"}) is not declared by the current schema.`,
+			recommendation: "Declare it so a rebuilt database keeps it, or drop it if it is obsolete.",
+			details: {
+				unique: index.unique,
+				partial: index.partial
+			}
+		});
+	}
+	return findings;
+}
+function isConstraintOwnedIndexName(name) {
+	return name.startsWith("sqlite_autoindex_") || name.endsWith("_pkey") || name.endsWith("_key");
+}
+function indexSignature(columns, unique) {
+	return `${columns.join(",")}:${unique}`;
+}
+/**
+* Conflict targets and unique constraints are order-insensitive: PostgreSQL
+* matches `ON CONFLICT (a, b)` against a unique index on `(b, a)`.
+*/
+function sameColumnSet(left, right) {
+	if (left.length !== right.length) return false;
+	const sortedLeft = [...left].sort();
+	const sortedRight = [...right].sort();
+	return sortedLeft.every((column, index) => column === sortedRight[index]);
+}
+function resolveEngine(db, engineHint) {
+	if (typeof db.exportTable === "function") return "json";
+	const dbWithConfig = db;
+	return detectEngine(db.url || dbWithConfig.config?.url || "", engineHint);
+}
+function isInternalTableName(name) {
+	return name.startsWith("sqlite_") || name.startsWith("pg_") || name.startsWith("duckdb_") || name === "information_schema";
+}
+async function listLiveTables(db, engine) {
+	const sql = engine === "postgres" ? `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'` : `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
+	try {
+		const rows = (await db.query(sql))?.rows ?? [];
+		return new Set(rows.map((row) => row.name || row.table_name || "").filter(Boolean));
+	} catch (error) {
+		throw new LiveSchemaParityError(`Could not list tables in the live database: ${describeError(error)}`, { cause: error });
+	}
+}
+async function readLiveColumns(db, tableName) {
+	if (typeof db.getTableSchema !== "function") throw new LiveSchemaParityError("The configured database adapter cannot describe tables (`getTableSchema` is unavailable), so live-schema parity cannot be verified.");
+	let schema;
+	try {
+		schema = await db.getTableSchema(tableName);
+	} catch (error) {
+		throw new LiveSchemaParityError(`Could not read the live schema of \`${tableName}\`: ${describeError(error)}`, { cause: error });
+	}
+	const columns = /* @__PURE__ */ new Map();
+	for (const [name, column] of Object.entries(schema?.columns ?? {})) columns.set(name, {
+		name,
+		type: String(column?.type ?? ""),
+		notNull: column?.notNull === true,
+		primaryKey: column?.primaryKey === true,
+		hasDefault: column?.defaultValue !== void 0 && column?.defaultValue !== null
+	});
+	return columns;
+}
+/**
+* Build an index reader for the engine, or `null` when index metadata cannot
+* be read. A null catalog disables every index-class check rather than
+* reporting indexes as missing on an engine we cannot introspect.
+*/
+async function readIndexCatalog(db, engine) {
+	if (engine === "postgres") return readPostgresIndexCatalog(db);
+	if (engine === "sqlite") return { forTable: (tableName) => readSqliteIndexes(db, tableName) };
+	return readDuckDbIndexCatalog(db);
+}
+async function readPostgresIndexCatalog(db) {
+	const sql = `
+    SELECT t.relname AS table_name,
+           c.relname AS index_name,
+           i.indisunique AS is_unique,
+           i.indisprimary AS is_primary,
+           i.indisvalid AS is_valid,
+           (i.indpred IS NOT NULL) AS is_partial,
+           pg_get_indexdef(i.indexrelid) AS index_def
+      FROM pg_index i
+      JOIN pg_class c ON c.oid = i.indexrelid
+      JOIN pg_class t ON t.oid = i.indrelid
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+     WHERE n.nspname = 'public'`;
+	let rows;
+	try {
+		rows = (await db.query(sql))?.rows ?? [];
+	} catch (error) {
+		throw new LiveSchemaParityError(`Could not read the PostgreSQL index catalog: ${describeError(error)}`, { cause: error });
+	}
+	const byTable = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const tableName = String(row.table_name ?? "");
+		if (!tableName) continue;
+		const bucket = byTable.get(tableName) ?? [];
+		bucket.push({
+			name: String(row.index_name ?? ""),
+			columns: parseIndexDefColumns(String(row.index_def ?? "")),
+			unique: toBoolean(row.is_unique),
+			primary: toBoolean(row.is_primary),
+			valid: row.is_valid === void 0 ? true : toBoolean(row.is_valid),
+			partial: toBoolean(row.is_partial)
+		});
+		byTable.set(tableName, bucket);
+	}
+	return { forTable: async (tableName) => byTable.get(tableName) ?? [] };
+}
+/**
+* Extract the indexed column list from a `CREATE INDEX` definition.
+*
+* Expression components (`lower(name)`, `(meta ->> 'x')`) are kept verbatim so
+* they never collide with a plain column of the same name; ordering is
+* preserved because leading-column coverage is what the policy checks.
+*/
+function parseIndexDefColumns(indexDef) {
+	const open = indexDef.indexOf("(");
+	if (open === -1) return [];
+	let depth = 0;
+	let end = -1;
+	for (let i = open; i < indexDef.length; i++) if (indexDef[i] === "(") depth++;
+	else if (indexDef[i] === ")") {
+		depth--;
+		if (depth === 0) {
+			end = i;
+			break;
+		}
+	}
+	if (end === -1) return [];
+	const body = indexDef.slice(open + 1, end);
+	const parts = [];
+	let current = "";
+	depth = 0;
+	for (const char of body) {
+		if (char === "(") depth++;
+		if (char === ")") depth--;
+		if (char === "," && depth === 0) {
+			parts.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	parts.push(current);
+	return parts.map((part) => part.trim().replace(/\s+(ASC|DESC|NULLS\s+(FIRST|LAST)|[a-z_]+_ops)\b/gi, "").trim().replace(/^"(.*)"$/, "$1")).filter((part) => part.length > 0);
+}
+async function readSqliteIndexes(db, tableName) {
+	let listRows;
+	try {
+		listRows = (await db.query(`SELECT * FROM pragma_index_list(${quoteLiteral(tableName)})`))?.rows ?? [];
+	} catch (error) {
+		throw new LiveSchemaParityError(`Could not read SQLite indexes for \`${tableName}\`: ${describeError(error)}`, { cause: error });
+	}
+	const indexes = [];
+	for (const row of listRows) {
+		const name = String(row.name ?? "");
+		if (!name) continue;
+		const columns = ((await db.query(`SELECT * FROM pragma_index_info(${quoteLiteral(name)})`))?.rows ?? []).slice().sort((left, right) => Number(left.seqno ?? 0) - Number(right.seqno ?? 0)).map((infoRow) => infoRow.name == null ? "" : String(infoRow.name)).filter((column) => column.length > 0);
+		indexes.push({
+			name,
+			columns,
+			unique: toBoolean(row.unique),
+			primary: String(row.origin ?? "") === "pk",
+			valid: true,
+			partial: toBoolean(row.partial)
+		});
+	}
+	return indexes;
+}
+async function readDuckDbIndexCatalog(db) {
+	const byTable = /* @__PURE__ */ new Map();
+	try {
+		const result = await db.query(`SELECT table_name, index_name, is_unique, sql FROM duckdb_indexes()`);
+		for (const row of result?.rows ?? []) {
+			const tableName = String(row.table_name ?? "");
+			if (!tableName) continue;
+			const bucket = byTable.get(tableName) ?? [];
+			bucket.push({
+				name: String(row.index_name ?? ""),
+				columns: parseIndexDefColumns(String(row.sql ?? "")),
+				unique: toBoolean(row.is_unique),
+				primary: false,
+				valid: true,
+				partial: false
+			});
+			byTable.set(tableName, bucket);
+		}
+	} catch {
+		return null;
+	}
+	try {
+		const result = await db.query(`SELECT table_name, constraint_type, constraint_column_names FROM duckdb_constraints()`);
+		for (const row of result?.rows ?? []) {
+			const constraintType = String(row.constraint_type ?? "").toUpperCase();
+			if (constraintType !== "UNIQUE" && constraintType !== "PRIMARY KEY") continue;
+			const tableName = String(row.table_name ?? "");
+			const columns = normalizeColumnNameList(row.constraint_column_names);
+			if (!tableName || columns.length === 0) continue;
+			const bucket = byTable.get(tableName) ?? [];
+			bucket.push({
+				name: `${tableName}_${columns.join("_")}_${constraintType === "UNIQUE" ? "key" : "pkey"}`,
+				columns,
+				unique: true,
+				primary: constraintType === "PRIMARY KEY",
+				valid: true,
+				partial: false
+			});
+			byTable.set(tableName, bucket);
+		}
+	} catch {
+		return null;
+	}
+	return { forTable: async (tableName) => byTable.get(tableName) ?? [] };
+}
+function normalizeColumnNameList(value) {
+	if (Array.isArray(value)) return value.map((entry) => String(entry)).filter(Boolean);
+	if (typeof value === "string") return value.replace(/^[[{]|[\]}]$/g, "").split(",").map((entry) => entry.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+	return [];
+}
+function toBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value !== 0;
+	if (typeof value === "string") return value === "1" || value.toLowerCase() === "true" || value === "t";
+	return false;
+}
+function quoteLiteral(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function describeError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { LiveSchemaParityError, checkLiveSchemaParity, normalizeSqlType, parseIndexDefColumns };
+
+//# sourceMappingURL=live-parity.js.map