@prisma-next/sql-contract-psl 0.5.0-dev.6 → 0.5.0-dev.60

package/dist/{interpreter-iFCRN9nb.mjs → interpreter-BChe-9vN.mjs}

@@ -1,4 +1,4 @@
-import { instantiateAuthoringTypeConstructor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
+import { hasRegisteredFieldNamespace, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
@@ -149,7 +149,7 @@ function parseAttributeFieldList(input) {
 	if (!raw) {
 		input.diagnostics.push({
 			code: input.code,
-			message: `${input.messagePrefix} requires fields list argument`,
+			message: `${input.entityLabel} requires fields list argument`,
 			sourceId: input.sourceId,
 			span: input.attribute.span
 		});
@@ -159,7 +159,7 @@ function parseAttributeFieldList(input) {
 	if (!fields || fields.length === 0) {
 		input.diagnostics.push({
 			code: input.code,
-			message: `${input.messagePrefix} requires bracketed field list argument`,
+			message: `${input.entityLabel} requires bracketed field list argument`,
 			sourceId: input.sourceId,
 			span: input.attribute.span
 		});
@@ -167,6 +167,13 @@ function parseAttributeFieldList(input) {
 	}
 	return fields;
 }
+function findDuplicateFieldName(fieldNames) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of fieldNames) {
+		if (seen.has(name)) return name;
+		seen.add(name);
+	}
+}
 function mapFieldNamesToColumns(input) {
 	const columns = [];
 	for (const fieldName of input.fieldNames) {
@@ -174,7 +181,7 @@ function mapFieldNamesToColumns(input) {
 		if (!columnName) {
 			input.diagnostics.push({
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
+				message: `${input.entityLabel} references unknown field "${input.modelName}.${fieldName}"`,
 				sourceId: input.sourceId,
 				span: input.span
 			});
@@ -620,6 +627,26 @@ function getAuthoringTypeConstructor(contributions, path) {
 	return isAuthoringTypeConstructorDescriptor(current) ? current : void 0;
 }
 /**
+* Walks `authoringContributions.field` segment-by-segment and returns the
+* field-preset descriptor at the resolved path, or `undefined` if no descriptor
+* is registered.
+*
+* Symmetric with `getAuthoringTypeConstructor`. Field presets are strictly
+* richer than type constructors — they can contribute `default` /
+* `executionDefaults` / `id` / `unique` / `nullable` in addition to the
+* `codecId` / `nativeType` / `typeParams` triple. PSL resolution tries field
+* presets first, then falls back to type constructors on miss (see
+* `resolveFieldTypeDescriptor`).
+*/
+function getAuthoringFieldPreset(contributions, path) {
+	let current = contributions?.field;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
+		current = current[segment];
+	}
+	return isAuthoringFieldPresetDescriptor(current) ? current : void 0;
+}
+/**
 * Returns the namespace prefix of `attributeName` if it references an
 * unrecognized extension namespace, otherwise `undefined`. A namespace is
 * considered recognized when it is:
@@ -627,17 +654,19 @@ function getAuthoringTypeConstructor(contributions, path) {
 * - `db` (native-type spec, always allowed),
 * - the active family id (e.g. `sql`),
 * - the active target id (e.g. `postgres`),
+* - a registered field-preset namespace (e.g. `temporal`),
 * - present in `composedExtensions`.
 *
-* Family/target namespaces are exempted so that e.g. `@sql.foo` surfaces as
-* PSL_UNSUPPORTED_*_ATTRIBUTE (the attribute isn't defined) rather than
-* PSL_EXTENSION_NAMESPACE_NOT_COMPOSED (the namespace is already composed).
+* Family/target/field-preset namespaces are exempted so that e.g. `@sql.foo`
+* surfaces as PSL_UNSUPPORTED_*_ATTRIBUTE (the attribute isn't defined)
+* rather than PSL_EXTENSION_NAMESPACE_NOT_COMPOSED (the namespace is already
+* composed).
 */
 function checkUncomposedNamespace(attributeName, composedExtensions, context) {
 	const dotIndex = attributeName.indexOf(".");
 	if (dotIndex <= 0 || dotIndex === attributeName.length - 1) return;
 	const namespace = attributeName.slice(0, dotIndex);
-	if (namespace === "db" || namespace === context?.familyId || namespace === context?.targetId || composedExtensions.has(namespace)) return;
+	if (namespace === "db" || namespace === context?.familyId || namespace === context?.targetId || hasRegisteredFieldNamespace(context?.authoringContributions, namespace) || composedExtensions.has(namespace)) return;
 	return namespace;
 }
 /**
@@ -660,6 +689,24 @@ function reportUncomposedNamespace(input) {
 		}
 	});
 }
+/**
+* Pushes the canonical `PSL_UNKNOWN_FIELD_PRESET` diagnostic when a typoed
+* preset name is referenced inside a registered field-preset namespace. The
+* `data` payload exposes the namespace and full helper path so machine
+* consumers (agents, IDE extensions) don't have to parse the prose.
+*/
+function reportUnknownFieldPreset(input) {
+	input.diagnostics.push({
+		code: "PSL_UNKNOWN_FIELD_PRESET",
+		message: `${input.entityLabel} references unknown field preset "${input.helperPath}". Check the spelling against the available presets in the "${input.namespace}" namespace.`,
+		sourceId: input.sourceId,
+		span: input.span,
+		data: {
+			namespace: input.namespace,
+			helperPath: input.helperPath
+		}
+	});
+}
 function instantiatePslTypeConstructor(input) {
 	const helperPath = input.call.path.join(".");
 	const args = mapPslHelperArgs({
@@ -697,11 +744,15 @@ function pushUnsupportedTypeConstructorDiagnostic(input) {
 function resolvePslTypeConstructorDescriptor(input) {
 	const descriptor = getAuthoringTypeConstructor(input.authoringContributions, input.call.path);
 	if (descriptor) return descriptor;
-	const namespace = input.call.path.length > 1 ? input.call.path[0] : void 0;
-	if (namespace && namespace !== "db" && namespace !== input.familyId && namespace !== input.targetId && !input.composedExtensions.has(namespace)) {
+	const uncomposedNamespace = checkUncomposedNamespace(input.call.path.join("."), input.composedExtensions, {
+		familyId: input.familyId,
+		targetId: input.targetId,
+		authoringContributions: input.authoringContributions
+	});
+	if (uncomposedNamespace) {
 		reportUncomposedNamespace({
 			subjectLabel: `Type constructor "${input.call.path.join(".")}"`,
-			namespace,
+			namespace: uncomposedNamespace,
 			sourceId: input.sourceId,
 			span: input.call.span,
 			diagnostics: input.diagnostics
@@ -716,10 +767,102 @@ function resolvePslTypeConstructorDescriptor(input) {
 		message: input.unsupportedMessage
 	});
 }
+/**
+* Instantiates a field-preset call against its descriptor, coercing PSL AST
+* arguments into the descriptor's typed argument shape and returning the
+* preset's full set of contract contributions.
+*
+* Symmetric with `instantiatePslTypeConstructor` but richer: a field preset
+* can contribute `default`, `executionDefaults`, `id`, `unique`, and
+* `nullable` in addition to the storage-type triple. PSL → typed-args
+* coercion happens here (via `mapPslHelperArgs`) so that
+* `instantiateAuthoringFieldPreset` itself stays typed-input-only and TS
+* keeps its zero-runtime-validation cost.
+*/
+function instantiatePslFieldPreset(input) {
+	const helperPath = input.call.path.join(".");
+	const args = mapPslHelperArgs({
+		args: input.call.args,
+		descriptors: input.descriptor.args ?? [],
+		helperLabel: `preset "${helperPath}"`,
+		span: input.call.span,
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		entityLabel: input.entityLabel
+	});
+	if (!args) return;
+	try {
+		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
+		const instantiated = instantiateAuthoringFieldPreset(input.descriptor, args);
+		return {
+			descriptor: {
+				codecId: instantiated.descriptor.codecId,
+				nativeType: instantiated.descriptor.nativeType,
+				...instantiated.descriptor.typeParams !== void 0 ? { typeParams: instantiated.descriptor.typeParams } : {}
+			},
+			nullable: instantiated.nullable,
+			...instantiated.default !== void 0 ? { default: instantiated.default } : {},
+			...instantiated.executionDefaults !== void 0 ? { executionDefaults: instantiated.executionDefaults } : {},
+			id: instantiated.id,
+			unique: instantiated.unique
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} preset "${helperPath}" ${message}`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return;
+	}
+}
 function resolveFieldTypeDescriptor(input) {
 	if (input.field.typeConstructor) {
+		const presetDescriptor = getAuthoringFieldPreset(input.authoringContributions, input.field.typeConstructor.path);
+		if (presetDescriptor) {
+			const instantiated$1 = instantiatePslFieldPreset({
+				call: input.field.typeConstructor,
+				descriptor: presetDescriptor,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: input.entityLabel
+			});
+			if (!instantiated$1) return {
+				ok: false,
+				alreadyReported: true
+			};
+			const presetContributions = {
+				nullable: instantiated$1.nullable,
+				id: instantiated$1.id,
+				unique: instantiated$1.unique,
+				...instantiated$1.default !== void 0 ? { default: instantiated$1.default } : {},
+				...instantiated$1.executionDefaults !== void 0 ? { executionDefaults: instantiated$1.executionDefaults } : {}
+			};
+			return {
+				ok: true,
+				descriptor: instantiated$1.descriptor,
+				presetContributions
+			};
+		}
 		const helperPath = input.field.typeConstructor.path.join(".");
-		const descriptor$1 = resolvePslTypeConstructorDescriptor({
+		const namespacePrefix = input.field.typeConstructor.path.length > 1 ? input.field.typeConstructor.path[0] : void 0;
+		const typeDescriptor = getAuthoringTypeConstructor(input.authoringContributions, input.field.typeConstructor.path);
+		if (!typeDescriptor && namespacePrefix && hasRegisteredFieldNamespace(input.authoringContributions, namespacePrefix)) {
+			reportUnknownFieldPreset({
+				entityLabel: input.entityLabel,
+				namespace: namespacePrefix,
+				helperPath,
+				sourceId: input.sourceId,
+				span: input.field.typeConstructor.span,
+				diagnostics: input.diagnostics
+			});
+			return {
+				ok: false,
+				alreadyReported: true
+			};
+		}
+		const descriptor$1 = typeDescriptor ?? resolvePslTypeConstructorDescriptor({
 			call: input.field.typeConstructor,
 			authoringContributions: input.authoringContributions,
 			composedExtensions: input.composedExtensions,
@@ -985,6 +1128,15 @@ function lowerDefaultForField(input) {
 		});
 		return {};
 	}
+	if (generatorDescriptor.applicableCodecIds === void 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+			message: `Default generator "${generatorDescriptor.id}" is not applicable to "@default(...)" lowering. Use the corresponding field preset (e.g. \`temporal.${generatorDescriptor.id === "timestampNow" ? "updatedAt" : generatorDescriptor.id}()\`) instead.`,
+			sourceId: input.sourceId,
+			span: expressionEntry.span
+		});
+		return {};
+	}
 	if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
 		input.diagnostics.push({
 			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
@@ -994,7 +1146,7 @@ function lowerDefaultForField(input) {
 		});
 		return {};
 	}
-	return { executionDefault: lowered.value.generated };
+	return { executionDefaults: { onCreate: lowered.value.generated } };
 }
 function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors) {
 	if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) return namedTypeDescriptors.get(field.typeRef);
@@ -1012,12 +1164,21 @@ const BUILTIN_FIELD_ATTRIBUTE_NAMES = new Set([
 	"relation",
 	"map"
 ]);
+const REMOVED_ATTRIBUTE_RULES = 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 Error(`BUILTIN_FIELD_ATTRIBUTE_NAMES 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;
 		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1029,9 +1190,12 @@ function validateFieldAttributes(input) {
 			});
 			continue;
 		}
+		const baseMessage = `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`;
+		const removedRule = REMOVED_ATTRIBUTE_RULES.get(attribute.name);
+		const message = removedRule && !removedRule.suppressWhen(input.field) ? `${baseMessage}. ${removedRule.hint}` : baseMessage;
 		input.diagnostics.push({
 			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-			message: `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+			message,
 			sourceId: input.sourceId,
 			span: attribute.span
 		});
@@ -1065,21 +1229,25 @@ function collectResolvedFields(input) {
 	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors } = input;
 	const resolvedFields = [];
 	for (const field of model.fields) {
-		if (field.list && modelNames.has(field.typeName)) continue;
+		const isModelField = modelNames.has(field.typeName);
+		if (field.list && isModelField) continue;
 		validateFieldAttributes({
 			model,
 			field,
 			composedExtensions,
+			authoringContributions,
 			diagnostics,
 			sourceId,
 			familyId,
 			targetId
 		});
-		if (getAttribute(field.attributes, "relation") && modelNames.has(field.typeName)) continue;
+		const relationAttribute = getAttribute(field.attributes, "relation");
+		if (isModelField && relationAttribute) continue;
 		const isValueObjectField = compositeTypeNames.has(field.typeName);
 		const isListField = field.list;
 		let descriptor;
 		let scalarCodecId;
+		let presetContributions;
 		const resolveInput = {
 			field,
 			enumTypeDescriptors,
@@ -1105,6 +1273,15 @@ function collectResolvedFields(input) {
 				});
 				continue;
 			}
+			if (resolved.presetContributions) {
+				diagnostics.push({
+					code: "PSL_PRESET_NOT_LIST",
+					message: `Field "${model.name}.${field.name}" uses a field-preset call as a list element type. Presets cannot be list elements; remove "[]" or use a scalar type.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
 			scalarCodecId = resolved.descriptor.codecId;
 			descriptor = scalarTypeDescriptors.get("Json");
 		} else {
@@ -1119,9 +1296,28 @@ function collectResolvedFields(input) {
 				continue;
 			}
 			descriptor = resolved.descriptor;
+			presetContributions = resolved.presetContributions;
 		}
 		if (!descriptor) continue;
+		if (presetContributions && field.optional) {
+			diagnostics.push({
+				code: "PSL_PRESET_NOT_OPTIONAL",
+				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot be optional. Remove "?" or use a different field type.`,
+				sourceId,
+				span: field.span
+			});
+			continue;
+		}
 		const defaultAttribute = getAttribute(field.attributes, "default");
+		if (presetContributions && defaultAttribute) {
+			diagnostics.push({
+				code: "PSL_PRESET_AND_DEFAULT_CONFLICT",
+				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot also declare @default(...). The preset already specifies the default value.`,
+				sourceId,
+				span: defaultAttribute.span
+			});
+			continue;
+		}
 		const loweredDefault = defaultAttribute ? lowerDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
@@ -1132,8 +1328,9 @@ function collectResolvedFields(input) {
 			defaultFunctionRegistry,
 			diagnostics
 		}) : {};
-		if (field.optional && loweredDefault.executionDefault) {
-			const generatorDescription = loweredDefault.executionDefault.kind === "generator" ? `"${loweredDefault.executionDefault.id}"` : "for this field";
+		const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
+		if (field.optional && loweredOnCreate) {
+			const generatorDescription = loweredOnCreate.kind === "generator" ? `"${loweredOnCreate.id}"` : "for this field";
 			diagnostics.push({
 				code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
 				message: `Field "${model.name}.${field.name}" cannot be optional when using execution default ${generatorDescription}. Remove "?" or use a storage default.`,
@@ -1142,8 +1339,8 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		if (loweredDefault.executionDefault) {
-			const generatedDescriptor = generatorDescriptorById.get(loweredDefault.executionDefault.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredDefault.executionDefault });
+		if (loweredOnCreate) {
+			const generatedDescriptor = generatorDescriptorById.get(loweredOnCreate.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredOnCreate });
 			if (generatedDescriptor) descriptor = generatedDescriptor;
 		}
 		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
@@ -1153,14 +1350,35 @@ function collectResolvedFields(input) {
 			sourceId,
 			diagnostics
 		});
+		let isIdField = Boolean(idAttribute);
+		if (idAttribute && field.optional) {
+			diagnostics.push({
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: `Field "${model.name}.${field.name}" @id cannot be optional; primary key columns must be NOT NULL`,
+				sourceId,
+				span: idAttribute.span
+			});
+			isIdField = false;
+		}
+		if (presetContributions && idAttribute && !presetContributions.id) {
+			diagnostics.push({
+				code: "PSL_PRESET_AND_ID_CONFLICT",
+				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot also declare @id. Use a preset that contributes id semantics, or drop @id.`,
+				sourceId,
+				span: idAttribute.span
+			});
+			continue;
+		}
+		const fieldExecutionDefaults = presetContributions?.executionDefaults ?? loweredDefault.executionDefaults;
+		const fieldDefaultValue = presetContributions?.default ?? loweredDefault.defaultValue;
 		resolvedFields.push({
 			field,
 			columnName: mappedColumnName,
 			descriptor,
-			...ifDefined("defaultValue", loweredDefault.defaultValue),
-			...ifDefined("executionDefault", loweredDefault.executionDefault),
-			isId: Boolean(idAttribute),
-			isUnique: Boolean(uniqueAttribute),
+			...ifDefined("defaultValue", fieldDefaultValue),
+			...ifDefined("executionDefaults", fieldExecutionDefaults),
+			isId: isIdField || Boolean(presetContributions?.id),
+			isUnique: Boolean(uniqueAttribute) || Boolean(presetContributions?.unique),
 			...ifDefined("idName", idName),
 			...ifDefined("uniqueName", uniqueName),
 			...ifDefined("many", isListField ? true : void 0),
@@ -1418,7 +1636,8 @@ function validateNavigationListFieldAttributes(input) {
 		if (attribute.name === "relation") continue;
 		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1531,7 +1750,8 @@ function validateNamedTypeAttributes(input) {
 		if (input.allowDbNativeType && attribute.name.startsWith("db.")) continue;
 		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1567,6 +1787,7 @@ function resolveNamedTypeDeclarations(input) {
 				sourceId: input.sourceId,
 				diagnostics: input.diagnostics,
 				composedExtensions: input.composedExtensions,
+				authoringContributions: input.authoringContributions,
 				allowDbNativeType: false,
 				familyId: input.familyId,
 				targetId: input.targetId
@@ -1626,6 +1847,7 @@ function resolveNamedTypeDeclarations(input) {
 			sourceId: input.sourceId,
 			diagnostics: input.diagnostics,
 			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
 			allowDbNativeType: true,
 			familyId: input.familyId,
 			targetId: input.targetId
@@ -1682,16 +1904,20 @@ function buildModelNodeFromPsl(input) {
 		sourceId,
 		scalarTypeDescriptors: input.scalarTypeDescriptors
 	});
-	const primaryKeyFields = resolvedFields.filter((field) => field.isId);
-	const primaryKeyColumns = primaryKeyFields.map((field) => field.columnName);
-	const primaryKeyName = primaryKeyFields.length === 1 ? primaryKeyFields[0]?.idName : void 0;
-	const isVariantModel = model.attributes.some((attr) => attr.name === "base");
-	if (primaryKeyColumns.length === 0 && !isVariantModel) diagnostics.push({
-		code: "PSL_MISSING_PRIMARY_KEY",
-		message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
+	const inlineIdFields = resolvedFields.filter((field) => field.isId);
+	if (inlineIdFields.length > 1) diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `Model "${model.name}" cannot declare inline @id on multiple fields; use model-level @@id([...]) for composite identity`,
 		sourceId,
 		span: model.span
 	});
+	const singleInlineIdField = inlineIdFields.length === 1 ? inlineIdFields[0] : void 0;
+	let primaryKey = singleInlineIdField ? {
+		columns: [singleInlineIdField.columnName],
+		...ifDefined("name", singleInlineIdField.idName)
+	} : void 0;
+	const hasInlinePrimaryKey = primaryKey !== void 0;
+	let blockPrimaryKeyDeclared = false;
 	const resultBackrelationCandidates = [];
 	for (const field of model.fields) {
 		if (!field.list || !input.modelNames.has(field.typeName)) continue;
@@ -1700,6 +1926,7 @@ function buildModelNodeFromPsl(input) {
 			field,
 			sourceId,
 			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
 			diagnostics,
 			familyId: input.familyId,
 			targetId: input.targetId
@@ -1757,15 +1984,98 @@ function buildModelNodeFromPsl(input) {
 	for (const modelAttribute of model.attributes) {
 		if (modelAttribute.name === "map") continue;
 		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
+		const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
+		if (modelAttribute.name === "id") {
+			if (blockPrimaryKeyDeclared) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" declares @@id more than once`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			if (hasInlinePrimaryKey) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" cannot declare both field-level @id and model-level @@id`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				blockPrimaryKeyDeclared = true;
+				continue;
+			}
+			const fieldNames = parseAttributeFieldList({
+				attribute: modelAttribute,
+				sourceId,
+				diagnostics,
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				entityLabel: attributeLabel
+			});
+			if (!fieldNames) continue;
+			const duplicateFieldName = findDuplicateFieldName(fieldNames);
+			if (duplicateFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} list contains duplicate field "${duplicateFieldName}"`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			const nullableFieldName = fieldNames.find((name) => model.fields.find((f) => f.name === name)?.optional === true);
+			if (nullableFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} cannot include optional field "${nullableFieldName}"; primary key columns must be NOT NULL`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			const columnNames = mapFieldNamesToColumns({
+				modelName: model.name,
+				fieldNames,
+				mapping,
+				sourceId,
+				diagnostics,
+				span: modelAttribute.span,
+				entityLabel: attributeLabel
+			});
+			if (!columnNames) continue;
+			primaryKey = {
+				columns: columnNames,
+				...ifDefined("name", parseConstraintMapArgument({
+					attribute: modelAttribute,
+					sourceId,
+					diagnostics,
+					entityLabel: attributeLabel,
+					span: modelAttribute.span,
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+				}))
+			};
+			blockPrimaryKeyDeclared = true;
+			continue;
+		}
 		if (modelAttribute.name === "unique" || modelAttribute.name === "index") {
 			const fieldNames = parseAttributeFieldList({
 				attribute: modelAttribute,
 				sourceId,
 				diagnostics,
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`
+				entityLabel: attributeLabel
 			});
 			if (!fieldNames) continue;
+			const duplicateFieldName = findDuplicateFieldName(fieldNames);
+			if (duplicateFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} list contains duplicate field "${duplicateFieldName}"`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
 			const columnNames = mapFieldNamesToColumns({
 				modelName: model.name,
 				fieldNames,
@@ -1773,14 +2083,14 @@ function buildModelNodeFromPsl(input) {
 				sourceId,
 				diagnostics,
 				span: modelAttribute.span,
-				contextLabel: `Model "${model.name}" @@${modelAttribute.name}`
+				entityLabel: attributeLabel
 			});
 			if (!columnNames) continue;
 			const constraintName = parseConstraintMapArgument({
 				attribute: modelAttribute,
 				sourceId,
 				diagnostics,
-				entityLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+				entityLabel: attributeLabel,
 				span: modelAttribute.span,
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
 			});
@@ -1796,7 +2106,8 @@ function buildModelNodeFromPsl(input) {
 		}
 		const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1861,7 +2172,7 @@ function buildModelNodeFromPsl(input) {
 			sourceId,
 			diagnostics,
 			span: relationAttribute.relation.span,
-			contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
 		});
 		if (!localColumns) continue;
 		const referencedColumns = mapFieldNamesToColumns({
@@ -1871,7 +2182,7 @@ function buildModelNodeFromPsl(input) {
 			sourceId,
 			diagnostics,
 			span: relationAttribute.relation.span,
-			contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
 		});
 		if (!referencedColumns) continue;
 		if (localColumns.length !== referencedColumns.length) {
@@ -1933,12 +2244,9 @@ function buildModelNodeFromPsl(input) {
 				descriptor: resolvedField.descriptor,
 				nullable: resolvedField.field.optional,
 				...ifDefined("default", resolvedField.defaultValue),
-				...ifDefined("executionDefault", resolvedField.executionDefault)
+				...ifDefined("executionDefaults", resolvedField.executionDefaults)
 			})),
-			...primaryKeyColumns.length > 0 ? { id: {
-				columns: primaryKeyColumns,
-				...ifDefined("name", primaryKeyName)
-			} } : {},
+			...ifDefined("id", primaryKey),
 			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
 			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
 			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}
@@ -2340,4 +2648,4 @@ function interpretPslDocumentToSqlContract(input) {
 
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
-//# sourceMappingURL=interpreter-iFCRN9nb.mjs.map
+//# sourceMappingURL=interpreter-BChe-9vN.mjs.map