@prisma-next/family-sql 0.14.0-dev.49 → 0.14.0-dev.50

package/dist/control.mjs

@@ -1,18 +1,19 @@
 import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CXd-8ydc.mjs";
-import { t as SqlContractSerializer } from "./sql-contract-serializer-DwUSJ4PO.mjs";
+import { n as classifyDiffSubjectGranularity, o as verifySqlSchemaByDiff, s as extractCodecControlHooks, t as classifyDiffEntityKind } from "./schema-verify-W3r631Jh.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-C75cfMSS.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-C-G0obRm.mjs";
-import { a as extractCodecControlHooks, i as resolveValueSetValues, n as contractToSchemaIR, r as detectDestructiveChanges, t as contractNamespaceToSchemaIR } from "./contract-to-schema-ir-S-evq8E6.mjs";
 import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-CloimujU.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
 import { blindCast } from "@prisma-next/utils/casts";
-import { effectiveControlPolicy } from "@prisma-next/contract/types";
-import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, dispositionForCategory } from "@prisma-next/framework-components/control";
+import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
 import { isPlainRecord } from "@prisma-next/framework-components/ir";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { StorageTable } from "@prisma-next/sql-contract/types";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
+import { StorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIR, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -210,12 +211,13 @@ function createSqlFamilyInstance(stack) {
 	const getControlAdapter = () => controlAdapter ??= adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
 	const targetInferPslContract = blindCast(target).inferPslContract;
+	const diffSchema = blindCast(target).diffSchema;
+	const targetGranularityOf = blindCast(target).classifySubjectGranularity;
+	const targetEntityKindOf = blindCast(target).classifyEntityKind;
 	const describedContracts = extensions.flatMap((extension) => extension.contractSpace ? [{
 		spaceId: extension.id,
 		contract: extension.contractSpace.contractJson
 	}] : []);
-	const verifyDatabaseSchema = blindCast(target).verifyDatabaseSchema;
-	if (!verifyDatabaseSchema) throw new Error(`SQL target "${target.targetId}" is missing the required verifyDatabaseSchema descriptor operation`);
 	const deserializeWithTargetSerializer = (contractOrJson) => {
 		const serializer = targetSerializer ?? new SqlContractSerializer();
 		const json = targetSerializer !== void 0 && !isPlainRecord(contractOrJson) ? targetSerializer.serializeContract(blindCast(contractOrJson)) : contractOrJson;
@@ -322,40 +324,40 @@ function createSqlFamilyInstance(stack) {
 		},
 		verifySchema(options) {
 			const contract = deserializeWithTargetSerializer(options.contract);
-			const sqlResult = verifyDatabaseSchema({
+			if (!diffSchema) throw new Error(`SQL target "${target.targetId}" is missing the required diffSchema descriptor operation`);
+			if (!targetGranularityOf) throw new Error(`SQL target "${target.targetId}" is missing the required classifySubjectGranularity descriptor operation`);
+			return verifySqlSchemaByDiff({
 				contract,
 				schema: options.schema,
 				strict: options.strict,
-				typeMetadataRegistry,
-				frameworkComponents: options.frameworkComponents
+				frameworkComponents: options.frameworkComponents,
+				diffSchema,
+				granularityOf: targetGranularityOf
 			});
-			const schemaDiffIssues = filterSchemaDiffIssues(sqlResult.schema.schemaDiffIssues, contract.defaultControlPolicy);
-			const relationalFails = sqlResult.schema.counts.fail;
-			if (schemaDiffIssues.length === 0) {
-				if (schemaDiffIssues === sqlResult.schema.schemaDiffIssues) return sqlResult;
-				return {
-					...sqlResult,
-					schema: {
-						...sqlResult.schema,
-						schemaDiffIssues
-					}
-				};
-			}
-			const totalFails = relationalFails + schemaDiffIssues.length;
-			return {
-				...sqlResult,
-				ok: false,
-				code: sqlResult.code ?? "PN-RUN-3010",
-				summary: `Database schema does not satisfy contract (${totalFails} failure${totalFails === 1 ? "" : "s"})`,
-				schema: {
-					...sqlResult.schema,
-					schemaDiffIssues,
-					counts: {
-						...sqlResult.schema.counts,
-						fail: totalFails
-					}
-				}
-			};
+		},
+		/**
+		* Classifies a diff issue's subject granularity on demand, by resolving
+		* its node's `nodeKind` through the target's classifier — the
+		* {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability. Framework consumers spanning contract spaces (the
+		* migration aggregate's unclaimed-elements sweep) detect and call this
+		* instead of reaching into the concrete schema-IR node, which they
+		* cannot read; nothing is stamped on the issue or the node.
+		*/
+		classifySubjectGranularity(issue) {
+			if (!targetGranularityOf) throw new Error(`SQL target "${target.targetId}" is missing the required classifySubjectGranularity descriptor operation`);
+			return classifyDiffSubjectGranularity(issue, targetGranularityOf);
+		},
+		/**
+		* Classifies a diff issue's subject storage `entityKind` on demand, by
+		* resolving its node's `nodeKind` through the target's classifier —
+		* the sibling of `classifySubjectGranularity` above, and part of the
+		* same {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability.
+		*/
+		classifyEntityKind(issue) {
+			if (!targetEntityKindOf) throw new Error(`SQL target "${target.targetId}" is missing the required classifyEntityKind descriptor operation`);
+			return classifyDiffEntityKind(issue, targetEntityKindOf);
 		},
 		async sign(options) {
 			const { driver, contract: contractInput, contractPath, configPath } = options;
@@ -553,24 +555,6 @@ function createSqlFamilyInstance(stack) {
 		}
 	};
 }
-/**
-* Filters the structural schema-diff issues (from `diffDatabaseSchema`) through
-* the contract's `defaultControlPolicy`. Issues whose outcome maps to a suppressed
-* category under the effective policy are removed. This mirrors the control-policy
-* filtering applied by `verifySqlSchema` for table/column-level findings.
-*
-* Outcome → category mapping:
-* - `'extra'`    → `'extraAuxiliary'`    (an extra auxiliary entity, e.g. an RLS policy)
-* - `'missing'`  → `'declaredMissing'`
-* - `'mismatch'` → `'declaredIncompatible'`
-*/
-function filterSchemaDiffIssues(issues, defaultControlPolicy) {
-	if (issues.length === 0) return issues;
-	const policy = effectiveControlPolicy(void 0, defaultControlPolicy);
-	return issues.filter((issue) => {
-		return dispositionForCategory(policy, issue.outcome === "extra" ? "extraAuxiliary" : issue.outcome === "missing" ? "declaredMissing" : "declaredIncompatible") !== "suppress";
-	});
-}
 //#endregion
 //#region src/core/control-descriptor.ts
 var SqlFamilyDescriptor = class {
@@ -590,6 +574,255 @@ var SqlFamilyDescriptor = class {
 	}
 };
 //#endregion
+//#region src/core/migrations/contract-to-schema-ir.ts
+function convertColumn(name, column, storageTypes, expandNativeType, renderDefault) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	const baseNativeType = expandNativeType ? expandNativeType({
+		nativeType: resolved.nativeType,
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", resolved.typeParams)
+	}) : resolved.nativeType;
+	const nativeType = column.many ? `${baseNativeType}[]` : baseNativeType;
+	return {
+		name,
+		nativeType,
+		nullable: column.nullable,
+		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0),
+		resolvedNativeType: nativeType,
+		...ifDefined("resolvedDefault", column.default ?? void 0),
+		codecRef: buildColumnCodecRef(resolved, column.many),
+		codecBaseNativeType: resolved.nativeType,
+		...column.typeRef !== void 0 ? { codecNamedType: true } : {}
+	};
+}
+/**
+* Builds the column's `CodecRef` from its resolved (post-`typeRef`) codec
+* identity — the same construction the query AST and the migration DDL
+* renderer already use (TML-2456, TML-2918).
+*/
+function buildColumnCodecRef(resolved, many) {
+	return {
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", resolved.typeParams !== void 0 ? blindCast(resolved.typeParams) : void 0),
+		...ifDefined("many", many)
+	};
+}
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referenced = storageTypes[column.typeRef];
+	if (!referenced) throw new Error(`Column references storage type "${column.typeRef}" but it is not defined in storage.types.`);
+	if (isStorageTypeInstance(referenced)) return {
+		codecId: referenced.codecId,
+		nativeType: referenced.nativeType,
+		typeParams: referenced.typeParams
+	};
+	throw new Error(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`);
+}
+/**
+* Resolves a `ValueSetRef` to its permitted values from the contract storage.
+*
+* Throws when the referenced namespace or value-set is absent — this indicates
+* the contract was built incorrectly (the check and the value-set must be
+* co-emitted by the lowering step). Used by `convertCheck` (schema-IR
+* projection), `verifyCheckConstraints` (verification), and
+* `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
+* the resolved values and the error behavior on a missing reference.
+*/
+function allStrings(values) {
+	return values.every((value) => typeof value === "string");
+}
+function resolveValueSetValues(ref, storage, contextLabel) {
+	const ns = storage.namespaces[ref.namespaceId];
+	if (!ns) throw new Error(`resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`);
+	const valueSet = ns.entries.valueSet?.[ref.entityName];
+	if (!valueSet) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`);
+	const values = valueSet.values;
+	if (!allStrings(values)) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`);
+	return values;
+}
+/**
+* Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by
+* resolving the permitted values from the storage value-set it references.
+*
+* The `CheckConstraint.valueSet` ref points to
+* `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved
+* values are lifted directly from `StorageValueSet.values` so verification
+* compares value sets, not SQL predicate strings.
+*
+* Throws if the referenced namespace or value-set is absent — this
+* indicates the contract was built incorrectly (the check and the
+* value-set must be co-emitted by the lowering step).
+*/
+function convertCheck(check, storage) {
+	const permittedValues = resolveValueSetValues(check.valueSet, storage, `check "${check.name}"`);
+	return {
+		name: check.name,
+		column: check.column,
+		permittedValues
+	};
+}
+function convertUnique(unique) {
+	return {
+		columns: unique.columns,
+		...ifDefined("name", unique.name)
+	};
+}
+function convertIndex(index) {
+	return {
+		columns: index.columns,
+		unique: false,
+		...ifDefined("name", index.name),
+		...ifDefined("type", index.type),
+		...ifDefined("options", index.options)
+	};
+}
+function convertForeignKey(fk) {
+	return {
+		columns: fk.source.columns,
+		referencedTable: fk.target.tableName,
+		referencedSchema: fk.target.namespaceId,
+		referencedColumns: fk.target.columns,
+		...ifDefined("name", fk.name),
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate)
+	};
+}
+function convertTable(name, table, storageTypes, expandNativeType, renderDefault, storage) {
+	const columns = {};
+	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault);
+	const satisfiedIndexColumns = new Set([
+		...table.indexes.map((idx) => idx.columns.join(",")),
+		...table.uniques.map((unique) => unique.columns.join(",")),
+		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
+	]);
+	const fkBackingIndexes = [];
+	for (const fk of table.foreignKeys) {
+		if (fk.index === false) continue;
+		const key = fk.source.columns.join(",");
+		if (satisfiedIndexColumns.has(key)) continue;
+		fkBackingIndexes.push({
+			columns: fk.source.columns,
+			unique: false,
+			name: defaultIndexName(name, fk.source.columns)
+		});
+		satisfiedIndexColumns.add(key);
+	}
+	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
+	return new SqlTableIR({
+		name,
+		columns,
+		...ifDefined("primaryKey", table.primaryKey),
+		foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),
+		uniques: table.uniques.map(convertUnique),
+		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
+		...ifDefined("checks", checks)
+	});
+}
+/**
+* Detects destructive changes between two contract storages.
+*
+* The additive-only planner silently ignores removals (tables, columns).
+* This function detects those removals so callers can report them as conflicts
+* rather than silently producing an empty plan.
+*
+* Returns an empty array if no destructive changes are found.
+*/
+function detectDestructiveChanges(from, to) {
+	if (!from) return [];
+	const hasOwn = (value, key) => Object.hasOwn(value, key);
+	const conflicts = [];
+	const namespaceIds = [...new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	for (const namespaceId of namespaceIds) {
+		const fromNs = from.namespaces[namespaceId];
+		const toNs = to.namespaces[namespaceId];
+		const fromTables = fromNs?.entries.table;
+		if (!fromTables) continue;
+		for (const tableName of Object.keys(fromTables)) {
+			const toTableRaw = toNs?.entries.table?.[tableName];
+			if (!StorageTable.is(toTableRaw)) {
+				conflicts.push({
+					kind: "tableRemoved",
+					summary: `Table "${tableName}" was removed`
+				});
+				continue;
+			}
+			const toTable = toTableRaw;
+			const fromTableRaw = fromTables[tableName];
+			if (!StorageTable.is(fromTableRaw)) continue;
+			const fromTable = fromTableRaw;
+			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
+				kind: "columnRemoved",
+				summary: `Column "${tableName}"."${columnName}" was removed`
+			});
+		}
+	}
+	return conflicts;
+}
+/**
+* Converts a `Contract` to `SqlSchemaIR`.
+*
+* Reads `contract.storage` for tables and `contract.storage.types` for type
+* annotations. Storage-type annotations are written under
+* `options.annotationNamespace`.
+*
+* Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
+* structural information. When `expandNativeType` is provided, parameterized types
+* are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
+* resulting IR compares correctly against the "to" contract during planning.
+*
+* Returns an empty schema IR when `contract` is `null` (new project).
+*/
+/**
+* Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
+* table name within that namespace. Unlike {@link contractToSchemaIR}, which
+* flattens every namespace's tables into one bare-keyed record (and throws on a
+* cross-namespace name collision), this scopes the table iteration to one
+* namespace so the same table name can exist in two schemas.
+*
+* The full `storage` is still passed to `convertTable`, so value-set / enum /
+* type resolution that legitimately spans namespaces is unaffected. Foreign
+* keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
+* FKs survive per-namespace conversion. The `annotations` block (storage-type
+* derived) is omitted here — the per-namespace tree consumer reads only the
+* per-table fields.
+*/
+function contractNamespaceToSchemaIR(storage, namespaceId, options) {
+	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
+	const namespace = storage.namespaces[namespaceId];
+	if (!namespace) return new SqlSchemaIR({ tables: {} });
+	const storageTypes = { ...storage.types ?? {} };
+	const tables = {};
+	for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);
+		tables[tableName] = convertTable(tableName, tableDefRaw, storageTypes, options.expandNativeType, options.renderDefault, storage);
+	}
+	return new SqlSchemaIR({ tables });
+}
+function contractToSchemaIR(contract, options) {
+	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
+	if (!contract) return new SqlSchemaIR({ tables: {} });
+	const storage = contract.storage;
+	const storageTypes = { ...storage.types ?? {} };
+	const tables = {};
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);
+		const tableDef = tableDefRaw;
+		if (tables[tableName] !== void 0) throw new Error(`contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`);
+		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault, storage);
+	}
+	return new SqlSchemaIR({
+		tables,
+		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace, options.resolveEnumNamespaceSchema))
+	});
+}
+function deriveAnnotations(storage, annotationNamespace, _resolveEnumNamespaceSchema) {
+	const storageTypes = {};
+	for (const typeInstance of Object.values(storage.types ?? {})) if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
+	const envelope = { ...Object.keys(storageTypes).length > 0 ? { storageTypes } : {} };
+	if (Object.keys(envelope).length === 0) return void 0;
+	return { [annotationNamespace]: envelope };
+}
+//#endregion
 //#region src/core/migrations/control-policy.ts
 /**
 * The control policy that governs a single call. The `external` default is an
@@ -884,6 +1117,25 @@ function unionSorted(a, b) {
 	return [...set].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
 }
 //#endregion
+//#region src/core/migrations/native-type-expander.ts
+/**
+* Builds the codec-hook-composed `expandNativeType` callback the contract→IR
+* derivation uses to expand parameterized native types (e.g. `character` +
+* `{ length: 36 }` → `character(36)`). Returns `undefined` when no framework
+* components are supplied, so callers can omit the option entirely.
+*/
+function buildNativeTypeExpander(frameworkComponents) {
+	if (!frameworkComponents) return;
+	const codecHooks = extractCodecControlHooks(frameworkComponents);
+	return (input) => {
+		if (!input.typeParams) return input.nativeType;
+		if (!input.codecId) return input.nativeType;
+		const hooks = codecHooks.get(input.codecId);
+		if (!hooks?.expandNativeType) return input.nativeType;
+		return hooks.expandNativeType(input);
+	};
+}
+//#endregion
 //#region src/core/migrations/plan-helpers.ts
 const readOnlyEmptyObject = Object.freeze({});
 function cloneRecord(value) {
@@ -995,6 +1247,6 @@ const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.fre
 //#region src/exports/control.ts
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, buildNativeTypeExpander, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map