@prisma-next/sql-contract-psl 0.3.0-dev.71 → 0.4.0-dev.1

package/src/psl-field-resolution.ts

@@ -0,0 +1,335 @@
+import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
+import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
+import type { PslAttribute, PslField, PslModel } from '@prisma-next/psl-parser';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type {
+  ControlMutationDefaultRegistry,
+  MutationDefaultGeneratorDescriptor,
+} from './default-function-registry';
+import {
+  getAttribute,
+  lowerFirst,
+  parseConstraintMapArgument,
+  parseMapName,
+} from './psl-attribute-parsing';
+import type { ColumnDescriptor } from './psl-column-resolution';
+import {
+  checkUncomposedNamespace,
+  lowerDefaultForField,
+  reportUncomposedNamespace,
+  resolveFieldTypeDescriptor,
+} from './psl-column-resolution';
+
+export type ResolvedField = {
+  readonly field: PslField;
+  readonly columnName: string;
+  readonly descriptor: ColumnDescriptor;
+  readonly defaultValue?: ColumnDefault;
+  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly isId: boolean;
+  readonly isUnique: boolean;
+  readonly idName?: string;
+  readonly uniqueName?: string;
+  readonly many?: true;
+  readonly valueObjectTypeName?: string;
+  readonly scalarCodecId?: string;
+};
+
+export type ModelNameMapping = {
+  readonly model: PslModel;
+  readonly tableName: string;
+  readonly fieldColumns: Map<string, string>;
+};
+
+export interface CollectResolvedFieldsInput {
+  readonly model: PslModel;
+  readonly mapping: ModelNameMapping;
+  readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
+  readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
+  readonly modelNames: Set<string>;
+  readonly compositeTypeNames: ReadonlySet<string>;
+  readonly composedExtensions: Set<string>;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly defaultFunctionRegistry: ControlMutationDefaultRegistry;
+  readonly generatorDescriptorById: ReadonlyMap<string, MutationDefaultGeneratorDescriptor>;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+}
+
+const BUILTIN_FIELD_ATTRIBUTE_NAMES: ReadonlySet<string> = new Set([
+  'id',
+  'unique',
+  'default',
+  'relation',
+  'map',
+]);
+
+function validateFieldAttributes(input: {
+  readonly model: PslModel;
+  readonly field: PslField;
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly familyId: string;
+  readonly targetId: string;
+}): void {
+  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,
+    });
+    if (uncomposedNamespace) {
+      reportUncomposedNamespace({
+        subjectLabel: `Attribute "@${attribute.name}"`,
+        namespace: uncomposedNamespace,
+        sourceId: input.sourceId,
+        span: attribute.span,
+        diagnostics: input.diagnostics,
+      });
+      continue;
+    }
+
+    input.diagnostics.push({
+      code: 'PSL_UNSUPPORTED_FIELD_ATTRIBUTE',
+      message: `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+      sourceId: input.sourceId,
+      span: attribute.span,
+    });
+  }
+}
+
+function extractFieldConstraintNames(input: {
+  readonly model: PslModel;
+  readonly field: PslField;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): {
+  readonly idAttribute: PslAttribute | undefined;
+  readonly uniqueAttribute: PslAttribute | undefined;
+  readonly idName: string | undefined;
+  readonly uniqueName: string | undefined;
+} {
+  const idAttribute = getAttribute(input.field.attributes, 'id');
+  const uniqueAttribute = getAttribute(input.field.attributes, 'unique');
+  const idName = parseConstraintMapArgument({
+    attribute: idAttribute,
+    sourceId: input.sourceId,
+    diagnostics: input.diagnostics,
+    entityLabel: `Field "${input.model.name}.${input.field.name}" @id`,
+    span: input.field.span,
+    code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+  });
+  const uniqueName = parseConstraintMapArgument({
+    attribute: uniqueAttribute,
+    sourceId: input.sourceId,
+    diagnostics: input.diagnostics,
+    entityLabel: `Field "${input.model.name}.${input.field.name}" @unique`,
+    span: input.field.span,
+    code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+  });
+  return { idAttribute, uniqueAttribute, idName, uniqueName };
+}
+
+export function collectResolvedFields(input: CollectResolvedFieldsInput): ResolvedField[] {
+  const {
+    model,
+    mapping,
+    enumTypeDescriptors,
+    namedTypeDescriptors,
+    modelNames,
+    compositeTypeNames,
+    composedExtensions,
+    authoringContributions,
+    familyId,
+    targetId,
+    defaultFunctionRegistry,
+    generatorDescriptorById,
+    diagnostics,
+    sourceId,
+    scalarTypeDescriptors,
+  } = input;
+  const resolvedFields: ResolvedField[] = [];
+
+  for (const field of model.fields) {
+    if (field.list && modelNames.has(field.typeName)) {
+      continue;
+    }
+
+    validateFieldAttributes({
+      model,
+      field,
+      composedExtensions,
+      diagnostics,
+      sourceId,
+      familyId,
+      targetId,
+    });
+
+    const relationAttribute = getAttribute(field.attributes, 'relation');
+    if (relationAttribute && modelNames.has(field.typeName)) {
+      continue;
+    }
+
+    const isValueObjectField = compositeTypeNames.has(field.typeName);
+    const isListField = field.list;
+
+    let descriptor: ColumnDescriptor | undefined;
+    let scalarCodecId: string | undefined;
+    const resolveInput = {
+      field,
+      enumTypeDescriptors,
+      namedTypeDescriptors,
+      scalarTypeDescriptors,
+      authoringContributions,
+      composedExtensions,
+      familyId,
+      targetId,
+      diagnostics,
+      sourceId,
+      entityLabel: `Field "${model.name}.${field.name}"`,
+    };
+
+    if (isValueObjectField) {
+      descriptor = scalarTypeDescriptors.get('Json');
+    } else if (isListField) {
+      const resolved = resolveFieldTypeDescriptor(resolveInput);
+      if (!resolved.ok) {
+        if (!resolved.alreadyReported) {
+          diagnostics.push({
+            code: 'PSL_UNSUPPORTED_FIELD_TYPE',
+            message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
+            sourceId,
+            span: field.span,
+          });
+        }
+        continue;
+      }
+      scalarCodecId = resolved.descriptor.codecId;
+      descriptor = scalarTypeDescriptors.get('Json');
+    } else {
+      const resolved = resolveFieldTypeDescriptor(resolveInput);
+      if (!resolved.ok) {
+        if (!resolved.alreadyReported) {
+          diagnostics.push({
+            code: 'PSL_UNSUPPORTED_FIELD_TYPE',
+            message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
+            sourceId,
+            span: field.span,
+          });
+        }
+        continue;
+      }
+      descriptor = resolved.descriptor;
+    }
+
+    if (!descriptor) {
+      continue;
+    }
+
+    const defaultAttribute = getAttribute(field.attributes, 'default');
+    const loweredDefault = defaultAttribute
+      ? lowerDefaultForField({
+          modelName: model.name,
+          fieldName: field.name,
+          defaultAttribute,
+          columnDescriptor: descriptor,
+          generatorDescriptorById,
+          sourceId,
+          defaultFunctionRegistry,
+          diagnostics,
+        })
+      : {};
+    if (field.optional && loweredDefault.executionDefault) {
+      const generatorDescription =
+        loweredDefault.executionDefault.kind === 'generator'
+          ? `"${loweredDefault.executionDefault.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.`,
+        sourceId,
+        span: defaultAttribute?.span ?? field.span,
+      });
+      continue;
+    }
+    if (loweredDefault.executionDefault) {
+      const generatorDescriptor = generatorDescriptorById.get(loweredDefault.executionDefault.id);
+      const generatedDescriptor = generatorDescriptor?.resolveGeneratedColumnDescriptor?.({
+        generated: loweredDefault.executionDefault,
+      });
+      if (generatedDescriptor) {
+        descriptor = generatedDescriptor;
+      }
+    }
+    const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
+    const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
+      model,
+      field,
+      sourceId,
+      diagnostics,
+    });
+
+    resolvedFields.push({
+      field,
+      columnName: mappedColumnName,
+      descriptor,
+      ...ifDefined('defaultValue', loweredDefault.defaultValue),
+      ...ifDefined('executionDefault', loweredDefault.executionDefault),
+      isId: Boolean(idAttribute),
+      isUnique: Boolean(uniqueAttribute),
+      ...ifDefined('idName', idName),
+      ...ifDefined('uniqueName', uniqueName),
+      ...ifDefined('many', isListField ? (true as const) : undefined),
+      ...ifDefined('valueObjectTypeName', isValueObjectField ? field.typeName : undefined),
+      ...ifDefined('scalarCodecId', scalarCodecId),
+    });
+  }
+
+  return resolvedFields;
+}
+
+export function buildModelMappings(
+  models: readonly PslModel[],
+  diagnostics: ContractSourceDiagnostic[],
+  sourceId: string,
+): Map<string, ModelNameMapping> {
+  const result = new Map<string, ModelNameMapping>();
+  for (const model of models) {
+    const mapAttribute = getAttribute(model.attributes, 'map');
+    const tableName = parseMapName({
+      attribute: mapAttribute,
+      defaultValue: lowerFirst(model.name),
+      sourceId,
+      diagnostics,
+      entityLabel: `Model "${model.name}"`,
+      span: model.span,
+    });
+    const fieldColumns = new Map<string, string>();
+    for (const field of model.fields) {
+      const fieldMapAttribute = getAttribute(field.attributes, 'map');
+      const columnName = parseMapName({
+        attribute: fieldMapAttribute,
+        defaultValue: field.name,
+        sourceId,
+        diagnostics,
+        entityLabel: `Field "${model.name}.${field.name}"`,
+        span: field.span,
+      });
+      fieldColumns.set(field.name, columnName);
+    }
+    result.set(model.name, {
+      model,
+      tableName,
+      fieldColumns,
+    });
+  }
+  return result;
+}

package/src/psl-relation-resolution.ts

@@ -0,0 +1,371 @@
+import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
+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';
+import { assertDefined, invariant } from '@prisma-next/utils/assertions';
+import { ifDefined } from '@prisma-next/utils/defined';
+import {
+  getNamedArgument,
+  getPositionalArgumentEntry,
+  parseFieldList,
+  parseQuotedStringLiteral,
+  unquoteStringLiteral,
+} from './psl-attribute-parsing';
+import { checkUncomposedNamespace, reportUncomposedNamespace } from './psl-column-resolution';
+
+export const REFERENTIAL_ACTION_MAP = {
+  NoAction: 'noAction',
+  Restrict: 'restrict',
+  Cascade: 'cascade',
+  SetNull: 'setNull',
+  SetDefault: 'setDefault',
+  noAction: 'noAction',
+  restrict: 'restrict',
+  cascade: 'cascade',
+  setNull: 'setNull',
+  setDefault: 'setDefault',
+} as const;
+
+export type ParsedRelationAttribute = {
+  readonly relationName?: string;
+  readonly fields?: readonly string[];
+  readonly references?: readonly string[];
+  readonly constraintName?: string;
+  readonly onDelete?: string;
+  readonly onUpdate?: string;
+};
+
+export type FkRelationMetadata = {
+  readonly declaringModelName: string;
+  readonly declaringFieldName: string;
+  readonly declaringTableName: string;
+  readonly targetModelName: string;
+  readonly targetTableName: string;
+  readonly relationName?: string;
+  readonly localColumns: readonly string[];
+  readonly referencedColumns: readonly string[];
+};
+
+export type ModelBackrelationCandidate = {
+  readonly modelName: string;
+  readonly tableName: string;
+  readonly field: PslField;
+  readonly targetModelName: string;
+  readonly relationName?: string;
+};
+
+type ModelRelationMetadata = RelationNode;
+
+export function fkRelationPairKey(declaringModelName: string, targetModelName: string): string {
+  // NOTE: We assume PSL model identifiers do not contain the `::` separator.
+  return `${declaringModelName}::${targetModelName}`;
+}
+
+export function normalizeReferentialAction(input: {
+  readonly modelName: string;
+  readonly fieldName: string;
+  readonly actionName: 'onDelete' | 'onUpdate';
+  readonly actionToken: string;
+  readonly sourceId: string;
+  readonly span: PslSpan;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): ReferentialAction | undefined {
+  const normalized =
+    REFERENTIAL_ACTION_MAP[input.actionToken as keyof typeof REFERENTIAL_ACTION_MAP];
+  if (normalized) {
+    return normalized;
+  }
+
+  input.diagnostics.push({
+    code: 'PSL_UNSUPPORTED_REFERENTIAL_ACTION',
+    message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported ${input.actionName} action "${input.actionToken}"`,
+    sourceId: input.sourceId,
+    span: input.span,
+  });
+  return undefined;
+}
+
+export function parseRelationAttribute(input: {
+  readonly attribute: PslAttribute;
+  readonly modelName: string;
+  readonly fieldName: string;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): ParsedRelationAttribute | undefined {
+  const positionalEntries = input.attribute.args.filter((arg) => arg.kind === 'positional');
+  if (positionalEntries.length > 1) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+      message: `Relation field "${input.modelName}.${input.fieldName}" has too many positional arguments`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  let relationNameFromPositional: string | undefined;
+  const positionalNameEntry = getPositionalArgumentEntry(input.attribute);
+  if (positionalNameEntry) {
+    const parsedName = parseQuotedStringLiteral(positionalNameEntry.value);
+    if (!parsedName) {
+      input.diagnostics.push({
+        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+        message: `Relation field "${input.modelName}.${input.fieldName}" positional relation name must be a quoted string literal`,
+        sourceId: input.sourceId,
+        span: positionalNameEntry.span,
+      });
+      return undefined;
+    }
+    relationNameFromPositional = parsedName;
+  }
+
+  for (const arg of input.attribute.args) {
+    if (arg.kind === 'positional') {
+      continue;
+    }
+    if (
+      arg.name !== 'name' &&
+      arg.name !== 'fields' &&
+      arg.name !== 'references' &&
+      arg.name !== 'map' &&
+      arg.name !== 'onDelete' &&
+      arg.name !== 'onUpdate'
+    ) {
+      input.diagnostics.push({
+        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+        message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported argument "${arg.name}"`,
+        sourceId: input.sourceId,
+        span: arg.span,
+      });
+      return undefined;
+    }
+  }
+
+  const namedRelationNameRaw = getNamedArgument(input.attribute, 'name');
+  const namedRelationName = namedRelationNameRaw
+    ? parseQuotedStringLiteral(namedRelationNameRaw)
+    : undefined;
+  if (namedRelationNameRaw && !namedRelationName) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+      message: `Relation field "${input.modelName}.${input.fieldName}" named relation name must be a quoted string literal`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  if (
+    relationNameFromPositional &&
+    namedRelationName &&
+    relationNameFromPositional !== namedRelationName
+  ) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+      message: `Relation field "${input.modelName}.${input.fieldName}" has conflicting positional and named relation names`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+  const relationName = namedRelationName ?? relationNameFromPositional;
+
+  const constraintNameRaw = getNamedArgument(input.attribute, 'map');
+  const constraintName = constraintNameRaw
+    ? parseQuotedStringLiteral(constraintNameRaw)
+    : undefined;
+  if (constraintNameRaw && !constraintName) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+      message: `Relation field "${input.modelName}.${input.fieldName}" map argument must be a quoted string literal`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  const fieldsRaw = getNamedArgument(input.attribute, 'fields');
+  const referencesRaw = getNamedArgument(input.attribute, 'references');
+  if ((fieldsRaw && !referencesRaw) || (!fieldsRaw && referencesRaw)) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+      message: `Relation field "${input.modelName}.${input.fieldName}" requires fields and references arguments`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  let fields: readonly string[] | undefined;
+  let references: readonly string[] | undefined;
+  if (fieldsRaw && referencesRaw) {
+    const parsedFields = parseFieldList(fieldsRaw);
+    const parsedReferences = parseFieldList(referencesRaw);
+    if (
+      !parsedFields ||
+      !parsedReferences ||
+      parsedFields.length === 0 ||
+      parsedReferences.length === 0
+    ) {
+      input.diagnostics.push({
+        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+        message: `Relation field "${input.modelName}.${input.fieldName}" requires bracketed fields and references lists`,
+        sourceId: input.sourceId,
+        span: input.attribute.span,
+      });
+      return undefined;
+    }
+    fields = parsedFields;
+    references = parsedReferences;
+  }
+
+  const onDeleteArgument = getNamedArgument(input.attribute, 'onDelete');
+  const onUpdateArgument = getNamedArgument(input.attribute, 'onUpdate');
+
+  return {
+    ...ifDefined('relationName', relationName),
+    ...ifDefined('fields', fields),
+    ...ifDefined('references', references),
+    ...ifDefined('constraintName', constraintName),
+    ...ifDefined('onDelete', onDeleteArgument ? unquoteStringLiteral(onDeleteArgument) : undefined),
+    ...ifDefined('onUpdate', onUpdateArgument ? unquoteStringLiteral(onUpdateArgument) : undefined),
+  };
+}
+
+export function indexFkRelations(input: {
+  readonly fkRelationMetadata: readonly FkRelationMetadata[];
+}): {
+  readonly modelRelations: Map<string, ModelRelationMetadata[]>;
+  readonly fkRelationsByPair: Map<string, FkRelationMetadata[]>;
+} {
+  const modelRelations = new Map<string, ModelRelationMetadata[]>();
+  const fkRelationsByPair = new Map<string, FkRelationMetadata[]>();
+
+  for (const relation of input.fkRelationMetadata) {
+    const existing = modelRelations.get(relation.declaringModelName);
+    const current = existing ?? [];
+    if (!existing) {
+      modelRelations.set(relation.declaringModelName, current);
+    }
+    current.push({
+      fieldName: relation.declaringFieldName,
+      toModel: relation.targetModelName,
+      toTable: relation.targetTableName,
+      cardinality: 'N:1',
+      on: {
+        parentTable: relation.declaringTableName,
+        parentColumns: relation.localColumns,
+        childTable: relation.targetTableName,
+        childColumns: relation.referencedColumns,
+      },
+    });
+
+    const pairKey = fkRelationPairKey(relation.declaringModelName, relation.targetModelName);
+    const pairRelations = fkRelationsByPair.get(pairKey);
+    if (!pairRelations) {
+      fkRelationsByPair.set(pairKey, [relation]);
+      continue;
+    }
+    pairRelations.push(relation);
+  }
+
+  return { modelRelations, fkRelationsByPair };
+}
+
+export function applyBackrelationCandidates(input: {
+  readonly backrelationCandidates: readonly ModelBackrelationCandidate[];
+  readonly fkRelationsByPair: Map<string, readonly FkRelationMetadata[]>;
+  readonly modelRelations: Map<string, ModelRelationMetadata[]>;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+}): void {
+  for (const candidate of input.backrelationCandidates) {
+    const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
+    const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
+    const matches = candidate.relationName
+      ? pairMatches.filter((relation) => relation.relationName === candidate.relationName)
+      : [...pairMatches];
+
+    if (matches.length === 0) {
+      input.diagnostics.push({
+        code: 'PSL_ORPHANED_BACKRELATION_LIST',
+        message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
+        sourceId: input.sourceId,
+        span: candidate.field.span,
+      });
+      continue;
+    }
+    if (matches.length > 1) {
+      input.diagnostics.push({
+        code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
+        message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
+        sourceId: input.sourceId,
+        span: candidate.field.span,
+      });
+      continue;
+    }
+
+    invariant(matches.length === 1, 'Backrelation matching requires exactly one match');
+    const matched = matches[0];
+    assertDefined(matched, 'Backrelation matching requires a defined relation match');
+
+    const existing = input.modelRelations.get(candidate.modelName);
+    const current = existing ?? [];
+    if (!existing) {
+      input.modelRelations.set(candidate.modelName, current);
+    }
+    current.push({
+      fieldName: candidate.field.name,
+      toModel: matched.declaringModelName,
+      toTable: matched.declaringTableName,
+      cardinality: '1:N',
+      on: {
+        parentTable: candidate.tableName,
+        parentColumns: matched.referencedColumns,
+        childTable: matched.declaringTableName,
+        childColumns: matched.localColumns,
+      },
+    });
+  }
+}
+
+export function validateNavigationListFieldAttributes(input: {
+  readonly modelName: string;
+  readonly field: PslField;
+  readonly sourceId: string;
+  readonly composedExtensions: Set<string>;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly familyId: string;
+  readonly targetId: string;
+}): boolean {
+  let valid = true;
+  for (const attribute of input.field.attributes) {
+    if (attribute.name === 'relation') {
+      continue;
+    }
+
+    const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+      familyId: input.familyId,
+      targetId: input.targetId,
+    });
+    if (uncomposedNamespace) {
+      reportUncomposedNamespace({
+        subjectLabel: `Attribute "@${attribute.name}"`,
+        namespace: uncomposedNamespace,
+        sourceId: input.sourceId,
+        span: attribute.span,
+        diagnostics: input.diagnostics,
+      });
+      valid = false;
+      continue;
+    }
+    input.diagnostics.push({
+      code: 'PSL_UNSUPPORTED_FIELD_ATTRIBUTE',
+      message: `Field "${input.modelName}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+      sourceId: input.sourceId,
+      span: attribute.span,
+    });
+    valid = false;
+  }
+  return valid;
+}