@prisma-next/sql-contract-psl 0.3.0-dev.128 → 0.3.0-dev.147

package/src/psl-field-resolution.ts

@@ -0,0 +1,312 @@
+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 { instantiateAuthoringTypeConstructor } from '@prisma-next/framework-components/authoring';
+import type { 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 {
+  getAuthoringTypeConstructor,
+  lowerDefaultForField,
+  parsePgvectorLength,
+  resolveColumnDescriptor,
+} 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 function collectResolvedFields(
+  model: PslModel,
+  mapping: ModelNameMapping,
+  enumTypeDescriptors: Map<string, ColumnDescriptor>,
+  namedTypeDescriptors: Map<string, ColumnDescriptor>,
+  namedTypeBaseTypes: Map<string, string>,
+  modelNames: Set<string>,
+  compositeTypeNames: ReadonlySet<string>,
+  composedExtensions: Set<string>,
+  authoringContributions: AuthoringContributions | undefined,
+  defaultFunctionRegistry: ControlMutationDefaultRegistry,
+  generatorDescriptorById: ReadonlyMap<string, MutationDefaultGeneratorDescriptor>,
+  diagnostics: ContractSourceDiagnostic[],
+  sourceId: string,
+  scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
+): ResolvedField[] {
+  const resolvedFields: ResolvedField[] = [];
+  const pgvectorVectorConstructor = getAuthoringTypeConstructor(authoringContributions, [
+    'pgvector',
+    'vector',
+  ]);
+
+  for (const field of model.fields) {
+    if (field.list && modelNames.has(field.typeName)) {
+      continue;
+    }
+
+    for (const attribute of field.attributes) {
+      if (
+        attribute.name === 'id' ||
+        attribute.name === 'unique' ||
+        attribute.name === 'default' ||
+        attribute.name === 'relation' ||
+        attribute.name === 'map' ||
+        attribute.name === 'pgvector.column'
+      ) {
+        continue;
+      }
+      if (attribute.name.startsWith('pgvector.') && !composedExtensions.has('pgvector')) {
+        diagnostics.push({
+          code: 'PSL_EXTENSION_NAMESPACE_NOT_COMPOSED',
+          message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+          sourceId,
+          span: attribute.span,
+        });
+        continue;
+      }
+      diagnostics.push({
+        code: 'PSL_UNSUPPORTED_FIELD_ATTRIBUTE',
+        message: `Field "${model.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`,
+        sourceId,
+        span: attribute.span,
+      });
+    }
+
+    const relationAttribute = getAttribute(field.attributes, 'relation');
+    if (relationAttribute && modelNames.has(field.typeName)) {
+      continue;
+    }
+
+    const isValueObjectField = compositeTypeNames.has(field.typeName);
+    const isListField = field.list;
+
+    const pgvectorOnJsonField = getAttribute(field.attributes, 'pgvector.column');
+    if (pgvectorOnJsonField && (isValueObjectField || isListField)) {
+      diagnostics.push({
+        code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+        message: `Field "${model.name}.${field.name}" uses @pgvector.column on a JSON-backed field (${isValueObjectField ? 'value object' : 'list'}). @pgvector.column is only supported on scalar Bytes fields.`,
+        sourceId,
+        span: pgvectorOnJsonField.span,
+      });
+      continue;
+    }
+
+    let descriptor: ColumnDescriptor | undefined;
+    let scalarCodecId: string | undefined;
+
+    if (isValueObjectField) {
+      descriptor = scalarTypeDescriptors.get('Json');
+    } else if (isListField) {
+      const originalDescriptor = resolveColumnDescriptor(
+        field,
+        enumTypeDescriptors,
+        namedTypeDescriptors,
+        scalarTypeDescriptors,
+      );
+      if (!originalDescriptor) {
+        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 = originalDescriptor.codecId;
+      descriptor = scalarTypeDescriptors.get('Json');
+    } else {
+      descriptor = resolveColumnDescriptor(
+        field,
+        enumTypeDescriptors,
+        namedTypeDescriptors,
+        scalarTypeDescriptors,
+      );
+
+      const pgvectorColumnAttribute = getAttribute(field.attributes, 'pgvector.column');
+      if (pgvectorColumnAttribute) {
+        if (!composedExtensions.has('pgvector')) {
+          diagnostics.push({
+            code: 'PSL_EXTENSION_NAMESPACE_NOT_COMPOSED',
+            message:
+              'Attribute "@pgvector.column" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.',
+            sourceId,
+            span: pgvectorColumnAttribute.span,
+          });
+        } else {
+          const isBytesBase =
+            field.typeName === 'Bytes' ||
+            namedTypeBaseTypes.get(field.typeRef ?? field.typeName) === 'Bytes';
+          if (!isBytesBase) {
+            diagnostics.push({
+              code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+              message: `Field "${model.name}.${field.name}" uses @pgvector.column on unsupported base type "${field.typeName}"`,
+              sourceId,
+              span: pgvectorColumnAttribute.span,
+            });
+          } else {
+            const length = parsePgvectorLength({
+              attribute: pgvectorColumnAttribute,
+              diagnostics,
+              sourceId,
+            });
+            if (length !== undefined) {
+              descriptor = pgvectorVectorConstructor
+                ? instantiateAuthoringTypeConstructor(pgvectorVectorConstructor, [length])
+                : {
+                    codecId: 'pg/vector@1',
+                    nativeType: 'vector',
+                    typeParams: { length },
+                  };
+            }
+          }
+        }
+      }
+    }
+
+    if (!descriptor) {
+      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;
+    }
+
+    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 = getAttribute(field.attributes, 'id');
+    const uniqueAttribute = getAttribute(field.attributes, 'unique');
+    const idName = parseConstraintMapArgument({
+      attribute: idAttribute,
+      sourceId,
+      diagnostics,
+      entityLabel: `Field "${model.name}.${field.name}" @id`,
+      span: field.span,
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+    });
+    const uniqueName = parseConstraintMapArgument({
+      attribute: uniqueAttribute,
+      sourceId,
+      diagnostics,
+      entityLabel: `Field "${model.name}.${field.name}" @unique`,
+      span: field.span,
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+    });
+
+    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,362 @@
+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';
+
+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[];
+}): boolean {
+  let valid = true;
+  for (const attribute of input.field.attributes) {
+    if (attribute.name === 'relation') {
+      continue;
+    }
+    if (attribute.name.startsWith('pgvector.') && !input.composedExtensions.has('pgvector')) {
+      input.diagnostics.push({
+        code: 'PSL_EXTENSION_NAMESPACE_NOT_COMPOSED',
+        message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+        sourceId: input.sourceId,
+        span: attribute.span,
+      });
+      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;
+}