@prisma-next/sql-contract-psl 0.5.0-dev.51 → 0.5.0-dev.52

package/README.md

@@ -15,6 +15,7 @@ This keeps core/CLI source-agnostic while giving PSL-first SQL users a one-line
 
 - Interpret `ParsePslDocumentResult` into SQL `Contract`
 - Interpret generic PSL attributes into SQL contract semantics (`@id`, `@unique`, `@default`, `@relation`, `@map`, `@@map`)
+- Interpret SQL timestamp semantics: `DateTime @default(now())` (or the equivalent `temporal.createdAt()` field-preset call) as a storage default, and `temporal.updatedAt()` as an execution mutation default
 - Lower shared constructor expressions in both `types {}` blocks and inline field positions (for example `ShortName = sql.String(length: 35)` and `embedding pgvector.Vector(length: 1536)?`)
 - Lower supported default functions through composed registry inputs
 - Support selected Postgres native-type attributes on named types for brownfield round-trips (`@db.Char`, `@db.VarChar`, `@db.Numeric`, `@db.Uuid`, `@db.SmallInt`, `@db.Real`, `@db.Timestamp`, `@db.Timestamptz`, `@db.Date`, `@db.Time`, `@db.Timetz`, `@db.Json`)
@@ -42,7 +43,7 @@ The **pure interpreter entrypoint** specifically excludes:
 - Artifact emission (`contract.json`, `contract.d.ts`) and hashing
 - CLI or ControlClient orchestration
 
-Current scope is SQL/Postgres-first: callers pass Postgres-oriented scalar descriptors and target context in v1.
+Current scope is SQL target-specific: callers pass scalar descriptors and target context assembled for the active SQL target.
 
 Unsupported PSL constructs in v1 (strict errors):
 
@@ -63,6 +64,13 @@ Supported `@default(...)` surface in v1 when composed contributors provide handl
 - Explicitly unsupported in v1: `cuid()` (diagnostic suggests `cuid(2)`)
 - `dbgenerated("...")` preserves the parsed PSL string-literal contents as-is (escaped sequences are not normalized in v1).
 
+Supported timestamp authoring surface:
+
+- `createdAt DateTime @default(now())` and `createdAt temporal.createdAt()` both lower to the target storage default and do not create an execution mutation default.
+- `updatedAt temporal.updatedAt()` lowers to `timestampNow` on create and on non-empty update mutations. This is application-side because update-time semantics are mutation-aware, not a database trigger.
+- The Prisma-flavored `@updatedAt` attribute is not supported; references produce `PSL_UNSUPPORTED_FIELD_ATTRIBUTE` with a migration hint pointing at `temporal.updatedAt()`. The hint is suppressed when the field already declares any `temporal.*` preset.
+- `@createdAt` is not supported as a PSL alias.
+
 ## Public API
 
 - `@prisma-next/sql-contract-psl`

package/dist/index.d.mts

@@ -17,10 +17,10 @@ type ColumnDescriptor = {
 //#region src/interpreter.d.ts
 interface InterpretPslDocumentToSqlContractInput {
   readonly document: ParsePslDocumentResult;
-  readonly target: TargetPackRef<'sql', 'postgres'>;
+  readonly target: TargetPackRef<'sql', string>;
   readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly composedExtensionPacks?: readonly string[];
-  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', 'postgres'>[];
+  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];
   readonly controlMutationDefaults?: ControlMutationDefaults$1;
   readonly authoringContributions?: AuthoringContributions;
 }

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAmCY,gBAAA;;;;EAAA,SAAA,UAAgB,CAAA,EAIJ,MAJI,CAAA,MAIJ,EAAM,OAAA,CAAA;;;;UCsCb,sCAAA;ED1CL,SAAA,QAAA,EC2CS,sBDvCS;mBCwCX;kCACe,oBAAoB;;EAHrC,SAAA,yBAAA,CAAA,EAAA,SAK+B,gBALO,CAAA,KAAA,EAAA,UAAA,CAAA,EAAA;EAClC,SAAA,uBAAA,CAAA,EAKgB,yBALhB;EACF,SAAA,sBAAA,CAAA,EAKiB,sBALjB;;AACe,iBAu/BlB,iCAAA,CAv/BkB,KAAA,EAw/BzB,sCAx/ByB,CAAA,EAy/B/B,MAz/B+B,CAy/BxB,QAz/BwB,EAy/Bd,yBAz/Bc,CAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAuCY,gBAAA;;;;EAAA,SAAA,UAAgB,CAAA,EAIJ,MAJI,CAAA,MAIJ,EAAM,OAAA,CAAA;;;;UCkCb,sCAAA;EDtCL,SAAA,QAAA,ECuCS,sBDnCS;mBCoCX;kCACe,oBAAoB;;EAHrC,SAAA,yBAAA,CAAA,EAAA,SAK+B,gBALO,CAAA,KAAA,EAAA,MAAA,CAAA,EAAA;EAClC,SAAA,uBAAA,CAAA,EAKgB,yBALhB;EACF,SAAA,sBAAA,CAAA,EAKiB,sBALjB;;AACe,iBAggClB,iCAAA,CAhgCkB,KAAA,EAigCzB,sCAjgCyB,CAAA,EAkgC/B,MAlgC+B,CAkgCxB,QAlgCwB,EAkgCd,yBAlgCc,CAAA"}

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-iFCRN9nb.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-DJrrH8Ee.mjs";
 
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-iFCRN9nb.mjs → interpreter-DJrrH8Ee.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";
@@ -620,6 +620,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 +647,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 +682,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 +737,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 +760,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 +1121,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 +1139,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 +1157,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 +1183,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 +1222,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 +1266,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 +1289,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 +1321,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 +1332,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 +1343,25 @@ function collectResolvedFields(input) {
 			sourceId,
 			diagnostics
 		});
+		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: Boolean(idAttribute) || Boolean(presetContributions?.id),
+			isUnique: Boolean(uniqueAttribute) || Boolean(presetContributions?.unique),
 			...ifDefined("idName", idName),
 			...ifDefined("uniqueName", uniqueName),
 			...ifDefined("many", isListField ? true : void 0),
@@ -1418,7 +1619,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 +1733,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 +1770,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 +1830,7 @@ function resolveNamedTypeDeclarations(input) {
 			sourceId: input.sourceId,
 			diagnostics: input.diagnostics,
 			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
 			allowDbNativeType: true,
 			familyId: input.familyId,
 			targetId: input.targetId
@@ -1700,6 +1905,7 @@ function buildModelNodeFromPsl(input) {
 			field,
 			sourceId,
 			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
 			diagnostics,
 			familyId: input.familyId,
 			targetId: input.targetId
@@ -1796,7 +2002,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({
@@ -1933,7 +2140,7 @@ 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,
@@ -2340,4 +2547,4 @@ function interpretPslDocumentToSqlContract(input) {
 
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
-//# sourceMappingURL=interpreter-iFCRN9nb.mjs.map
+//# sourceMappingURL=interpreter-DJrrH8Ee.mjs.map