@prisma-next/family-sql 0.3.0-pr.93.4 → 0.3.0-pr.94.1

package/dist/verify-sql-schema-BnLVoeWI.mjs

@@ -0,0 +1,686 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/core/schema-verify/verify-helpers.ts
+/**
+* Compares two arrays of strings for equality (order-sensitive).
+*/
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* Checks if a unique constraint requirement is satisfied by the given columns.
+*
+* Semantic satisfaction: a unique constraint requirement can be satisfied by:
+* - A unique constraint with the same columns, OR
+* - A unique index with the same columns
+*
+* @param uniques - The unique constraints in the schema table
+* @param indexes - The indexes in the schema table
+* @param columns - The columns required by the unique constraint
+* @returns true if the requirement is satisfied
+*/
+function isUniqueConstraintSatisfied(uniques, indexes, columns) {
+	if (uniques.some((unique) => arraysEqual(unique.columns, columns))) return true;
+	return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
+}
+/**
+* Checks if an index requirement is satisfied by the given columns.
+*
+* Semantic satisfaction: a non-unique index requirement can be satisfied by:
+* - Any index (unique or non-unique) with the same columns, OR
+* - A unique constraint with the same columns (stronger satisfies weaker)
+*
+* @param indexes - The indexes in the schema table
+* @param uniques - The unique constraints in the schema table
+* @param columns - The columns required by the index
+* @returns true if the requirement is satisfied
+*/
+function isIndexSatisfied(indexes, uniques, columns) {
+	if (indexes.some((index) => arraysEqual(index.columns, columns))) return true;
+	return uniques.some((unique) => arraysEqual(unique.columns, columns));
+}
+/**
+* Verifies primary key matches between contract and schema.
+* Returns 'pass' or 'fail'.
+*
+* Uses semantic satisfaction: identity is based on (table + kind + columns).
+* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
+*/
+function verifyPrimaryKey(contractPK, schemaPK, tableName, issues) {
+	if (!schemaPK) {
+		issues.push({
+			kind: "primary_key_mismatch",
+			table: tableName,
+			expected: contractPK.columns.join(", "),
+			message: `Table "${tableName}" is missing primary key`
+		});
+		return "fail";
+	}
+	if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
+		issues.push({
+			kind: "primary_key_mismatch",
+			table: tableName,
+			expected: contractPK.columns.join(", "),
+			actual: schemaPK.columns.join(", "),
+			message: `Table "${tableName}" has primary key mismatch: expected columns [${contractPK.columns.join(", ")}], got [${schemaPK.columns.join(", ")}]`
+		});
+		return "fail";
+	}
+	return "pass";
+}
+/**
+* Verifies foreign keys match between contract and schema.
+* Returns verification nodes for the tree.
+*
+* Uses semantic satisfaction: identity is based on (table + columns + referenced table + referenced columns).
+* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
+*/
+function verifyForeignKeys(contractFKs, schemaFKs, tableName, tablePath, issues, strict) {
+	const nodes = [];
+	for (const contractFK of contractFKs) {
+		const fkPath = `${tablePath}.foreignKeys[${contractFK.columns.join(",")}]`;
+		if (!schemaFKs.find((fk) => {
+			return arraysEqual(fk.columns, contractFK.columns) && fk.referencedTable === contractFK.references.table && arraysEqual(fk.referencedColumns, contractFK.references.columns);
+		})) {
+			issues.push({
+				kind: "foreign_key_mismatch",
+				table: tableName,
+				expected: `${contractFK.columns.join(", ")} -> ${contractFK.references.table}(${contractFK.references.columns.join(", ")})`,
+				message: `Table "${tableName}" is missing foreign key: ${contractFK.columns.join(", ")} -> ${contractFK.references.table}(${contractFK.references.columns.join(", ")})`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "foreignKey",
+				name: `foreignKey(${contractFK.columns.join(", ")})`,
+				contractPath: fkPath,
+				code: "foreign_key_mismatch",
+				message: "Foreign key missing",
+				expected: contractFK,
+				actual: void 0,
+				children: []
+			});
+		} else nodes.push({
+			status: "pass",
+			kind: "foreignKey",
+			name: `foreignKey(${contractFK.columns.join(", ")})`,
+			contractPath: fkPath,
+			code: "",
+			message: "",
+			expected: void 0,
+			actual: void 0,
+			children: []
+		});
+	}
+	if (strict) {
+		for (const schemaFK of schemaFKs) if (!contractFKs.find((fk) => {
+			return arraysEqual(fk.columns, schemaFK.columns) && fk.references.table === schemaFK.referencedTable && arraysEqual(fk.references.columns, schemaFK.referencedColumns);
+		})) {
+			issues.push({
+				kind: "extra_foreign_key",
+				table: tableName,
+				message: `Extra foreign key found in database (not in contract): ${schemaFK.columns.join(", ")} -> ${schemaFK.referencedTable}(${schemaFK.referencedColumns.join(", ")})`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "foreignKey",
+				name: `foreignKey(${schemaFK.columns.join(", ")})`,
+				contractPath: `${tablePath}.foreignKeys[${schemaFK.columns.join(",")}]`,
+				code: "extra_foreign_key",
+				message: "Extra foreign key found",
+				expected: void 0,
+				actual: schemaFK,
+				children: []
+			});
+		}
+	}
+	return nodes;
+}
+/**
+* Verifies unique constraints match between contract and schema.
+* Returns verification nodes for the tree.
+*
+* Uses semantic satisfaction: identity is based on (table + kind + columns).
+* A unique constraint requirement can be satisfied by either:
+* - A unique constraint with the same columns, or
+* - A unique index with the same columns
+*
+* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
+*/
+function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes, tableName, tablePath, issues, strict) {
+	const nodes = [];
+	for (const contractUnique of contractUniques) {
+		const uniquePath = `${tablePath}.uniques[${contractUnique.columns.join(",")}]`;
+		const matchingUnique = schemaUniques.find((u) => arraysEqual(u.columns, contractUnique.columns));
+		const matchingUniqueIndex = !matchingUnique && schemaIndexes.find((idx) => idx.unique && arraysEqual(idx.columns, contractUnique.columns));
+		if (!matchingUnique && !matchingUniqueIndex) {
+			issues.push({
+				kind: "unique_constraint_mismatch",
+				table: tableName,
+				expected: contractUnique.columns.join(", "),
+				message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(", ")}`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "unique",
+				name: `unique(${contractUnique.columns.join(", ")})`,
+				contractPath: uniquePath,
+				code: "unique_constraint_mismatch",
+				message: "Unique constraint missing",
+				expected: contractUnique,
+				actual: void 0,
+				children: []
+			});
+		} else nodes.push({
+			status: "pass",
+			kind: "unique",
+			name: `unique(${contractUnique.columns.join(", ")})`,
+			contractPath: uniquePath,
+			code: "",
+			message: "",
+			expected: void 0,
+			actual: void 0,
+			children: []
+		});
+	}
+	if (strict) {
+		for (const schemaUnique of schemaUniques) if (!contractUniques.find((u) => arraysEqual(u.columns, schemaUnique.columns))) {
+			issues.push({
+				kind: "extra_unique_constraint",
+				table: tableName,
+				message: `Extra unique constraint found in database (not in contract): ${schemaUnique.columns.join(", ")}`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "unique",
+				name: `unique(${schemaUnique.columns.join(", ")})`,
+				contractPath: `${tablePath}.uniques[${schemaUnique.columns.join(",")}]`,
+				code: "extra_unique_constraint",
+				message: "Extra unique constraint found",
+				expected: void 0,
+				actual: schemaUnique,
+				children: []
+			});
+		}
+	}
+	return nodes;
+}
+/**
+* Verifies indexes match between contract and schema.
+* Returns verification nodes for the tree.
+*
+* Uses semantic satisfaction: identity is based on (table + kind + columns).
+* A non-unique index requirement can be satisfied by either:
+* - A non-unique index with the same columns, or
+* - A unique index with the same columns (stronger satisfies weaker)
+*
+* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
+*/
+function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName, tablePath, issues, strict) {
+	const nodes = [];
+	for (const contractIndex of contractIndexes) {
+		const indexPath = `${tablePath}.indexes[${contractIndex.columns.join(",")}]`;
+		const matchingIndex = schemaIndexes.find((idx) => arraysEqual(idx.columns, contractIndex.columns));
+		const matchingUniqueConstraint = !matchingIndex && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
+		if (!matchingIndex && !matchingUniqueConstraint) {
+			issues.push({
+				kind: "index_mismatch",
+				table: tableName,
+				expected: contractIndex.columns.join(", "),
+				message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(", ")}`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "index",
+				name: `index(${contractIndex.columns.join(", ")})`,
+				contractPath: indexPath,
+				code: "index_mismatch",
+				message: "Index missing",
+				expected: contractIndex,
+				actual: void 0,
+				children: []
+			});
+		} else nodes.push({
+			status: "pass",
+			kind: "index",
+			name: `index(${contractIndex.columns.join(", ")})`,
+			contractPath: indexPath,
+			code: "",
+			message: "",
+			expected: void 0,
+			actual: void 0,
+			children: []
+		});
+	}
+	if (strict) for (const schemaIndex of schemaIndexes) {
+		if (schemaIndex.unique) continue;
+		if (!contractIndexes.find((idx) => arraysEqual(idx.columns, schemaIndex.columns))) {
+			issues.push({
+				kind: "extra_index",
+				table: tableName,
+				message: `Extra index found in database (not in contract): ${schemaIndex.columns.join(", ")}`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "index",
+				name: `index(${schemaIndex.columns.join(", ")})`,
+				contractPath: `${tablePath}.indexes[${schemaIndex.columns.join(",")}]`,
+				code: "extra_index",
+				message: "Extra index found",
+				expected: void 0,
+				actual: schemaIndex,
+				children: []
+			});
+		}
+	}
+	return nodes;
+}
+/**
+* Verifies database dependencies are installed using component-owned verification hooks.
+* Each dependency provides a pure verifyDatabaseDependencyInstalled function that checks
+* whether the dependency is satisfied based on the in-memory schema IR (no DB I/O).
+*
+* Returns verification nodes for the tree.
+*/
+function verifyDatabaseDependencies(dependencies, schema, issues) {
+	const nodes = [];
+	for (const dependency of dependencies) {
+		const depIssues = dependency.verifyDatabaseDependencyInstalled(schema);
+		const depPath = `dependencies.${dependency.id}`;
+		if (depIssues.length > 0) {
+			issues.push(...depIssues);
+			const issuesMessage = depIssues.map((i) => i.message).join("; ");
+			const nodeMessage = issuesMessage ? `${dependency.id}: ${issuesMessage}` : dependency.id;
+			nodes.push({
+				status: "fail",
+				kind: "databaseDependency",
+				name: dependency.label,
+				contractPath: depPath,
+				code: "dependency_missing",
+				message: nodeMessage,
+				expected: void 0,
+				actual: void 0,
+				children: []
+			});
+		} else nodes.push({
+			status: "pass",
+			kind: "databaseDependency",
+			name: dependency.label,
+			contractPath: depPath,
+			code: "",
+			message: "",
+			expected: void 0,
+			actual: void 0,
+			children: []
+		});
+	}
+	return nodes;
+}
+/**
+* Computes counts of pass/warn/fail nodes by traversing the tree.
+*/
+function computeCounts(node) {
+	let pass = 0;
+	let warn = 0;
+	let fail = 0;
+	function traverse(n) {
+		if (n.status === "pass") pass++;
+		else if (n.status === "warn") warn++;
+		else if (n.status === "fail") fail++;
+		if (n.children) for (const child of n.children) traverse(child);
+	}
+	traverse(node);
+	return {
+		pass,
+		warn,
+		fail,
+		totalNodes: pass + warn + fail
+	};
+}
+
+//#endregion
+//#region src/core/schema-verify/verify-sql-schema.ts
+/**
+* Verifies that a SqlSchemaIR matches a SqlContract.
+*
+* This is a pure function that does NOT perform any database I/O.
+* It takes an already-introspected schema IR and compares it against
+* the contract requirements.
+*
+* @param options - Verification options
+* @returns VerifyDatabaseSchemaResult with verification tree and issues
+*/
+function verifySqlSchema(options) {
+	const { contract, schema, strict, context, typeMetadataRegistry } = options;
+	const startTime = Date.now();
+	const contractCoreHash = contract.coreHash;
+	const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : void 0;
+	const contractTarget = contract.target;
+	const issues = [];
+	const rootChildren = [];
+	const contractTables = contract.storage.tables;
+	const schemaTables = schema.tables;
+	for (const [tableName, contractTable] of Object.entries(contractTables)) {
+		const schemaTable = schemaTables[tableName];
+		const tablePath = `storage.tables.${tableName}`;
+		if (!schemaTable) {
+			issues.push({
+				kind: "missing_table",
+				table: tableName,
+				message: `Table "${tableName}" is missing from database`
+			});
+			rootChildren.push({
+				status: "fail",
+				kind: "table",
+				name: `table ${tableName}`,
+				contractPath: tablePath,
+				code: "missing_table",
+				message: `Table "${tableName}" is missing`,
+				expected: void 0,
+				actual: void 0,
+				children: []
+			});
+			continue;
+		}
+		const tableChildren = [];
+		const columnNodes = [];
+		for (const [columnName, contractColumn] of Object.entries(contractTable.columns)) {
+			const schemaColumn = schemaTable.columns[columnName];
+			const columnPath = `${tablePath}.columns.${columnName}`;
+			if (!schemaColumn) {
+				issues.push({
+					kind: "missing_column",
+					table: tableName,
+					column: columnName,
+					message: `Column "${tableName}"."${columnName}" is missing from database`
+				});
+				columnNodes.push({
+					status: "fail",
+					kind: "column",
+					name: `${columnName}: missing`,
+					contractPath: columnPath,
+					code: "missing_column",
+					message: `Column "${columnName}" is missing`,
+					expected: void 0,
+					actual: void 0,
+					children: []
+				});
+				continue;
+			}
+			const columnChildren = [];
+			let columnStatus = "pass";
+			const contractNativeType = contractColumn.nativeType;
+			const schemaNativeType = schemaColumn.nativeType;
+			if (contractNativeType !== schemaNativeType) {
+				issues.push({
+					kind: "type_mismatch",
+					table: tableName,
+					column: columnName,
+					expected: contractNativeType,
+					actual: schemaNativeType,
+					message: `Column "${tableName}"."${columnName}" has type mismatch: expected "${contractNativeType}", got "${schemaNativeType}"`
+				});
+				columnChildren.push({
+					status: "fail",
+					kind: "type",
+					name: "type",
+					contractPath: `${columnPath}.nativeType`,
+					code: "type_mismatch",
+					message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
+					expected: contractNativeType,
+					actual: schemaNativeType,
+					children: []
+				});
+				columnStatus = "fail";
+			}
+			if (contractColumn.codecId) {
+				const typeMetadata = typeMetadataRegistry.get(contractColumn.codecId);
+				if (!typeMetadata) columnChildren.push({
+					status: "warn",
+					kind: "type",
+					name: "type_metadata_missing",
+					contractPath: `${columnPath}.codecId`,
+					code: "type_metadata_missing",
+					message: `codecId "${contractColumn.codecId}" not found in type metadata registry`,
+					expected: contractColumn.codecId,
+					actual: void 0,
+					children: []
+				});
+				else if (typeMetadata.nativeType && typeMetadata.nativeType !== contractNativeType) columnChildren.push({
+					status: "warn",
+					kind: "type",
+					name: "type_consistency",
+					contractPath: `${columnPath}.codecId`,
+					code: "type_consistency_warning",
+					message: `codecId "${contractColumn.codecId}" maps to nativeType "${typeMetadata.nativeType}" in registry, but contract has "${contractNativeType}"`,
+					expected: typeMetadata.nativeType,
+					actual: contractNativeType,
+					children: []
+				});
+			}
+			if (contractColumn.nullable !== schemaColumn.nullable) {
+				issues.push({
+					kind: "nullability_mismatch",
+					table: tableName,
+					column: columnName,
+					expected: String(contractColumn.nullable),
+					actual: String(schemaColumn.nullable),
+					message: `Column "${tableName}"."${columnName}" has nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`
+				});
+				columnChildren.push({
+					status: "fail",
+					kind: "nullability",
+					name: "nullability",
+					contractPath: `${columnPath}.nullable`,
+					code: "nullability_mismatch",
+					message: `Nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`,
+					expected: contractColumn.nullable,
+					actual: schemaColumn.nullable,
+					children: []
+				});
+				columnStatus = "fail";
+			}
+			const computedColumnStatus = columnChildren.some((c) => c.status === "fail") ? "fail" : columnChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+			const finalColumnStatus = columnChildren.length > 0 ? computedColumnStatus : columnStatus;
+			const nullableText = contractColumn.nullable ? "nullable" : "not nullable";
+			const columnTypeDisplay = contractColumn.codecId ? `${contractNativeType} (${contractColumn.codecId})` : contractNativeType;
+			const failureMessages = columnChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
+			const columnMessage = finalColumnStatus === "fail" && failureMessages.length > 0 ? failureMessages.join("; ") : "";
+			const columnCode = (finalColumnStatus === "fail" || finalColumnStatus === "warn") && columnChildren[0] ? columnChildren[0].code : "";
+			columnNodes.push({
+				status: finalColumnStatus,
+				kind: "column",
+				name: `${columnName}: ${columnTypeDisplay} (${nullableText})`,
+				contractPath: columnPath,
+				code: columnCode,
+				message: columnMessage,
+				expected: void 0,
+				actual: void 0,
+				children: columnChildren
+			});
+		}
+		if (columnNodes.length > 0) {
+			const columnsStatus = columnNodes.some((c) => c.status === "fail") ? "fail" : columnNodes.some((c) => c.status === "warn") ? "warn" : "pass";
+			tableChildren.push({
+				status: columnsStatus,
+				kind: "columns",
+				name: "columns",
+				contractPath: `${tablePath}.columns`,
+				code: "",
+				message: "",
+				expected: void 0,
+				actual: void 0,
+				children: columnNodes
+			});
+		}
+		if (strict) {
+			for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) if (!contractTable.columns[columnName]) {
+				issues.push({
+					kind: "extra_column",
+					table: tableName,
+					column: columnName,
+					message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`
+				});
+				columnNodes.push({
+					status: "fail",
+					kind: "column",
+					name: `${columnName}: extra`,
+					contractPath: `${tablePath}.columns.${columnName}`,
+					code: "extra_column",
+					message: `Extra column "${columnName}" found`,
+					expected: void 0,
+					actual: nativeType,
+					children: []
+				});
+			}
+		}
+		if (contractTable.primaryKey) if (verifyPrimaryKey(contractTable.primaryKey, schemaTable.primaryKey, tableName, issues) === "fail") tableChildren.push({
+			status: "fail",
+			kind: "primaryKey",
+			name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+			contractPath: `${tablePath}.primaryKey`,
+			code: "primary_key_mismatch",
+			message: "Primary key mismatch",
+			expected: contractTable.primaryKey,
+			actual: schemaTable.primaryKey,
+			children: []
+		});
+		else tableChildren.push({
+			status: "pass",
+			kind: "primaryKey",
+			name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+			contractPath: `${tablePath}.primaryKey`,
+			code: "",
+			message: "",
+			expected: void 0,
+			actual: void 0,
+			children: []
+		});
+		else if (schemaTable.primaryKey && strict) {
+			issues.push({
+				kind: "extra_primary_key",
+				table: tableName,
+				message: "Extra primary key found in database (not in contract)"
+			});
+			tableChildren.push({
+				status: "fail",
+				kind: "primaryKey",
+				name: `primary key: ${schemaTable.primaryKey.columns.join(", ")}`,
+				contractPath: `${tablePath}.primaryKey`,
+				code: "extra_primary_key",
+				message: "Extra primary key found",
+				expected: void 0,
+				actual: schemaTable.primaryKey,
+				children: []
+			});
+		}
+		const fkStatuses = verifyForeignKeys(contractTable.foreignKeys, schemaTable.foreignKeys, tableName, tablePath, issues, strict);
+		tableChildren.push(...fkStatuses);
+		const uniqueStatuses = verifyUniqueConstraints(contractTable.uniques, schemaTable.uniques, schemaTable.indexes, tableName, tablePath, issues, strict);
+		tableChildren.push(...uniqueStatuses);
+		const indexStatuses = verifyIndexes(contractTable.indexes, schemaTable.indexes, schemaTable.uniques, tableName, tablePath, issues, strict);
+		tableChildren.push(...indexStatuses);
+		const tableStatus = tableChildren.some((c) => c.status === "fail") ? "fail" : tableChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+		const tableFailureMessages = tableChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
+		const tableMessage = tableStatus === "fail" && tableFailureMessages.length > 0 ? `${tableFailureMessages.length} issue${tableFailureMessages.length === 1 ? "" : "s"}` : "";
+		const tableCode = tableStatus === "fail" && tableChildren.length > 0 && tableChildren[0] ? tableChildren[0].code : "";
+		rootChildren.push({
+			status: tableStatus,
+			kind: "table",
+			name: `table ${tableName}`,
+			contractPath: tablePath,
+			code: tableCode,
+			message: tableMessage,
+			expected: void 0,
+			actual: void 0,
+			children: tableChildren
+		});
+	}
+	if (strict) {
+		for (const tableName of Object.keys(schemaTables)) if (!contractTables[tableName]) {
+			issues.push({
+				kind: "extra_table",
+				table: tableName,
+				message: `Extra table "${tableName}" found in database (not in contract)`
+			});
+			rootChildren.push({
+				status: "fail",
+				kind: "table",
+				name: `table ${tableName}`,
+				contractPath: `storage.tables.${tableName}`,
+				code: "extra_table",
+				message: `Extra table "${tableName}" found`,
+				expected: void 0,
+				actual: void 0,
+				children: []
+			});
+		}
+	}
+	const contractExtensionPacks = contract.extensionPacks ?? {};
+	for (const extensionNamespace of Object.keys(contractExtensionPacks)) if (!options.frameworkComponents.some((component) => component.id === extensionNamespace && (component.kind === "extension" || component.kind === "adapter" || component.kind === "target"))) throw new Error(`Extension pack '${extensionNamespace}' is declared in the contract but not found in framework components. This indicates a configuration mismatch - the contract was emitted with this extension pack, but it is not provided in the current configuration.`);
+	const dependencyStatuses = verifyDatabaseDependencies(collectDependenciesFromFrameworkComponents(options.frameworkComponents), schema, issues);
+	rootChildren.push(...dependencyStatuses);
+	const root = {
+		status: rootChildren.some((c) => c.status === "fail") ? "fail" : rootChildren.some((c) => c.status === "warn") ? "warn" : "pass",
+		kind: "contract",
+		name: "contract",
+		contractPath: "",
+		code: "",
+		message: "",
+		expected: void 0,
+		actual: void 0,
+		children: rootChildren
+	};
+	const counts = computeCounts(root);
+	const ok = counts.fail === 0;
+	const code = ok ? void 0 : "PN-SCHEMA-0001";
+	const summary = ok ? "Database schema satisfies contract" : `Database schema does not satisfy contract (${counts.fail} failure${counts.fail === 1 ? "" : "s"})`;
+	const totalTime = Date.now() - startTime;
+	return {
+		ok,
+		...ifDefined("code", code),
+		summary,
+		contract: {
+			coreHash: contractCoreHash,
+			...ifDefined("profileHash", contractProfileHash)
+		},
+		target: {
+			expected: contractTarget,
+			actual: contractTarget
+		},
+		schema: {
+			issues,
+			root,
+			counts
+		},
+		meta: {
+			strict,
+			...ifDefined("contractPath", context?.contractPath),
+			...ifDefined("configPath", context?.configPath)
+		},
+		timings: { total: totalTime }
+	};
+}
+/**
+* Type predicate to check if a component has database dependencies with an init array.
+* The familyId check is redundant since TargetBoundComponentDescriptor<'sql', T> already
+* guarantees familyId is 'sql' at the type level, so we don't need runtime checks for it.
+*/
+function hasDatabaseDependenciesInit(component) {
+	if (!("databaseDependencies" in component)) return false;
+	const dbDeps = component["databaseDependencies"];
+	if (dbDeps === void 0 || dbDeps === null || typeof dbDeps !== "object") return false;
+	const init = dbDeps["init"];
+	if (init === void 0 || !Array.isArray(init)) return false;
+	return true;
+}
+function collectDependenciesFromFrameworkComponents(components) {
+	const dependencies = [];
+	for (const component of components) if (hasDatabaseDependenciesInit(component)) dependencies.push(...component.databaseDependencies.init);
+	return dependencies;
+}
+
+//#endregion
+export { verifyDatabaseDependencies as a, isUniqueConstraintSatisfied as i, arraysEqual as n, isIndexSatisfied as r, verifySqlSchema as t };
+//# sourceMappingURL=verify-sql-schema-BnLVoeWI.mjs.map