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

package/src/psl-column-resolution.ts

@@ -1,11 +1,15 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
-import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next/contract/types';
 import type {
   AuthoringContributions,
+  AuthoringFieldPresetDescriptor,
   AuthoringTypeConstructorDescriptor,
 } from '@prisma-next/framework-components/authoring';
 import {
+  hasRegisteredFieldNamespace,
+  instantiateAuthoringFieldPreset,
   instantiateAuthoringTypeConstructor,
+  isAuthoringFieldPresetDescriptor,
   isAuthoringTypeConstructorDescriptor,
   validateAuthoringHelperArguments,
 } from '@prisma-next/framework-components/authoring';
@@ -67,6 +71,34 @@ export function getAuthoringTypeConstructor(
   return isAuthoringTypeConstructorDescriptor(current) ? current : undefined;
 }
 
+/**
+ * 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`).
+ */
+export function getAuthoringFieldPreset(
+  contributions: AuthoringContributions | undefined,
+  path: readonly string[],
+): AuthoringFieldPresetDescriptor | undefined {
+  let current: unknown = contributions?.field;
+
+  for (const segment of path) {
+    if (typeof current !== 'object' || current === null || Array.isArray(current)) {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[segment];
+  }
+
+  return isAuthoringFieldPresetDescriptor(current) ? current : undefined;
+}
+
 /**
  * Returns the namespace prefix of `attributeName` if it references an
  * unrecognized extension namespace, otherwise `undefined`. A namespace is
@@ -75,16 +107,22 @@ export function getAuthoringTypeConstructor(
  * - `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).
  */
 export function checkUncomposedNamespace(
   attributeName: string,
   composedExtensions: ReadonlySet<string>,
-  context?: { readonly familyId?: string; readonly targetId?: string },
+  context?: {
+    readonly familyId?: string;
+    readonly targetId?: string;
+    readonly authoringContributions?: AuthoringContributions | undefined;
+  },
 ): string | undefined {
   const dotIndex = attributeName.indexOf('.');
   if (dotIndex <= 0 || dotIndex === attributeName.length - 1) {
@@ -95,6 +133,7 @@ export function checkUncomposedNamespace(
     namespace === 'db' ||
     namespace === context?.familyId ||
     namespace === context?.targetId ||
+    hasRegisteredFieldNamespace(context?.authoringContributions, namespace) ||
     composedExtensions.has(namespace)
   ) {
     return undefined;
@@ -126,6 +165,29 @@ export 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.
+ */
+export function reportUnknownFieldPreset(input: {
+  readonly entityLabel: string;
+  readonly namespace: string;
+  readonly helperPath: string;
+  readonly sourceId: string;
+  readonly span: PslSpan;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): void {
+  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 },
+  });
+}
+
 export function instantiatePslTypeConstructor(input: {
   readonly call: PslTypeConstructorCall;
   readonly descriptor: AuthoringTypeConstructorDescriptor;
@@ -200,17 +262,19 @@ export function resolvePslTypeConstructorDescriptor(input: {
     return descriptor;
   }
 
-  const namespace = input.call.path.length > 1 ? input.call.path[0] : undefined;
-  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,
@@ -227,8 +291,99 @@ export function resolvePslTypeConstructorDescriptor(input: {
   });
 }
 
+/**
+ * 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.
+ */
+export function instantiatePslFieldPreset(input: {
+  readonly call: PslTypeConstructorCall;
+  readonly descriptor: AuthoringFieldPresetDescriptor;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly entityLabel: string;
+}):
+  | {
+      readonly descriptor: ColumnDescriptor;
+      readonly nullable: boolean;
+      readonly default?: ColumnDefault;
+      readonly executionDefaults?: ExecutionMutationDefaultPhases;
+      readonly id: boolean;
+      readonly unique: boolean;
+    }
+  | undefined {
+  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 undefined;
+  }
+
+  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 !== undefined
+          ? { typeParams: instantiated.descriptor.typeParams }
+          : {}),
+      },
+      nullable: instantiated.nullable,
+      ...(instantiated.default !== undefined ? { default: instantiated.default } : {}),
+      ...(instantiated.executionDefaults !== undefined
+        ? { 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 undefined;
+  }
+}
+
+/**
+ * Contract contributions a field preset adds beyond the bare storage-type
+ * triple. Set when a field is resolved through the field-preset dispatch
+ * path; absent when resolved through the type-constructor path or as a
+ * scalar/enum/named-type lookup.
+ */
+export type FieldPresetContributions = {
+  readonly nullable: boolean;
+  readonly id: boolean;
+  readonly unique: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+};
+
 export type ResolveFieldTypeResult =
-  | { readonly ok: true; readonly descriptor: ColumnDescriptor }
+  | {
+      readonly ok: true;
+      readonly descriptor: ColumnDescriptor;
+      readonly presetContributions?: FieldPresetContributions;
+    }
   | { readonly ok: false; readonly alreadyReported: boolean };
 
 export function resolveFieldTypeDescriptor(input: {
@@ -245,18 +400,73 @@ export function resolveFieldTypeDescriptor(input: {
   readonly entityLabel: string;
 }): ResolveFieldTypeResult {
   if (input.field.typeConstructor) {
+    // Field presets carry richer semantics than type constructors, so a field
+    // preset match is the complete answer. Shared composition rejects exact
+    // cross-registry collisions before PSL resolution can observe them.
+    const presetDescriptor = getAuthoringFieldPreset(
+      input.authoringContributions,
+      input.field.typeConstructor.path,
+    );
+    if (presetDescriptor) {
+      const instantiated = instantiatePslFieldPreset({
+        call: input.field.typeConstructor,
+        descriptor: presetDescriptor,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        entityLabel: input.entityLabel,
+      });
+      if (!instantiated) {
+        return { ok: false, alreadyReported: true };
+      }
+      const presetContributions: FieldPresetContributions = {
+        nullable: instantiated.nullable,
+        id: instantiated.id,
+        unique: instantiated.unique,
+        ...(instantiated.default !== undefined ? { default: instantiated.default } : {}),
+        ...(instantiated.executionDefaults !== undefined
+          ? { executionDefaults: instantiated.executionDefaults }
+          : {}),
+      };
+      return { ok: true, descriptor: instantiated.descriptor, presetContributions };
+    }
+
     const helperPath = input.field.typeConstructor.path.join('.');
-    const descriptor = resolvePslTypeConstructorDescriptor({
-      call: input.field.typeConstructor,
-      authoringContributions: input.authoringContributions,
-      composedExtensions: input.composedExtensions,
-      familyId: input.familyId,
-      targetId: input.targetId,
-      diagnostics: input.diagnostics,
-      sourceId: input.sourceId,
-      unsupportedCode: 'PSL_UNSUPPORTED_FIELD_TYPE',
-      unsupportedMessage: `${input.entityLabel} type constructor "${helperPath}" is not supported in SQL PSL provider v1`,
-    });
+    const namespacePrefix =
+      input.field.typeConstructor.path.length > 1 ? input.field.typeConstructor.path[0] : undefined;
+    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 =
+      typeDescriptor ??
+      resolvePslTypeConstructorDescriptor({
+        call: input.field.typeConstructor,
+        authoringContributions: input.authoringContributions,
+        composedExtensions: input.composedExtensions,
+        familyId: input.familyId,
+        targetId: input.targetId,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        unsupportedCode: 'PSL_UNSUPPORTED_FIELD_TYPE',
+        unsupportedMessage: `${input.entityLabel} type constructor "${helperPath}" is not supported in SQL PSL provider v1`,
+      });
     if (!descriptor) {
       return { ok: false, alreadyReported: true };
     }
@@ -495,7 +705,7 @@ export function lowerDefaultForField(input: {
   readonly diagnostics: ContractSourceDiagnostic[];
 }): {
   readonly defaultValue?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
 } {
   const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === 'positional');
   const namedEntries = input.defaultAttribute.args.filter((arg) => arg.kind === 'named');
@@ -568,6 +778,21 @@ export function lowerDefaultForField(input: {
     return {};
   }
 
+  // Preset-only generators (e.g. `timestampNow`) co-register their codec
+  // through the preset descriptor, so they don't carry an
+  // `applicableCodecIds` list. Such a generator surfacing on the
+  // `@default(...)` lowering path is itself the bug — emit a diagnostic
+  // pointing the user at the correct authoring surface.
+  if (generatorDescriptor.applicableCodecIds === undefined) {
+    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',
@@ -578,7 +803,7 @@ export function lowerDefaultForField(input: {
     return {};
   }
 
-  return { executionDefault: lowered.value.generated };
+  return { executionDefaults: { onCreate: lowered.value.generated } };
 }
 
 export function resolveColumnDescriptor(

package/src/psl-field-resolution.ts

@@ -1,5 +1,5 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
-import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next/contract/types';
 import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
 import type {
   ControlMutationDefaultRegistry,
@@ -13,7 +13,7 @@ import {
   parseConstraintMapArgument,
   parseMapName,
 } from './psl-attribute-parsing';
-import type { ColumnDescriptor } from './psl-column-resolution';
+import type { ColumnDescriptor, FieldPresetContributions } from './psl-column-resolution';
 import {
   checkUncomposedNamespace,
   lowerDefaultForField,
@@ -26,7 +26,7 @@ export type ResolvedField = {
   readonly columnName: string;
   readonly descriptor: ColumnDescriptor;
   readonly defaultValue?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
   readonly isId: boolean;
   readonly isUnique: boolean;
   readonly idName?: string;
@@ -68,10 +68,54 @@ const BUILTIN_FIELD_ATTRIBUTE_NAMES: ReadonlySet<string> = new Set([
   'map',
 ]);
 
+/**
+ * Per-attribute migration rule for attributes that have been removed
+ * from PSL in favor of the field-preset surface. The `hint` text is
+ * appended to the `PSL_UNSUPPORTED_FIELD_ATTRIBUTE` message so users
+ * porting Prisma 6 schemas see "use this preset instead" inline; the
+ * `suppressWhen` predicate skips the hint when the user has already
+ * migrated (so they don't get told to do what they just did).
+ *
+ * Pairing the suppression predicate with the hint makes each entry
+ * self-contained: a future entry for, say, `@id` ↔ `id.uuidv7()` cannot
+ * silently inherit the wrong predicate when added.
+ */
+interface RemovedAttributeRule {
+  readonly hint: string;
+  readonly suppressWhen: (field: PslField) => boolean;
+}
+
+const REMOVED_ATTRIBUTE_RULES: ReadonlyMap<string, RemovedAttributeRule> = new Map([
+  [
+    'updatedAt',
+    {
+      hint: 'Use `temporal.updatedAt()` as a field-preset call instead.',
+      suppressWhen: (field) => field.typeConstructor?.path[0] === 'temporal',
+    },
+  ],
+]);
+
+// `validateFieldAttributes` short-circuits on `BUILTIN_FIELD_ATTRIBUTE_NAMES`
+// before consulting `REMOVED_ATTRIBUTE_RULES`. A name appearing in both sets
+// would silently suppress its migration hint, defeating the purpose of the
+// hint table. Fail at module load with a clear message — the table is
+// designed to grow and this is the cheap insurance against future drift.
+{
+  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: {
   readonly model: PslModel;
   readonly field: PslField;
   readonly composedExtensions: ReadonlySet<string>;
+  readonly authoringContributions: AuthoringContributions | undefined;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly familyId: string;
@@ -85,6 +129,7 @@ function validateFieldAttributes(input: {
     const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
       familyId: input.familyId,
       targetId: input.targetId,
+      authoringContributions: input.authoringContributions,
     });
     if (uncomposedNamespace) {
       reportUncomposedNamespace({
@@ -97,9 +142,16 @@ 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,
     });
@@ -159,7 +211,9 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
   const resolvedFields: ResolvedField[] = [];
 
   for (const field of model.fields) {
-    if (field.list && modelNames.has(field.typeName)) {
+    const isModelField = modelNames.has(field.typeName);
+
+    if (field.list && isModelField) {
       continue;
     }
 
@@ -167,6 +221,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       model,
       field,
       composedExtensions,
+      authoringContributions,
       diagnostics,
       sourceId,
       familyId,
@@ -174,7 +229,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
     });
 
     const relationAttribute = getAttribute(field.attributes, 'relation');
-    if (relationAttribute && modelNames.has(field.typeName)) {
+    if (isModelField && relationAttribute) {
       continue;
     }
 
@@ -183,6 +238,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
 
     let descriptor: ColumnDescriptor | undefined;
     let scalarCodecId: string | undefined;
+    let presetContributions: FieldPresetContributions | undefined;
     const resolveInput = {
       field,
       enumTypeDescriptors,
@@ -212,6 +268,17 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
         }
         continue;
       }
+      // Field presets are complete declarations — they carry their own codec
+      // and do not compose with `[]` list-of semantics. Reject early.
+      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 {
@@ -228,13 +295,37 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
         continue;
       }
       descriptor = resolved.descriptor;
+      presetContributions = resolved.presetContributions;
     }
 
     if (!descriptor) {
       continue;
     }
 
+    // Field presets are complete declarations: the preset names its own codec
+    // and contributes any combination of default / executionDefaults / id /
+    // unique. Optional and `@default(...)` modifiers contradict that, so they
+    // are hard errors per spec FR7.
+    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,
@@ -247,11 +338,10 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
           diagnostics,
         })
       : {};
-    if (field.optional && loweredDefault.executionDefault) {
+    const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
+    if (field.optional && loweredOnCreate) {
       const generatorDescription =
-        loweredDefault.executionDefault.kind === 'generator'
-          ? `"${loweredDefault.executionDefault.id}"`
-          : 'for this field';
+        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.`,
@@ -260,10 +350,10 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       });
       continue;
     }
-    if (loweredDefault.executionDefault) {
-      const generatorDescriptor = generatorDescriptorById.get(loweredDefault.executionDefault.id);
+    if (loweredOnCreate) {
+      const generatorDescriptor = generatorDescriptorById.get(loweredOnCreate.id);
       const generatedDescriptor = generatorDescriptor?.resolveGeneratedColumnDescriptor?.({
-        generated: loweredDefault.executionDefault,
+        generated: loweredOnCreate,
       });
       if (generatedDescriptor) {
         descriptor = generatedDescriptor;
@@ -276,15 +366,46 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       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;
+    }
+
+    // Field presets contribute their own default / executionDefaults / id /
+    // unique. They take precedence over attribute-derived contributions for
+    // this field, since a preset *is* the field declaration. Conflicts with
+    // `@default` and optional are already rejected above; explicit `@id`
+    // would be redundant noise on the resolved field, so we surface it as
+    // a hard error here for symmetry.
+    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;
+    }
 
+    // Field-preset contributions take precedence over attribute-derived
+    // sources when present.
+    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 as const) : undefined),

package/src/psl-relation-resolution.ts

@@ -1,4 +1,5 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
+import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
 import type { PslAttribute, PslField, PslSpan } from '@prisma-next/psl-parser';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
 import type { RelationNode } from '@prisma-next/sql-contract-ts/contract-builder';
@@ -334,6 +335,7 @@ export function validateNavigationListFieldAttributes(input: {
   readonly field: PslField;
   readonly sourceId: string;
   readonly composedExtensions: Set<string>;
+  readonly authoringContributions: AuthoringContributions | undefined;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly familyId: string;
   readonly targetId: string;
@@ -347,6 +349,7 @@ export function validateNavigationListFieldAttributes(input: {
     const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
       familyId: input.familyId,
       targetId: input.targetId,
+      authoringContributions: input.authoringContributions,
     });
     if (uncomposedNamespace) {
       reportUncomposedNamespace({