@prisma/orm-family-sql 8.0.0-rc.1-dev.46 → 8.0.0-rc.10-dev.1

package/dist/{interpreter-DyiUUAWh-DYdjIpiE.mjs → interpreter-CZ_iVQV4-CJ6COgSE.mjs}

@@ -1,5 +1,6 @@
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition } from "./derived-checks-DFMRmiAu-DGfB8aS4.mjs";
+import { a as interpretFieldAttribute, i as findModelAttributeNode, n as fieldSpecContext, o as interpretModelAttribute, r as findFieldAttributeNode, s as sqlAttributeSpecs, t as PSL_CHECK_ON_STI_VARIANT } from "./sql-attribute-specs-CG0yitvD-CG-0eW98.mjs";
+import { n as buildSqlContractFromDefinition } from "./derived-checks-DGjY5t7S-B3txNm7X.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
@@ -7,10 +8,12 @@ import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { crossRef } from "@prisma/orm-framework/contract/types";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { bool, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, funcCall, identifier, interpretAttribute, keywordPslSpan, leafDiagnostic, list, modelAttribute, nodePslSpan, num, oneOf, optional, record, str } from "@prisma/orm-framework/psl-parser";
-import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
+import { findBlockDescriptor, keywordPslSpan, nodePslSpan } from "@prisma/orm-framework/psl-parser";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-DyiUUAWh.mjs
+import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { consumeInvalidFkPairing, fkRelationPairKey, requiredOneToOneBackrelationDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
+import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-CZ_iVQV4.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -364,196 +367,6 @@ function mapPslHelperArgs(input) {
 	}
 	return mappedArgs;
 }
-function findModelAttributeNode(model, name) {
-	for (const attribute of model.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
-}
-function findFieldAttributeNode(field, name) {
-	for (const attribute of field.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
-}
-function buildModelInterpretCtx(input) {
-	return {
-		level: "model",
-		sourceId: input.sourceId,
-		sourceFile: input.sourceFile,
-		selfModel: input.selfModel,
-		resolveReferencedModel: () => void 0
-	};
-}
-function buildFieldInterpretCtx(input) {
-	return {
-		level: "field",
-		sourceId: input.sourceId,
-		sourceFile: input.sourceFile,
-		selfModel: input.selfModel,
-		resolveReferencedModel: input.resolveReferencedModel ?? (() => void 0),
-		field: input.field
-	};
-}
-function interpretModelAttribute(input) {
-	const result = interpretAttribute(input.node, input.spec, buildModelInterpretCtx({
-		selfModel: input.model,
-		sourceFile: input.sourceFile,
-		sourceId: input.sourceId
-	}));
-	if (!result.ok) {
-		for (const failure of result.failure) input.diagnostics.push(failure);
-		return;
-	}
-	return result.value;
-}
-function interpretFieldAttribute(input) {
-	const result = interpretAttribute(input.node, input.spec, buildFieldInterpretCtx({
-		selfModel: input.model,
-		field: input.field,
-		sourceFile: input.sourceFile,
-		sourceId: input.sourceId,
-		resolveReferencedModel: input.resolveReferencedModel
-	}));
-	if (!result.ok) {
-		for (const failure of result.failure) input.diagnostics.push(failure);
-		return;
-	}
-	return result.value;
-}
-const mapModelSpec = modelAttribute("map", { positional: [{
-	key: "name",
-	type: str()
-}] });
-const mapFieldSpec = fieldAttribute("map", { positional: [{
-	key: "name",
-	type: str()
-}] });
-function buildDefaultSpec(input) {
-	const literal = () => oneOf(str(), num(), bool());
-	const funcArms = [...input.registry.entries()].map(([name, entry]) => funcCall(name, blindCast(entry.signature)));
-	return fieldAttribute("default", { positional: [{
-		key: "value",
-		type: oneOf(...input.isList ? [list(literal()), ...funcArms] : [
-			str(),
-			num(),
-			bool(),
-			...funcArms
-		])
-	}] });
-}
-function buildEnumDefaultSpec(memberNames) {
-	const [first, ...rest] = memberNames;
-	return fieldAttribute("default", { positional: [{
-		key: "member",
-		type: oneOf(...[identifier(first), ...rest.map((name) => identifier(name))])
-	}] });
-}
-const idFieldSpec = fieldAttribute("id", { named: { map: optional(str()) } });
-const uniqueFieldSpec = fieldAttribute("unique", { named: { map: optional(str()) } });
-const noCheckKindArgument = () => oneOf(identifier("membership"), identifier("elementNotNull"));
-/**
-* `@noCheck` waives generated CHECK constraints on one column: bare for every
-* kind the column's shape derives, or naming concrete kinds. Two optional
-* positional slots cover the whole kind vocabulary; a third argument is
-* necessarily a duplicate and fails as excess arity.
-*/
-const noCheckFieldSpec = fieldAttribute("noCheck", {
-	positional: [{
-		key: "first",
-		type: optional(noCheckKindArgument())
-	}, {
-		key: "second",
-		type: optional(noCheckKindArgument())
-	}],
-	refine: (value, ctx, attributeNode) => {
-		if (value.first !== void 0 && value.first === value.second) return [leafDiagnostic(ctx, attributeNode, "`@noCheck` names the same kind twice")];
-		return [];
-	}
-});
-const idModelSpec = modelAttribute("id", {
-	positional: [{
-		key: "fields",
-		type: list(fieldRef("self"), {
-			nonEmpty: true,
-			unique: true
-		})
-	}],
-	named: { map: optional(str()) }
-});
-const uniqueModelSpec = modelAttribute("unique", {
-	positional: [{
-		key: "fields",
-		type: list(fieldRef("self"), {
-			nonEmpty: true,
-			unique: true
-		})
-	}],
-	named: { map: optional(str()) }
-});
-const PSL_INDEX_FIELDS_XOR_EXPRESSION = "PSL_INDEX_FIELDS_XOR_EXPRESSION";
-const PSL_INDEX_EXPRESSION_REQUIRES_NAME = "PSL_INDEX_EXPRESSION_REQUIRES_NAME";
-const PSL_INDEX_NAME_XOR_MAP = "PSL_INDEX_NAME_XOR_MAP";
-const indexModelSpec = modelAttribute("index", {
-	positional: [{
-		key: "fields",
-		type: optional(list(fieldRef("self"), {
-			nonEmpty: true,
-			unique: true
-		}))
-	}],
-	named: {
-		expression: optional(str()),
-		where: optional(str()),
-		unique: optional(bool()),
-		name: optional(str()),
-		map: optional(str()),
-		type: optional(str()),
-		options: optional(record(str()))
-	},
-	refine: (value, ctx, attributeNode) => {
-		const diagnostics = [];
-		if (value.fields === void 0 === (value.expression === void 0)) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` requires exactly one of a fields list or an `expression` argument", PSL_INDEX_FIELDS_XOR_EXPRESSION));
-		if (value.expression !== void 0 && value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` with an `expression` argument requires a `name` or `map` argument (a default name cannot be derived from an expression)", PSL_INDEX_EXPRESSION_REQUIRES_NAME));
-		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` takes at most one of `name` and `map`", PSL_INDEX_NAME_XOR_MAP));
-		if (value.options !== void 0 && value.type === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` options argument requires a type argument"));
-		return diagnostics;
-	}
-});
-const PSL_CHECK_REQUIRES_NAME_OR_MAP = "PSL_CHECK_REQUIRES_NAME_OR_MAP";
-const PSL_CHECK_NAME_XOR_MAP = "PSL_CHECK_NAME_XOR_MAP";
-const PSL_CHECK_EXPRESSION_EMPTY = "PSL_CHECK_EXPRESSION_EMPTY";
-/**
-* A single-table-inheritance variant (`@@base` with no own `@@map`) shares
-* its base model's storage table and has no table of its own to declare a
-* check on — raised from {@link interpretPslDocumentToSqlContract}, not from
-* this spec's own `refine`, because the rule needs the model's `@@base`
-* declaration, which a single attribute's `refine` cannot see.
-*/
-const PSL_CHECK_ON_STI_VARIANT = "PSL_CHECK_ON_STI_VARIANT";
-const checkModelSpec = modelAttribute("check", {
-	named: {
-		expression: str(),
-		name: optional(str()),
-		map: optional(str())
-	},
-	refine: (value, ctx, attributeNode) => {
-		const diagnostics = [];
-		if (value.expression.trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
-		if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
-		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
-		return diagnostics;
-	}
-});
-const controlModelSpec = modelAttribute("control", { positional: [{
-	key: "policy",
-	type: oneOf(identifier("managed"), identifier("tolerated"), identifier("external"), identifier("observed"))
-}] });
-const discriminatorModelSpec = modelAttribute("discriminator", { positional: [{
-	key: "field",
-	type: fieldRef("self")
-}] });
-const baseModelSpec = modelAttribute("base", { positional: [{
-	key: "base",
-	type: entityRef()
-}, {
-	key: "value",
-	type: str()
-}] });
 function toNamedTypeFieldDescriptor(typeRef, descriptor) {
 	return {
 		codecId: descriptor.codecId,
@@ -951,10 +764,12 @@ function lowerDefaultForField(input) {
 	if (node === void 0) return {};
 	const interpreted = interpretFieldAttribute({
 		node,
-		spec: buildDefaultSpec({
-			isList: input.isList ?? false,
-			registry: input.defaultFunctionRegistry
-		}),
+		spec: sqlAttributeSpecs.field.default(fieldSpecContext({
+			symbols: input.symbolTable,
+			model: input.model,
+			field: input.field,
+			controlMutationDefaults: input.defaultFunctionRegistry
+		})),
 		model: input.model,
 		field: input.field,
 		sourceFile: input.sourceFile,
@@ -1027,11 +842,15 @@ function lowerEnumDefaultForField(input) {
 	const { field, model, sourceFile, enumHandle, sourceId, diagnostics } = input;
 	const node = findFieldAttributeNode(field, "default");
 	if (node === void 0) return {};
-	const [firstMember, ...restMembers] = enumHandle.enumMembers.map((m) => m.name);
-	if (firstMember === void 0) return {};
+	if (enumHandle.enumMembers.length === 0) return {};
 	const interpreted = interpretFieldAttribute({
 		node,
-		spec: buildEnumDefaultSpec([firstMember, ...restMembers]),
+		spec: sqlAttributeSpecs.field.default(fieldSpecContext({
+			symbols: input.symbolTable,
+			model,
+			field,
+			controlMutationDefaults: input.defaultFunctionRegistry
+		})),
 		model,
 		field,
 		sourceFile,
@@ -1039,7 +858,8 @@ function lowerEnumDefaultForField(input) {
 		diagnostics
 	});
 	if (interpreted === void 0) return {};
-	const member = interpreted.member;
+	const member = interpreted.value;
+	invariant(typeof member === "string", "the enum @default grammar admits only member identifiers, so the parsed value is a string");
 	const match = enumHandle.enumMembers.find((m) => m.name === member);
 	if (!match) return {};
 	return { defaultValue: {
@@ -1051,25 +871,17 @@ const MODEL_COORDINATE_SEPARATOR = "\0";
 function modelCoordinateKey(namespaceId, modelName) {
 	return `${namespaceId}${MODEL_COORDINATE_SEPARATOR}${modelName}`;
 }
-const BUILTIN_FIELD_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
-	"id",
-	"unique",
-	"default",
-	"relation",
-	"map",
-	"noCheck"
-]);
 const REMOVED_ATTRIBUTE_RULES = /* @__PURE__ */ new Map([["updatedAt", {
 	hint: "Use `temporal.updatedAt()` as a field-preset call instead.",
 	suppressWhen: (field) => field.typeConstructor?.path[0] === "temporal"
 }]]);
 {
-	const overlap = [...REMOVED_ATTRIBUTE_RULES.keys()].filter((name) => BUILTIN_FIELD_ATTRIBUTE_NAMES.has(name));
-	if (overlap.length > 0) throw new InternalError(`BUILTIN_FIELD_ATTRIBUTE_NAMES and REMOVED_ATTRIBUTE_RULES must not overlap. Names in both: ${overlap.join(", ")}`);
+	const overlap = [...REMOVED_ATTRIBUTE_RULES.keys()].filter((name) => Object.hasOwn(sqlAttributeSpecs.field, name));
+	if (overlap.length > 0) throw new InternalError(`Registered SQL field attributes and REMOVED_ATTRIBUTE_RULES must not overlap. Names in both: ${overlap.join(", ")}`);
 }
 function validateFieldAttributes(input) {
 	for (const attribute of input.field.attributes) {
-		if (BUILTIN_FIELD_ATTRIBUTE_NAMES.has(attribute.name)) continue;
+		if (Object.hasOwn(sqlAttributeSpecs.field, attribute.name)) continue;
 		if (attribute.name.startsWith("db.")) {
 			input.diagnostics.push({
 				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
@@ -1111,7 +923,7 @@ function extractFieldConstraintNames(input) {
 	const idNode = findFieldAttributeNode(input.field, "id");
 	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
 		node: idNode,
-		spec: idFieldSpec,
+		spec: sqlAttributeSpecs.field.id(),
 		model: input.model,
 		field: input.field,
 		sourceFile: input.sourceFile,
@@ -1125,7 +937,7 @@ function extractFieldConstraintNames(input) {
 		idName,
 		uniqueName: uniqueNode === void 0 ? void 0 : interpretFieldAttribute({
 			node: uniqueNode,
-			spec: uniqueFieldSpec,
+			spec: sqlAttributeSpecs.field.unique(),
 			model: input.model,
 			field: input.field,
 			sourceFile: input.sourceFile,
@@ -1146,7 +958,7 @@ function lowerNoCheckForField(input) {
 	if (node === void 0) return void 0;
 	const interpreted = interpretFieldAttribute({
 		node,
-		spec: noCheckFieldSpec,
+		spec: sqlAttributeSpecs.field.noCheck(),
 		model: input.model,
 		field: input.field,
 		sourceFile: input.sourceFile,
@@ -1185,7 +997,7 @@ function lowerNoCheckForField(input) {
 	return [...authored].sort();
 }
 function collectResolvedFields(input) {
-	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const { model, symbolTable, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
 	const resolvedFields = [];
 	const valueObjectStorageTypeName = authoringContributions?.valueObjectStorageType;
 	const declaredControlPolicy = getAttribute(model.attributes, "control")?.args.find((arg) => arg.kind === "positional")?.value.trim();
@@ -1300,22 +1112,24 @@ function collectResolvedFields(input) {
 			fieldName: field.name,
 			field,
 			model,
+			symbolTable,
 			sourceFile: input.sourceFile,
 			enumHandle,
 			sourceId,
+			defaultFunctionRegistry,
 			diagnostics
 		}) : lowerDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
 			field,
 			model,
+			symbolTable,
 			sourceFile: input.sourceFile,
 			columnDescriptor: descriptor,
 			generatorDescriptorById,
 			sourceId,
 			defaultFunctionRegistry,
-			diagnostics,
-			isList: isListField
+			diagnostics
 		}) : {};
 		const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
 		const loweredFunctionDefault = loweredDefault.defaultValue?.kind === "function";
@@ -1411,7 +1225,7 @@ function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourc
 		const mapNode = findModelAttributeNode(model, "map");
 		const tableName = mapNode === void 0 ? lowerFirst(model.name) : interpretModelAttribute({
 			node: mapNode,
-			spec: mapModelSpec,
+			spec: sqlAttributeSpecs.model.map(),
 			model,
 			sourceFile,
 			sourceId,
@@ -1422,7 +1236,7 @@ function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourc
 			const fieldMapNode = findFieldAttributeNode(field, "map");
 			const columnName = fieldMapNode === void 0 ? field.name : interpretFieldAttribute({
 				node: fieldMapNode,
-				spec: mapFieldSpec,
+				spec: sqlAttributeSpecs.field.map(),
 				model,
 				field,
 				sourceFile,
@@ -1587,58 +1401,9 @@ const REFERENTIAL_ACTION_MAP = {
 	setNull: "setNull",
 	setDefault: "setDefault"
 };
-function fkRelationPairKey(declaringModelName, targetModelName) {
-	return `${declaringModelName}::${targetModelName}`;
-}
 function normalizeReferentialAction(actionToken) {
 	return REFERENTIAL_ACTION_MAP[actionToken];
 }
-function relationInvariants(parsed, ctx) {
-	if (parsed.fields !== void 0 !== (parsed.references !== void 0)) return [{
-		code: "PSL_INVALID_ATTRIBUTE_SYNTAX",
-		message: `Relation field "${ctx.selfModel.name}.${ctx.field?.name ?? ""}" requires fields and references arguments`,
-		sourceId: ctx.sourceId,
-		span: relationAttributeSpan(ctx)
-	}];
-	return [];
-}
-const sqlRelation = fieldAttribute("relation", {
-	positional: [{
-		key: "name",
-		type: optional(str())
-	}],
-	named: {
-		name: optional(str()),
-		fields: optional(list(fieldRef("self"), {
-			nonEmpty: true,
-			unique: true
-		})),
-		references: optional(list(fieldRef("referenced"), {
-			nonEmpty: true,
-			unique: true
-		})),
-		map: optional(str()),
-		onDelete: optional(oneOf(identifier("NoAction"), identifier("Restrict"), identifier("Cascade"), identifier("SetNull"), identifier("SetDefault"))),
-		onUpdate: optional(oneOf(identifier("NoAction"), identifier("Restrict"), identifier("Cascade"), identifier("SetNull"), identifier("SetDefault"))),
-		/**
-		* Opts a foreign key out of its default backing index
-		* (`index: false`). Omitted (the default) keeps the FK's derived
-		* backing-index expectation; only `false` is meaningful — there is no
-		* `index: true` spelling since that is already the default.
-		*/
-		index: optional(bool())
-	},
-	refine: relationInvariants
-});
-function relationAttributeSpan(ctx) {
-	const field = ctx.field;
-	if (field !== void 0) {
-		const node = findFieldAttributeNode(field, "relation");
-		if (node !== void 0) return nodePslSpan(node.syntax, ctx.sourceFile);
-		return field.span;
-	}
-	return ctx.selfModel.span;
-}
 function resolveReferencedModel(symbols, field) {
 	const topLevel = symbols.topLevel.models[field.typeName];
 	if (topLevel !== void 0) return topLevel;
@@ -1652,7 +1417,7 @@ function interpretRelationAttribute(input) {
 	if (node === void 0) return void 0;
 	return interpretFieldAttribute({
 		node,
-		spec: sqlRelation,
+		spec: sqlAttributeSpecs.field.relation(),
 		model: input.selfModel,
 		field: input.field,
 		sourceFile: input.sourceFile,
@@ -1678,6 +1443,7 @@ function indexFkRelations(input) {
 			toTable: relation.targetTableName,
 			...ifDefined("toNamespaceId", relation.targetNamespaceId),
 			cardinality: "N:1",
+			nullable: relation.nullable,
 			on: {
 				parentTable: relation.declaringTableName,
 				parentColumns: relation.localColumns,
@@ -1853,6 +1619,7 @@ function applyBackrelationCandidates(input) {
 		const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
 		const matches = candidate.relationName ? pairMatches.filter((relation) => relation.relationName === candidate.relationName) : [...pairMatches];
 		if (matches.length === 0) {
+			if (consumeInvalidFkPairing(candidate, pairKey, input.invalidFkPairings)) continue;
 			if (candidate.isList) {
 				const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
 					candidate,
@@ -1911,12 +1678,22 @@ function applyBackrelationCandidates(input) {
 				continue;
 			}
 		}
+		if (!candidate.isList && !candidate.field.optional) input.diagnostics.push(requiredOneToOneBackrelationDiagnostic({
+			modelName: candidate.modelName,
+			field: candidate.field,
+			targetModelName: candidate.targetModelName,
+			sourceId: input.sourceId,
+			recordNoun: "row"
+		}));
 		relationsForModel(input.modelRelations, candidate.modelName).push({
 			fieldName: candidate.field.name,
 			toModel: matched.declaringModelName,
 			toTable: matched.declaringTableName,
 			...ifDefined("toNamespaceId", matched.declaringNamespaceId),
-			cardinality: candidate.isList ? "1:N" : "1:1",
+			...candidate.isList ? { cardinality: "1:N" } : {
+				cardinality: "1:1",
+				nullable: true
+			},
 			on: {
 				parentTable: candidate.tableName,
 				parentColumns: matched.referencedColumns,
@@ -2283,6 +2060,22 @@ function composedBlockKeywords(authoringContributions) {
 function relationAttributeDeclaresOwningSide(relationAttribute) {
 	return getNamedArgument(relationAttribute, "fields") !== void 0 || getNamedArgument(relationAttribute, "references") !== void 0;
 }
+function relationNullabilityMismatch(relationField, localColumns, resolvedFields) {
+	return resolveToOneRelationNullable({
+		declaredNullable: relationField.optional,
+		localFieldNullability: resolvedFields.filter((resolvedField) => localColumns.includes(resolvedField.columnName)).map((resolvedField) => resolvedField.nullable),
+		ownsReference: true
+	}).contradiction !== void 0;
+}
+function relationNullabilityMismatchDiagnostic(modelName, relationAttribute, sourceId) {
+	const fieldLabel = `Relation field "${modelName}.${relationAttribute.field.name}"`;
+	return {
+		code: "PSL_RELATION_NULLABILITY_MISMATCH",
+		message: relationAttribute.field.optional ? `${fieldLabel} is optional but every field in @relation(fields: [...]) is required. Make one of those fields optional with "?" or remove "?" from "${relationAttribute.field.name}".` : `${fieldLabel} is required but a field in @relation(fields: [...]) is optional. Add "?" to "${relationAttribute.field.name}" or make those fields required.`,
+		sourceId,
+		span: relationAttribute.field.span
+	};
+}
 function buildModelNodeFromPsl(input) {
 	const { model, mapping, sourceId, diagnostics } = input;
 	const tableName = mapping.tableName;
@@ -2290,6 +2083,7 @@ function buildModelNodeFromPsl(input) {
 	const namespaceExtensionEntitiesForModel = modelNamespaceId !== void 0 ? input.namespaceExtensionEntities?.get(modelNamespaceId) : void 0;
 	const resolvedFields = collectResolvedFields({
 		model,
+		symbolTable: input.symbolTable,
 		mapping,
 		enumTypeDescriptors: input.enumTypeDescriptors,
 		namedTypeDescriptors: input.namedTypeDescriptors,
@@ -2398,6 +2192,30 @@ function buildModelNodeFromPsl(input) {
 	const foreignKeyNodes = [];
 	const modelAttributeNodes = Array.from(model.node.attributes());
 	for (const [attributeIndex, modelAttribute] of model.attributes.entries()) {
+		if (!Object.hasOwn(sqlAttributeSpecs.model, modelAttribute.name) && !input.modelAttributesByName.has(modelAttribute.name)) {
+			const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
+				familyId: input.familyId,
+				targetId: input.targetId,
+				authoringContributions: input.authoringContributions
+			});
+			if (uncomposedNamespace) {
+				reportUncomposedNamespace({
+					subjectLabel: `Attribute "@@${modelAttribute.name}"`,
+					namespace: uncomposedNamespace,
+					sourceId,
+					span: modelAttribute.span,
+					diagnostics
+				});
+				continue;
+			}
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
+				message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
+				sourceId,
+				span: modelAttribute.span
+			});
+			continue;
+		}
 		if (modelAttribute.name === "map") continue;
 		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
 		if (modelAttribute.name === "control") {
@@ -2415,7 +2233,7 @@ function buildModelNodeFromPsl(input) {
 			if (node === void 0) continue;
 			const parsed = interpretModelAttribute({
 				node,
-				spec: controlModelSpec,
+				spec: sqlAttributeSpecs.model.control(),
 				model,
 				sourceFile: input.sourceFile,
 				sourceId,
@@ -2449,7 +2267,7 @@ function buildModelNodeFromPsl(input) {
 			if (node === void 0) continue;
 			const parsed = interpretModelAttribute({
 				node,
-				spec: idModelSpec,
+				spec: sqlAttributeSpecs.model.id(),
 				model,
 				sourceFile: input.sourceFile,
 				sourceId,
@@ -2489,7 +2307,7 @@ function buildModelNodeFromPsl(input) {
 			if (node === void 0) continue;
 			const parsed = interpretModelAttribute({
 				node,
-				spec: uniqueModelSpec,
+				spec: sqlAttributeSpecs.model.unique(),
 				model,
 				sourceFile: input.sourceFile,
 				sourceId,
@@ -2517,7 +2335,7 @@ function buildModelNodeFromPsl(input) {
 			if (node === void 0) continue;
 			const parsed = interpretModelAttribute({
 				node,
-				spec: indexModelSpec,
+				spec: sqlAttributeSpecs.model.index(),
 				model,
 				sourceFile: input.sourceFile,
 				sourceId,
@@ -2564,7 +2382,7 @@ function buildModelNodeFromPsl(input) {
 			}
 			const parsed = interpretModelAttribute({
 				node,
-				spec: checkModelSpec,
+				spec: sqlAttributeSpecs.model.check(),
 				model,
 				sourceFile: input.sourceFile,
 				sourceId,
@@ -2594,7 +2412,11 @@ function buildModelNodeFromPsl(input) {
 			if (node === void 0) continue;
 			const parsed = interpretModelAttribute({
 				node,
-				spec: blindCast(contributedModelAttribute.spec),
+				spec: blindCast(contributedModelAttribute.spec)({
+					symbols: input.symbolTable,
+					model,
+					controlMutationDefaults: input.defaultFunctionRegistry
+				}),
 				model,
 				sourceFile: input.sourceFile,
 				sourceId,
@@ -2618,29 +2440,10 @@ function buildModelNodeFromPsl(input) {
 			slot[lowered.key] = lowered.entity;
 			continue;
 		}
-		const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
-			familyId: input.familyId,
-			targetId: input.targetId,
-			authoringContributions: input.authoringContributions
-		});
-		if (uncomposedNamespace) {
-			reportUncomposedNamespace({
-				subjectLabel: `Attribute "@@${modelAttribute.name}"`,
-				namespace: uncomposedNamespace,
-				sourceId,
-				span: modelAttribute.span,
-				diagnostics
-			});
-			continue;
-		}
-		diagnostics.push({
-			code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
-			message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
-			sourceId,
-			span: modelAttribute.span
-		});
+		throw new InternalError(`Model attribute "@@${modelAttribute.name}" is registered but has no interpreter branch`);
 	}
 	const resultFkRelationMetadata = [];
+	const resultInvalidFkPairings = [];
 	const resultCrossSpaceRelations = [];
 	for (const relationAttribute of relationAttributes) {
 		const { typeName: fieldTypeName, typeNamespaceId: fieldTypeNamespaceId, typeContractSpaceId: fieldTypeContractSpaceId } = relationAttribute.field;
@@ -2697,6 +2500,10 @@ function buildModelNodeFromPsl(input) {
 				entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
 			});
 			if (!localColumns) continue;
+			if (relationNullabilityMismatch(relationAttribute.field, localColumns, resolvedFields)) {
+				diagnostics.push(relationNullabilityMismatchDiagnostic(model.name, relationAttribute, sourceId));
+				continue;
+			}
 			const referencedColumns = parsedRelation.references;
 			if (localColumns.length !== referencedColumns.length) {
 				diagnostics.push({
@@ -2747,6 +2554,7 @@ function buildModelNodeFromPsl(input) {
 				toModel: fieldTypeName,
 				toTable: crossTargetTableName,
 				cardinality: "N:1",
+				nullable: relationAttribute.field.optional,
 				spaceId: fieldTypeContractSpaceId,
 				namespaceId: crossTargetNamespaceId,
 				on: {
@@ -2816,6 +2624,14 @@ function buildModelNodeFromPsl(input) {
 			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
 		});
 		if (!localColumns) continue;
+		if (relationNullabilityMismatch(relationAttribute.field, localColumns, resolvedFields)) {
+			diagnostics.push(relationNullabilityMismatchDiagnostic(model.name, relationAttribute, sourceId));
+			resultInvalidFkPairings.push({
+				pairKey: fkRelationPairKey(model.name, targetMapping.model.name),
+				...ifDefined("relationName", parsedRelation.name)
+			});
+			continue;
+		}
 		const referencedColumns = mapFieldNamesToColumns({
 			modelName: targetMapping.model.name,
 			fieldNames: parsedRelation.references,
@@ -2860,6 +2676,7 @@ function buildModelNodeFromPsl(input) {
 			targetTableName: targetMapping.tableName,
 			...ifDefined("targetNamespaceId", targetNamespaceId),
 			...ifDefined("relationName", parsedRelation.name),
+			nullable: relationAttribute.field.optional,
 			localColumns,
 			referencedColumns
 		});
@@ -2890,6 +2707,7 @@ function buildModelNodeFromPsl(input) {
 			...ifDefined("control", controlPolicy)
 		},
 		fkRelationMetadata: resultFkRelationMetadata,
+		invalidFkPairings: resultInvalidFkPairings,
 		crossSpaceRelations: resultCrossSpaceRelations,
 		backrelationCandidates: resultBackrelationCandidates,
 		resolvedFields,
@@ -3001,7 +2819,7 @@ function collectPolymorphismDeclarations(models, sourceFile, sourceId, diagnosti
 		if (discriminatorNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: discriminatorNode,
-				spec: discriminatorModelSpec,
+				spec: sqlAttributeSpecs.model.discriminator(),
 				model,
 				sourceFile,
 				sourceId,
@@ -3026,7 +2844,7 @@ function collectPolymorphismDeclarations(models, sourceFile, sourceId, diagnosti
 		if (baseNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: baseNode,
-				spec: baseModelSpec,
+				spec: sqlAttributeSpecs.model.base(),
 				model,
 				sourceFile,
 				sourceId,
@@ -3490,6 +3308,7 @@ function interpretPslDocumentToSqlContract(input) {
 	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
 	const modelNodes = [];
 	const fkRelationMetadata = [];
+	const invalidFkPairings = [];
 	const backrelationCandidates = [];
 	const modelResolvedFields = /* @__PURE__ */ new Map();
 	const crossSpaceRelationsByModel = /* @__PURE__ */ new Map();
@@ -3532,6 +3351,7 @@ function interpretPslDocumentToSqlContract(input) {
 			namespaceId
 		} : result.modelNode);
 		fkRelationMetadata.push(...result.fkRelationMetadata);
+		invalidFkPairings.push(...result.invalidFkPairings);
 		backrelationCandidates.push(...result.backrelationCandidates);
 		modelResolvedFields.set(coordinate, result.resolvedFields);
 		if (result.crossSpaceRelations.length > 0) {
@@ -3561,6 +3381,7 @@ function interpretPslDocumentToSqlContract(input) {
 	applyBackrelationCandidates({
 		backrelationCandidates,
 		fkRelationsByPair,
+		invalidFkPairings,
 		fkRelationsByDeclaringModel,
 		modelIdColumns,
 		modelUniqueColumnSets,
@@ -3677,4 +3498,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-DyiUUAWh-DYdjIpiE.mjs.map
+//# sourceMappingURL=interpreter-CZ_iVQV4-CJ6COgSE.mjs.map