@prisma/orm-family-sql 0.16.0-dev.36

package/dist/build-contract-DBCz_YSs-DO0wMHai.mjs

@@ -0,0 +1,778 @@
+import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-DfIc_lOO.mjs";
+import { i as Index } from "./storage-table-_LWDmPfv-DFhU2dML.mjs";
+import { m as valueSetEntityKind, p as tableEntityKind } from "./entity-kinds-DKxwKolf-CcsY-iYV.mjs";
+import { n as lowerAuthoredIndex } from "./index-naming-BoGBcMmI-DiJAr66H.mjs";
+import { r as materializeForeignKeysAndIndexes } from "./foreign-key-materialization-HI7BIQrG.mjs";
+import { t as validateIndexTypes } from "./index-type-validation-COH4d78M.mjs";
+import { t as createIndexTypeRegistry } from "./index-types-DJQ_xwaE.mjs";
+import { a as SqlStorage, o as applyFkDefaults, u as toStorageTypeInstance } from "./types-CMMQS6aG.mjs";
+import { u as validateStorageSemantics } from "./validators-C4PItWnf.mjs";
+import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { asNamespaceId, coreHash, crossRef } from "@prisma/orm-framework/contract/types";
+import { flushAuthoringWarnings, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
+import { mergeCapabilityMatrices } from "@prisma/orm-framework/contract-authoring";
+//#region ../../../2-sql/2-authoring/contract-ts/dist/build-contract-DBCz_YSs.mjs
+function contractError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function encodeViaCodec(value, codecId, codecLookup) {
+	const codec = codecLookup?.get(codecId);
+	if (codec) return codec.encodeJson(value);
+	return blindCast(value);
+}
+function encodeColumnDefault(defaultInput, codecId, codecLookup, many = false) {
+	if (defaultInput.kind === "function") return {
+		kind: "function",
+		expression: defaultInput.expression
+	};
+	if (many) {
+		if (!Array.isArray(defaultInput.value)) throw new InternalError(`Literal default on a list column must be an array; received ${typeof defaultInput.value}. A scalar default on a list field must be rejected at the authoring surface.`);
+		return {
+			kind: "literal",
+			value: defaultInput.value.map((element) => encodeViaCodec(element, codecId, codecLookup))
+		};
+	}
+	return {
+		kind: "literal",
+		value: encodeViaCodec(defaultInput.value, codecId, codecLookup)
+	};
+}
+function assertStorageSemantics(definition, contract) {
+	const semanticErrors = validateStorageSemantics(contract.storage);
+	if (semanticErrors.length > 0) throw contractError("CONTRACT.VALIDATION_FAILED", `Contract semantic validation failed: ${semanticErrors.join("; ")}`, { meta: { errors: semanticErrors } });
+	const indexTypeRegistry = createIndexTypeRegistry();
+	const packsToRegister = [definition.target, ...Object.values(definition.extensions ?? {})];
+	for (const pack of packsToRegister) {
+		const registration = pack.indexTypes;
+		if (registration === void 0) continue;
+		if (typeof registration !== "object" || registration === null || !Array.isArray(registration.entries)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack "${pack.id ?? "<unknown>"}" declares "indexTypes" but its value is not an IndexTypeRegistration (expected an object with an "entries" array; got ${typeof registration}).`, { meta: {
+			packId: pack.id,
+			contribution: "indexTypes",
+			reason: "invalid-shape"
+		} });
+		for (const entry of registration.entries) indexTypeRegistry.register(entry);
+	}
+	validateIndexTypes(contract, indexTypeRegistry);
+}
+function assertKnownTargetModel(modelsByName, modelsByCoordinate, sourceModelName, targetModelName, targetNamespaceId, context) {
+	const targetModel = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? modelsByCoordinate.get(`${targetNamespaceId}:${targetModelName}`) : modelsByName.get(targetModelName);
+	if (!targetModel) {
+		const qualified = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? `${targetNamespaceId}.${targetModelName}` : targetModelName;
+		throw contractError("CONTRACT.MODEL_UNKNOWN", `${context} on model "${sourceModelName}" references unknown model "${qualified}"`, { meta: {
+			sourceModel: sourceModelName,
+			targetModel: qualified,
+			context
+		} });
+	}
+	return targetModel;
+}
+function assertTargetTableMatches(sourceModelName, targetModel, referencedTableName, context) {
+	if (targetModel.tableName !== referencedTableName) throw contractError("CONTRACT.TABLE_MISMATCH", `${context} on model "${sourceModelName}" references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`, { meta: {
+		sourceModel: sourceModelName,
+		referencedTable: referencedTableName,
+		mappedTable: targetModel.tableName,
+		context
+	} });
+}
+function isValueObjectField(field) {
+	return "valueObjectName" in field;
+}
+/**
+* Resolves a deferred entity-ref column descriptor (e.g. a `pg.enum(handle)`
+* column) against the field's now-known owning namespace: attaches the
+* storage `valueSet` ref the collected entity's derived value-set is stored
+* under. `nativeType` / `typeParams.typeName` stay bare here — schema
+* qualification (e.g. `auth.aal_level`) is a target concern applied in the
+* next step, `qualifyColumnDescriptor`. A descriptor with no `entityRef` (the
+* ordinary case) passes through unchanged.
+*/
+function resolveEntityRefDescriptor(descriptor, namespaceId) {
+	const entityRef = descriptor.entityRef;
+	if (entityRef === void 0) return descriptor;
+	return {
+		...descriptor,
+		valueSet: {
+			plane: "storage",
+			entityKind: "valueSet",
+			namespaceId,
+			entityName: entityRef.entityName
+		}
+	};
+}
+/**
+* Structural check for a target that contributes a `qualifyColumnType` hook
+* on its authoring contributions. Duck-typed (mirroring
+* `contract-psl`'s `hasColumnFromEntityHook`) so the SQL family stays blind
+* to the target's qualification logic and no framework/family interface has
+* to name the hook.
+*/
+function hasColumnTypeQualifier(authoring) {
+	return "qualifyColumnType" in authoring && typeof authoring.qualifyColumnType === "function";
+}
+function resolveColumnTypeQualifier(target) {
+	const authoring = target.authoring;
+	if (authoring === void 0) return void 0;
+	return hasColumnTypeQualifier(authoring) ? authoring.qualifyColumnType : void 0;
+}
+/**
+* Applies the target's `qualifyColumnType` hook to a scalar column descriptor
+* at construction, so the storage column and the domain field (which derives
+* its `type.typeParams` from the storage column) are both built already
+* qualified in a single pass. A descriptor whose codec the target leaves
+* unchanged passes through untouched.
+*/
+function qualifyColumnDescriptor(descriptor, namespaceId, qualify) {
+	if (qualify === void 0) return descriptor;
+	const qualified = qualify({
+		codecId: descriptor.codecId,
+		nativeType: descriptor.nativeType,
+		...ifDefined("typeParams", descriptor.typeParams)
+	}, namespaceId);
+	if (qualified.nativeType === descriptor.nativeType && qualified.typeParams === descriptor.typeParams) return descriptor;
+	return {
+		...descriptor,
+		nativeType: qualified.nativeType,
+		...ifDefined("typeParams", qualified.typeParams)
+	};
+}
+/**
+* Records a deferred column's entity-ref into the namespace-scoped collection
+* accumulator (`namespaceId → entityKind → entityName`) — folded into the same
+* namespace assembly `deriveEntityValueSets`/`entries.<kind>` step as the
+* entities-channel attachments, so a column-collected entity gets its
+* value-set the same way an entities-channel one does.
+*
+* The same handle reused by many columns in one namespace is normal (a native
+* enum type backs any number of columns) and records the identical entity once.
+* Two *different* entity instances sharing a name+kind in one namespace is a
+* name collision — the emitted `entries.valueSet.<name>` could only reflect one
+* of them, silently mismatching the other column's type/cast. PSL hard-errors
+* on the equivalent (`PSL_DUPLICATE_DECLARATION`); the TS path rejects it too.
+*/
+function collectEntityFromColumn(collected, namespaceId, entityRef) {
+	const forNs = collected[namespaceId] ?? {};
+	const forKind = forNs[entityRef.entityKind] ?? {};
+	const existing = forKind[entityRef.entityName];
+	if (existing !== void 0 && existing !== entityRef.entity) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${entityRef.entityKind}" entities named "${entityRef.entityName}" in namespace "${namespaceId}" — pack-entity names must be unique per namespace.`, { meta: {
+		kind: entityRef.entityKind,
+		name: entityRef.entityName,
+		namespaceId
+	} });
+	forKind[entityRef.entityName] = entityRef.entity;
+	forNs[entityRef.entityKind] = forKind;
+	collected[namespaceId] = forNs;
+}
+/**
+* Merges a namespace's entities-channel attachments (lowered from the
+* `entities` handle list, carried on `ContractDefinition.attachedEntities`)
+* with the entities collected from that namespace's deferred entity-ref
+* columns. A column-collected entity that shadows a *different* attached
+* entity of the same kind+name (or vice-versa) is the same name-collision bug
+* `collectEntityFromColumn` guards against across columns, so it is rejected
+* the same way — by entity identity, so the same handle attached and used by
+* a column does not throw.
+*/
+function mergeColumnAndAttachedEntities(namespaceId, attached, columnCollected) {
+	if (attached === void 0) return columnCollected;
+	if (columnCollected === void 0) return attached;
+	const kinds = /* @__PURE__ */ new Set([...Object.keys(attached), ...Object.keys(columnCollected)]);
+	const result = {};
+	for (const kind of kinds) {
+		const attachedForKind = attached[kind];
+		const columnForKind = columnCollected[kind];
+		for (const [name, entity] of Object.entries(columnForKind ?? {})) {
+			const existing = attachedForKind?.[name];
+			if (existing !== void 0 && existing !== entity) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${kind}" entities named "${name}" in namespace "${namespaceId}" — a column-referenced entity conflicts with an attached one; pack-entity names must be unique per namespace.`, { meta: {
+				kind,
+				name,
+				namespaceId
+			} });
+		}
+		result[kind] = {
+			...attachedForKind,
+			...columnForKind
+		};
+	}
+	return result;
+}
+const JSONB_CODEC_ID = "pg/jsonb@1";
+const JSONB_NATIVE_TYPE = "jsonb";
+function resolveModelNamespaceId(model, modelNameToNamespaceId, defaultNamespaceId) {
+	if (model.namespaceId !== void 0 && model.namespaceId.length > 0) return model.namespaceId;
+	return modelNameToNamespaceId.get(model.modelName) ?? defaultNamespaceId;
+}
+function buildThroughDescriptor(through, tableNamespaceByName, targetModel, modelName, fieldName, defaultNamespaceId) {
+	if (!tableNamespaceByName.has(through.table)) throw contractError("CONTRACT.MODEL_UNKNOWN", `buildSqlContractFromDefinition: junction table "${through.table}" for relation "${modelName}.${fieldName}" is not a declared model.`, { meta: {
+		sourceModel: modelName,
+		relationName: fieldName,
+		junctionTable: through.table
+	} });
+	const namespaceId = through.namespaceId ?? defaultNamespaceId;
+	return {
+		table: through.table,
+		namespaceId,
+		parentColumns: through.parentColumns,
+		childColumns: through.childColumns,
+		targetColumns: targetColumnsForJunction(targetModel, fieldName)
+	};
+}
+function targetColumnsForJunction(targetModel, fieldName) {
+	const primaryKeyColumns = targetModel.id?.columns;
+	if (primaryKeyColumns && primaryKeyColumns.length > 0) return primaryKeyColumns;
+	const firstUnique = targetModel.uniques?.find((u) => u.columns.length > 0);
+	if (firstUnique) return firstUnique.columns;
+	throw contractError("CONTRACT.IDENTITY_INVALID", `M:N target model "${targetModel.modelName}" (relation field "${fieldName}") has no primary id or unique key to derive junction targetColumns.`, { meta: {
+		modelName: targetModel.modelName,
+		reason: "no-key-for-junction-target-columns"
+	} });
+}
+function buildStorageColumn(field, storageValueSetRef, codecLookup) {
+	if (isValueObjectField(field)) {
+		const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, JSONB_CODEC_ID, codecLookup) : void 0;
+		return {
+			nativeType: JSONB_NATIVE_TYPE,
+			codecId: JSONB_CODEC_ID,
+			nullable: field.nullable,
+			...ifDefined("default", encodedDefault)
+		};
+	}
+	const codecId = field.descriptor.codecId;
+	const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, codecId, codecLookup, field.many === true) : void 0;
+	const valueSet = storageValueSetRef ?? field.descriptor.valueSet;
+	return {
+		nativeType: field.descriptor.nativeType,
+		codecId,
+		nullable: field.nullable,
+		...field.many ? { many: true } : {},
+		...ifDefined("typeParams", field.descriptor.typeParams),
+		...ifDefined("default", encodedDefault),
+		...ifDefined("typeRef", field.descriptor.typeRef),
+		...ifDefined("valueSet", valueSet)
+	};
+}
+function buildDomainField(field, column, domainValueSetRef) {
+	if (isValueObjectField(field)) return {
+		type: {
+			kind: "valueObject",
+			name: field.valueObjectName
+		},
+		nullable: field.nullable,
+		...field.many ? { many: true } : {}
+	};
+	return {
+		type: {
+			kind: "scalar",
+			codecId: column.codecId,
+			...ifDefined("typeParams", column.typeParams)
+		},
+		nullable: column.nullable,
+		...field.many ? { many: true } : {},
+		...ifDefined("valueSet", domainValueSetRef)
+	};
+}
+function collectStorageNamespaceCoordinateIds(definition) {
+	const ids = /* @__PURE__ */ new Set();
+	ids.add(definition.target.defaultNamespaceId);
+	for (const id of definition.namespaces ?? []) if (id.length > 0) ids.add(id);
+	for (const model of definition.models) if (model.namespaceId !== void 0 && model.namespaceId.length > 0) ids.add(model.namespaceId);
+	for (const id of Object.keys(definition.attachedEntities ?? {})) if (id.length > 0) ids.add(id);
+	return ids;
+}
+/**
+* Entry kinds the framework assembler itself manages (`table` from models,
+* `valueSet` from `enums` and attached-entity value-set derivation). A
+* pack-attached entity claiming one of these would silently clobber or be
+* clobbered by the managed slot, so it is rejected outright.
+*/
+const MANAGED_ENTRY_KINDS = /* @__PURE__ */ new Set([tableEntityKind.kind, valueSetEntityKind.kind]);
+function assertNoManagedEntityKinds(namespaceId, entitiesForNs) {
+	if (entitiesForNs === void 0) return;
+	for (const kind of Object.keys(entitiesForNs)) if (MANAGED_ENTRY_KINDS.has(kind)) throw contractError("CONTRACT.ENTITY_KIND_INVALID", `buildSqlContractFromDefinition: attached entity in namespace "${namespaceId}" declares entry kind "${kind}", which is managed by the framework (table/valueSet) and cannot be attached.`, { meta: {
+		entityKind: kind,
+		namespaceId
+	} });
+}
+/**
+* Walks the flat `entityTypes` namespace tree contributed by the target pack
+* and every extension pack, indexing descriptors by their `discriminator` —
+* the same string a pack entity's entries-map key (`entries.<kind>`) uses.
+* Mirrors `contract-psl`'s `buildEntityTypesByDiscriminator`, recomposed here
+* from the packs `ContractDefinition` already carries (`target` +
+* `extensions`) since the TS assembler has no single pre-merged
+* `AuthoringContributions` input to read the way the PSL interpreter does.
+*/
+function collectEntityTypeDescriptorsByDiscriminator(definition) {
+	const result = /* @__PURE__ */ new Map();
+	const walk = (namespace) => {
+		for (const value of Object.values(namespace)) if (isAuthoringEntityTypeDescriptor(value)) result.set(value.discriminator, value);
+		else walk(value);
+	};
+	const components = [definition.target, ...Object.values(definition.extensions ?? {})];
+	for (const component of components) {
+		const entityTypes = component.authoring?.entityTypes;
+		if (entityTypes !== void 0) walk(entityTypes);
+	}
+	return result;
+}
+/**
+* Derives value-sets for every pack entity declared in one namespace,
+* reusing the same `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook
+* `contract-psl`'s `lowerExtensionBlocksForNamespace` folds into
+* `entries.valueSet` on the PSL path — so a TS-attached entity (e.g. a
+* native enum) gets its value-set the same way. Entity kinds with no
+* registered descriptor, or whose descriptor output doesn't derive a
+* value-set, contribute nothing.
+*/
+function deriveEntityValueSets(entitiesForNs, entityTypesByDiscriminator) {
+	if (entitiesForNs === void 0) return void 0;
+	let result;
+	for (const [kind, entitiesByName] of Object.entries(entitiesForNs)) {
+		const descriptor = entityTypesByDiscriminator.get(kind);
+		if (descriptor === void 0) continue;
+		for (const [name, entity] of Object.entries(entitiesByName)) {
+			const derivedValueSet = deriveValueSetFromEntity(descriptor.output, entity);
+			if (derivedValueSet === void 0) continue;
+			result ??= {};
+			result[name] = derivedValueSet;
+		}
+	}
+	return result;
+}
+/**
+* Merges a namespace's `enumType()`-derived value-sets with its pack-entity-
+* derived value-sets. Both land in the same `entries.valueSet[name]` slot —
+* which drives value-set → codec typing and the domain-enum CHECK — so a
+* same-named entry in both would let one silently overwrite the other and
+* corrupt whichever column resolves against it. The same collision class the
+* `mergeColumnAndAttachedEntities` guard rejects; the PSL path already hard-errors
+* on the equivalent (`interpretPslDocumentToSqlContract`). Reject it here too.
+*/
+function mergeNamespaceValueSets(namespaceId, enumValueSets, packValueSets) {
+	if (enumValueSets !== void 0 && packValueSets !== void 0) {
+		for (const name of Object.keys(packValueSets)) if (Object.hasOwn(enumValueSets, name)) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: value-set "${name}" in namespace "${namespaceId}" is derived from both an enum and a pack entity — names must be unique per namespace.`, { meta: {
+			kind: "valueSet",
+			name,
+			namespaceId
+		} });
+	}
+	return {
+		...enumValueSets,
+		...packValueSets
+	};
+}
+function ensureUnboundNamespaceSlot(namespaces, createNamespace) {
+	if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) return namespaces;
+	const unbound = createNamespace({
+		id: UNBOUND_NAMESPACE_ID,
+		entries: { table: {} }
+	});
+	return {
+		[UNBOUND_NAMESPACE_ID]: unbound,
+		...namespaces
+	};
+}
+function buildSqlContractFromDefinition(definition, codecLookup) {
+	const target = definition.target.targetId;
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	const qualifyColumnType = resolveColumnTypeQualifier(definition.target);
+	const targetFamily = "sql";
+	const resolveNamespaceId = (m) => m.namespaceId !== void 0 && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId;
+	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
+	const tableNamespaceByName = new Map(definition.models.map((m) => [m.tableName, m.namespaceId !== void 0 && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId]));
+	const modelsByCoordinate = new Map(definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]));
+	const tablesByNamespace = {};
+	const authoringWarnings = [...definition.warnings ?? []];
+	const modelNameToNamespaceId = /* @__PURE__ */ new Map();
+	const executionDefaults = [];
+	const modelsByNamespace = {};
+	const collectedColumnEntities = {};
+	const rootEntries = [];
+	for (const semanticModel of definition.models) {
+		const tableName = semanticModel.tableName;
+		const namespaceId = semanticModel.namespaceId !== void 0 && semanticModel.namespaceId.length > 0 ? semanticModel.namespaceId : defaultNamespaceId;
+		modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
+		if (!semanticModel.sharesBaseTable) rootEntries.push({
+			tableName,
+			namespaceId,
+			ref: crossRef(semanticModel.modelName, namespaceId)
+		});
+		const columns = {};
+		const fieldToColumn = {};
+		const domainFields = {};
+		const domainFieldRefs = {};
+		const checksForTable = [];
+		for (const field of semanticModel.fields) {
+			const executionDefaultPhases = field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate ? field.executionDefaults : void 0;
+			if (executionDefaultPhases) {
+				if (field.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${semanticModel.modelName}.${field.fieldName}" cannot define both default and executionDefaults.`, { meta: {
+					modelName: semanticModel.modelName,
+					fieldName: field.fieldName,
+					reason: "default-and-executionDefaults"
+				} });
+				if (field.nullable) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${semanticModel.modelName}.${field.fieldName}" cannot be nullable when executionDefaults are present.`, { meta: {
+					modelName: semanticModel.modelName,
+					fieldName: field.fieldName,
+					reason: "nullable-with-executionDefaults"
+				} });
+			}
+			const enumHandle = !isValueObjectField(field) ? field.enumTypeHandle : void 0;
+			const storageValueSetRef = enumHandle !== void 0 ? {
+				plane: "storage",
+				entityKind: "valueSet",
+				namespaceId: defaultNamespaceId,
+				entityName: enumHandle.enumName
+			} : void 0;
+			const domainValueSetRef = enumHandle !== void 0 ? {
+				plane: "domain",
+				entityKind: "enum",
+				namespaceId: defaultNamespaceId,
+				entityName: enumHandle.enumName
+			} : void 0;
+			let resolvedField = field;
+			if (!isValueObjectField(field)) {
+				let descriptor = field.descriptor;
+				const entityRef = descriptor.entityRef;
+				if (entityRef !== void 0) {
+					collectEntityFromColumn(collectedColumnEntities, namespaceId, entityRef);
+					descriptor = resolveEntityRefDescriptor(descriptor, namespaceId);
+				}
+				descriptor = qualifyColumnDescriptor(descriptor, namespaceId, qualifyColumnType);
+				if (descriptor !== field.descriptor) resolvedField = {
+					...field,
+					descriptor
+				};
+			}
+			const column = buildStorageColumn(resolvedField, storageValueSetRef, codecLookup);
+			columns[field.columnName] = column;
+			fieldToColumn[field.fieldName] = field.columnName;
+			if (column.valueSet !== void 0 && storageValueSetRef !== void 0) checksForTable.push({
+				name: `${tableName}_${field.columnName}_check`,
+				column: field.columnName,
+				valueSet: column.valueSet
+			});
+			domainFields[field.fieldName] = buildDomainField(field, column, domainValueSetRef);
+			if (isValueObjectField(field)) domainFieldRefs[field.fieldName] = {
+				kind: "valueObject",
+				name: field.valueObjectName,
+				...field.many ? { many: true } : {}
+			};
+			else if (field.many) domainFieldRefs[field.fieldName] = {
+				kind: "scalar",
+				many: true
+			};
+			if (executionDefaultPhases) executionDefaults.push({
+				ref: {
+					namespace: namespaceId,
+					table: tableName,
+					column: field.columnName
+				},
+				...ifDefined("onCreate", executionDefaultPhases.onCreate),
+				...ifDefined("onUpdate", executionDefaultPhases.onUpdate)
+			});
+		}
+		const authoringForeignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
+			if (fk.references.spaceId !== void 0) {
+				const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;
+				return {
+					source: {
+						namespaceId: asNamespaceId(namespaceId),
+						tableName,
+						columns: fk.columns
+					},
+					target: {
+						namespaceId: asNamespaceId(targetNamespaceId),
+						tableName: fk.references.table,
+						columns: fk.references.columns,
+						spaceId: fk.references.spaceId
+					},
+					...applyFkDefaults({
+						...ifDefined("constraint", fk.constraint),
+						...ifDefined("index", fk.index)
+					}, definition.foreignKeyDefaults),
+					...ifDefined("name", fk.name),
+					...ifDefined("onDelete", fk.onDelete),
+					...ifDefined("onUpdate", fk.onUpdate)
+				};
+			}
+			const targetModel = assertKnownTargetModel(modelsByName, modelsByCoordinate, semanticModel.modelName, fk.references.model, fk.references.namespaceId, "Foreign key");
+			assertTargetTableMatches(semanticModel.modelName, targetModel, fk.references.table, "Foreign key");
+			const targetNamespaceId = fk.references.namespaceId ?? (targetModel.namespaceId !== void 0 && targetModel.namespaceId.length > 0 ? targetModel.namespaceId : defaultNamespaceId);
+			return {
+				source: {
+					namespaceId: asNamespaceId(namespaceId),
+					tableName,
+					columns: fk.columns
+				},
+				target: {
+					namespaceId: asNamespaceId(targetNamespaceId),
+					tableName: fk.references.table,
+					columns: fk.references.columns
+				},
+				...applyFkDefaults({
+					...ifDefined("constraint", fk.constraint),
+					...ifDefined("index", fk.index)
+				}, definition.foreignKeyDefaults),
+				...ifDefined("name", fk.name),
+				...ifDefined("onDelete", fk.onDelete),
+				...ifDefined("onUpdate", fk.onUpdate)
+			};
+		});
+		if (!semanticModel.sharesBaseTable) {
+			const uniques = (semanticModel.uniques ?? []).map((u) => ({
+				columns: u.columns,
+				...ifDefined("name", u.name)
+			}));
+			const declaredIndexes = (semanticModel.indexes ?? []).map((i) => lowerAuthoredIndex(tableName, blindCast({
+				...ifDefined("columns", i.columns),
+				...ifDefined("expression", i.expression),
+				where: i.where,
+				unique: i.unique,
+				map: i.map,
+				name: i.name,
+				type: i.type,
+				options: i.options
+			}), authoringWarnings));
+			const primaryKey = semanticModel.id ? {
+				columns: semanticModel.id.columns,
+				...ifDefined("name", semanticModel.id.name)
+			} : void 0;
+			const { foreignKeys, indexes } = materializeForeignKeysAndIndexes(tableName, authoringForeignKeys, declaredIndexes, uniques, primaryKey);
+			const tableInput = {
+				columns,
+				...ifDefined("control", semanticModel.control),
+				uniques,
+				indexes: indexes.map((i) => new Index(i)),
+				foreignKeys,
+				...primaryKey ? { primaryKey } : {},
+				...checksForTable.length > 0 ? { checks: checksForTable } : {}
+			};
+			let nsTables = tablesByNamespace[namespaceId];
+			if (nsTables === void 0) {
+				nsTables = {};
+				tablesByNamespace[namespaceId] = nsTables;
+			}
+			if (nsTables[tableName] !== void 0) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`, { meta: {
+				kind: "table",
+				name: tableName,
+				namespaceId
+			} });
+			nsTables[tableName] = tableInput;
+		}
+		const storageFields = {};
+		for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
+		const columnToField = new Map(Object.entries(fieldToColumn).map(([field, col]) => [col, field]));
+		const modelRelations = {};
+		for (const relation of semanticModel.relations ?? []) {
+			if (relation.spaceId !== void 0) {
+				const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;
+				modelRelations[relation.fieldName] = {
+					to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),
+					cardinality: "N:1",
+					on: {
+						localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+						targetFields: relation.on.childColumns
+					}
+				};
+				continue;
+			}
+			const targetModel = assertKnownTargetModel(modelsByName, modelsByCoordinate, semanticModel.modelName, relation.toModel, relation.toNamespaceId, "Relation");
+			assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, "Relation");
+			const targetColumnToField = new Map(targetModel.fields.map((f) => [f.columnName, f.fieldName]));
+			const to = crossRef(relation.toModel, relation.toNamespaceId !== void 0 && relation.toNamespaceId.length > 0 ? relation.toNamespaceId : resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId));
+			const on = {
+				localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+				targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col)
+			};
+			if (relation.cardinality === "N:M") {
+				if (!relation.through) throw contractError("CONTRACT.RELATION_INVALID", `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`, { meta: {
+					modelName: semanticModel.modelName,
+					relationName: relation.fieldName,
+					reason: "many-to-many-missing-through"
+				} });
+				modelRelations[relation.fieldName] = {
+					to,
+					cardinality: "N:M",
+					on,
+					through: buildThroughDescriptor(relation.through, tableNamespaceByName, targetModel, semanticModel.modelName, relation.fieldName, defaultNamespaceId)
+				};
+			} else modelRelations[relation.fieldName] = {
+				to,
+				cardinality: relation.cardinality,
+				on
+			};
+		}
+		let namespaceModels = modelsByNamespace[namespaceId];
+		if (namespaceModels === void 0) {
+			namespaceModels = {};
+			modelsByNamespace[namespaceId] = namespaceModels;
+		}
+		namespaceModels[semanticModel.modelName] = {
+			storage: {
+				table: tableName,
+				namespaceId,
+				fields: storageFields
+			},
+			fields: domainFields,
+			relations: modelRelations
+		};
+	}
+	const rootTableNameCounts = /* @__PURE__ */ new Map();
+	for (const entry of rootEntries) rootTableNameCounts.set(entry.tableName, (rootTableNameCounts.get(entry.tableName) ?? 0) + 1);
+	const roots = {};
+	for (const entry of rootEntries) {
+		const key = (rootTableNameCounts.get(entry.tableName) ?? 0) > 1 ? `${entry.namespaceId}.${entry.tableName}` : entry.tableName;
+		roots[key] = entry.ref;
+	}
+	const rawStorageTypes = definition.storageTypes ?? {};
+	const documentTypes = Object.fromEntries(Object.entries(rawStorageTypes).map(([name, entry]) => {
+		if (entry.kind === "codec-instance") return [name, entry];
+		return [name, toStorageTypeInstance({
+			codecId: entry.codecId,
+			nativeType: entry.nativeType,
+			typeParams: entry.typeParams ?? {}
+		})];
+	}));
+	const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
+	const domainEnumsByNs = {};
+	const storageValueSetsByNs = {};
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {
+		if (enumName !== handle.enumName) throw contractError("CONTRACT.ENUM_INVALID", `enum declaration key "${enumName}" must match enumType name "${handle.enumName}". Aliases are not supported.`, { meta: {
+			enumName: handle.enumName,
+			declarationKey: enumName,
+			reason: "key-name-mismatch"
+		} });
+		const nsId = defaultNamespaceId;
+		let domainSlot = domainEnumsByNs[nsId];
+		if (domainSlot === void 0) {
+			domainSlot = {};
+			domainEnumsByNs[nsId] = domainSlot;
+		}
+		domainSlot[enumName] = {
+			codecId: handle.codecId,
+			members: handle.enumMembers.map((m) => ({
+				name: m.name,
+				value: encodeViaCodec(m.value, handle.codecId, codecLookup)
+			}))
+		};
+		let storageSlot = storageValueSetsByNs[nsId];
+		if (storageSlot === void 0) {
+			storageSlot = {};
+			storageValueSetsByNs[nsId] = storageSlot;
+		}
+		storageSlot[enumName] = {
+			kind: "valueSet",
+			values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup))
+		};
+	}
+	const { createNamespace } = definition;
+	const entityTypesByDiscriminator = collectEntityTypeDescriptorsByDiscriminator(definition);
+	const namespaces = Object.fromEntries([...namespaceCoordinateIds].sort().map((id) => {
+		const entitiesForNs = mergeColumnAndAttachedEntities(id, definition.attachedEntities?.[id], collectedColumnEntities[id]);
+		assertNoManagedEntityKinds(id, entitiesForNs);
+		const enumValueSetEntries = storageValueSetsByNs[id];
+		const packValueSetEntries = deriveEntityValueSets(entitiesForNs, entityTypesByDiscriminator);
+		const valueSetEntries = enumValueSetEntries !== void 0 || packValueSetEntries !== void 0 ? mergeNamespaceValueSets(id, enumValueSetEntries, packValueSetEntries) : void 0;
+		const nsInput = {
+			id,
+			entries: {
+				table: tablesByNamespace[id] ?? {},
+				...entitiesForNs,
+				...valueSetEntries !== void 0 && Object.keys(valueSetEntries).length > 0 ? { valueSet: valueSetEntries } : {}
+			}
+		};
+		return [id, createNamespace(nsInput)];
+	}));
+	const storageWithoutHash = {
+		...Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {},
+		namespaces: defaultNamespaceId === UNBOUND_NAMESPACE_ID ? ensureUnboundNamespaceSlot(namespaces, createNamespace) : namespaces
+	};
+	const storageHash = definition.storageHash ? coreHash(definition.storageHash) : computeStorageHash({
+		target,
+		targetFamily,
+		storage: storageWithoutHash,
+		...sqlContractCanonicalizationHooks
+	});
+	const storage = new SqlStorage({
+		...storageWithoutHash,
+		storageHash
+	});
+	const executionSection = executionDefaults.length > 0 ? { mutations: { defaults: executionDefaults.sort((a, b) => {
+		const tableCompare = a.ref.table.localeCompare(b.ref.table);
+		if (tableCompare !== 0) return tableCompare;
+		return a.ref.column.localeCompare(b.ref.column);
+	}) } } : void 0;
+	const extensionNamespaces = definition.extensions ? Object.values(definition.extensions).map((pack) => pack.id) : void 0;
+	const extensions = { ...definition.extensions || {} };
+	if (extensionNamespaces) {
+		for (const namespace of extensionNamespaces) if (!Object.hasOwn(extensions, namespace)) extensions[namespace] = {};
+	}
+	const extensionPackCapabilitySources = definition.extensions ? Object.values(definition.extensions).map((pack) => pack.capabilities) : [];
+	const capabilities = mergeCapabilityMatrices(definition.target.capabilities, ...extensionPackCapabilitySources);
+	const profileHash = computeProfileHash({
+		target,
+		targetFamily,
+		capabilities: {}
+	});
+	const executionWithHash = executionSection ? {
+		...executionSection,
+		executionHash: computeExecutionHash({
+			target,
+			targetFamily,
+			execution: executionSection
+		})
+	} : void 0;
+	const valueObjects = definition.valueObjects && definition.valueObjects.length > 0 ? Object.fromEntries(definition.valueObjects.map((vo) => [vo.name, { fields: Object.fromEntries(vo.fields.map((f) => [f.fieldName, isValueObjectField(f) ? {
+		type: {
+			kind: "valueObject",
+			name: f.valueObjectName
+		},
+		nullable: f.nullable,
+		...f.many ? { many: true } : {}
+	} : {
+		type: {
+			kind: "scalar",
+			codecId: f.descriptor.codecId,
+			...ifDefined("typeParams", f.descriptor.typeParams)
+		},
+		nullable: f.nullable
+	}])) }])) : void 0;
+	const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
+	if (domainNamespaceIds.size === 0) domainNamespaceIds.add(defaultNamespaceId);
+	if (valueObjects !== void 0) domainNamespaceIds.add(defaultNamespaceId);
+	for (const nsId of Object.keys(domainEnumsByNs)) domainNamespaceIds.add(nsId);
+	const domainNamespaces = Object.fromEntries([...domainNamespaceIds].sort().map((namespaceId) => {
+		const modelsInNs = modelsByNamespace[namespaceId] ?? {};
+		const enumsInNs = domainEnumsByNs[namespaceId];
+		return [namespaceId, {
+			models: modelsInNs,
+			...namespaceId === defaultNamespaceId && valueObjects !== void 0 ? { valueObjects } : {},
+			...enumsInNs !== void 0 && Object.keys(enumsInNs).length > 0 ? { enum: enumsInNs } : {}
+		}];
+	}));
+	const contract = {
+		target,
+		targetFamily,
+		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
+		domain: { namespaces: domainNamespaces },
+		roots,
+		storage,
+		...executionWithHash ? { execution: executionWithHash } : {},
+		extensions,
+		capabilities,
+		profileHash,
+		meta: {}
+	};
+	assertStorageSemantics(definition, contract);
+	flushAuthoringWarnings(authoringWarnings);
+	return contract;
+}
+//#endregion
+export { contractError as n, buildSqlContractFromDefinition as t };
+
+//# sourceMappingURL=build-contract-DBCz_YSs-DO0wMHai.mjs.map