@prisma-next/sql-contract-psl 0.3.0-dev.146 → 0.3.0-dev.162

package/src/psl-column-resolution.ts

@@ -4,8 +4,17 @@ import type {
   AuthoringContributions,
   AuthoringTypeConstructorDescriptor,
 } from '@prisma-next/framework-components/authoring';
-import { isAuthoringTypeConstructorDescriptor } from '@prisma-next/framework-components/authoring';
-import type { PslAttribute, PslField } from '@prisma-next/psl-parser';
+import {
+  instantiateAuthoringTypeConstructor,
+  isAuthoringTypeConstructorDescriptor,
+  validateAuthoringHelperArguments,
+} from '@prisma-next/framework-components/authoring';
+import type {
+  PslAttribute,
+  PslField,
+  PslSpan,
+  PslTypeConstructorCall,
+} from '@prisma-next/psl-parser';
 import type {
   ControlMutationDefaultRegistry,
   MutationDefaultGeneratorDescriptor,
@@ -15,8 +24,6 @@ import {
   parseDefaultFunctionCall,
 } from './default-function-registry';
 import {
-  getNamedArgument,
-  getPositionalArgument,
   getPositionalArgumentEntry,
   getPositionalArguments,
   parseOptionalNumericArguments,
@@ -24,6 +31,7 @@ import {
   pushInvalidAttributeArgument,
   unquoteStringLiteral,
 } from './psl-attribute-parsing';
+import { mapPslHelperArgs } from './psl-authoring-arguments';
 
 export type ColumnDescriptor = {
   readonly codecId: string;
@@ -59,6 +67,225 @@ export function getAuthoringTypeConstructor(
   return isAuthoringTypeConstructorDescriptor(current) ? current : undefined;
 }
 
+/**
+ * Returns the namespace prefix of `attributeName` if it references an
+ * unrecognized extension namespace, otherwise `undefined`. A namespace is
+ * considered recognized when it is:
+ *
+ * - `db` (native-type spec, always allowed),
+ * - the active family id (e.g. `sql`),
+ * - the active target id (e.g. `postgres`),
+ * - 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).
+ */
+export function checkUncomposedNamespace(
+  attributeName: string,
+  composedExtensions: ReadonlySet<string>,
+  context?: { readonly familyId?: string; readonly targetId?: string },
+): string | undefined {
+  const dotIndex = attributeName.indexOf('.');
+  if (dotIndex <= 0 || dotIndex === attributeName.length - 1) {
+    return undefined;
+  }
+  const namespace = attributeName.slice(0, dotIndex);
+  if (
+    namespace === 'db' ||
+    namespace === context?.familyId ||
+    namespace === context?.targetId ||
+    composedExtensions.has(namespace)
+  ) {
+    return undefined;
+  }
+  return namespace;
+}
+
+/**
+ * Pushes the canonical `PSL_EXTENSION_NAMESPACE_NOT_COMPOSED` diagnostic for a
+ * subject (attribute, model attribute, or type constructor) that references an
+ * extension namespace which is not composed in the current contract.
+ *
+ * The `data` payload carries the missing namespace so machine consumers
+ * (agents, IDE extensions, CLI auto-fix) don't have to parse the prose.
+ */
+export function reportUncomposedNamespace(input: {
+  readonly subjectLabel: string;
+  readonly namespace: string;
+  readonly sourceId: string;
+  readonly span: PslSpan;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): void {
+  input.diagnostics.push({
+    code: 'PSL_EXTENSION_NAMESPACE_NOT_COMPOSED',
+    message: `${input.subjectLabel} uses unrecognized namespace "${input.namespace}". Add extension pack "${input.namespace}" to extensionPacks in prisma-next.config.ts.`,
+    sourceId: input.sourceId,
+    span: input.span,
+    data: { namespace: input.namespace, suggestedPack: input.namespace },
+  });
+}
+
+export function instantiatePslTypeConstructor(input: {
+  readonly call: PslTypeConstructorCall;
+  readonly descriptor: AuthoringTypeConstructorDescriptor;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly entityLabel: string;
+}):
+  | {
+      readonly codecId: string;
+      readonly nativeType: string;
+      readonly typeParams?: Record<string, unknown>;
+    }
+  | undefined {
+  const helperPath = input.call.path.join('.');
+  const args = mapPslHelperArgs({
+    args: input.call.args,
+    descriptors: input.descriptor.args ?? [],
+    helperLabel: `constructor "${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);
+    return instantiateAuthoringTypeConstructor(input.descriptor, args);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    input.diagnostics.push({
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message: `${input.entityLabel} constructor "${helperPath}" ${message}`,
+      sourceId: input.sourceId,
+      span: input.call.span,
+    });
+    return undefined;
+  }
+}
+
+function pushUnsupportedTypeConstructorDiagnostic(input: {
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly span: PslSpan;
+  readonly code: 'PSL_UNSUPPORTED_FIELD_TYPE' | 'PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR';
+  readonly message: string;
+}): undefined {
+  input.diagnostics.push({
+    code: input.code,
+    message: input.message,
+    sourceId: input.sourceId,
+    span: input.span,
+  });
+  return undefined;
+}
+
+export function resolvePslTypeConstructorDescriptor(input: {
+  readonly call: PslTypeConstructorCall;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly unsupportedCode: 'PSL_UNSUPPORTED_FIELD_TYPE' | 'PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR';
+  readonly unsupportedMessage: string;
+}): AuthoringTypeConstructorDescriptor | undefined {
+  const descriptor = getAuthoringTypeConstructor(input.authoringContributions, input.call.path);
+  if (descriptor) {
+    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)
+  ) {
+    reportUncomposedNamespace({
+      subjectLabel: `Type constructor "${input.call.path.join('.')}"`,
+      namespace,
+      sourceId: input.sourceId,
+      span: input.call.span,
+      diagnostics: input.diagnostics,
+    });
+    return undefined;
+  }
+
+  return pushUnsupportedTypeConstructorDiagnostic({
+    diagnostics: input.diagnostics,
+    sourceId: input.sourceId,
+    span: input.call.span,
+    code: input.unsupportedCode,
+    message: input.unsupportedMessage,
+  });
+}
+
+export type ResolveFieldTypeResult =
+  | { readonly ok: true; readonly descriptor: ColumnDescriptor }
+  | { readonly ok: false; readonly alreadyReported: boolean };
+
+export function resolveFieldTypeDescriptor(input: {
+  readonly field: PslField;
+  readonly enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly entityLabel: string;
+}): ResolveFieldTypeResult {
+  if (input.field.typeConstructor) {
+    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`,
+    });
+    if (!descriptor) {
+      return { ok: false, alreadyReported: true };
+    }
+
+    const instantiated = instantiatePslTypeConstructor({
+      call: input.field.typeConstructor,
+      descriptor,
+      diagnostics: input.diagnostics,
+      sourceId: input.sourceId,
+      entityLabel: input.entityLabel,
+    });
+    if (!instantiated) {
+      return { ok: false, alreadyReported: true };
+    }
+    return { ok: true, descriptor: instantiated };
+  }
+
+  const descriptor = resolveColumnDescriptor(
+    input.field,
+    input.enumTypeDescriptors,
+    input.namedTypeDescriptors,
+    input.scalarTypeDescriptors,
+  );
+  if (!descriptor) {
+    return { ok: false, alreadyReported: false };
+  }
+  return { ok: true, descriptor };
+}
+
 /**
  * Declarative specification for @db.* native type attributes.
  *
@@ -242,37 +469,6 @@ export function resolveDbNativeTypeAttribute(input: {
   }
 }
 
-export function parsePgvectorLength(input: {
-  readonly attribute: PslAttribute;
-  readonly diagnostics: ContractSourceDiagnostic[];
-  readonly sourceId: string;
-}): number | undefined {
-  const namedLength = getNamedArgument(input.attribute, 'length');
-  const namedDim = getNamedArgument(input.attribute, 'dim');
-  const positional = getPositionalArgument(input.attribute);
-  const raw = namedLength ?? namedDim ?? positional;
-  if (!raw) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-      message: '@pgvector.column requires length/dim argument',
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return undefined;
-  }
-  const parsed = Number(unquoteStringLiteral(raw));
-  if (!Number.isInteger(parsed) || parsed < 1) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-      message: '@pgvector.column length/dim must be a positive integer',
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return undefined;
-  }
-  return parsed;
-}
-
 export function parseDefaultLiteralValue(expression: string): ColumnDefault | undefined {
   const trimmed = expression.trim();
   if (trimmed === 'true' || trimmed === 'false') {
@@ -387,8 +583,8 @@ export function lowerDefaultForField(input: {
 
 export function resolveColumnDescriptor(
   field: PslField,
-  enumTypeDescriptors: Map<string, ColumnDescriptor>,
-  namedTypeDescriptors: Map<string, ColumnDescriptor>,
+  enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
+  namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
   scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
 ): ColumnDescriptor | undefined {
   if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) {

package/src/psl-field-resolution.ts

@@ -1,8 +1,7 @@
 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 type { PslAttribute, PslField, PslModel } from '@prisma-next/psl-parser';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type {
   ControlMutationDefaultRegistry,
@@ -16,10 +15,10 @@ import {
 } from './psl-attribute-parsing';
 import type { ColumnDescriptor } from './psl-column-resolution';
 import {
-  getAuthoringTypeConstructor,
+  checkUncomposedNamespace,
   lowerDefaultForField,
-  parsePgvectorLength,
-  resolveColumnDescriptor,
+  reportUncomposedNamespace,
+  resolveFieldTypeDescriptor,
 } from './psl-column-resolution';
 
 export type ResolvedField = {
@@ -43,61 +42,137 @@ export type ModelNameMapping = {
   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',
-  ]);
+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>;
+}
 
-  for (const field of model.fields) {
-    if (field.list && modelNames.has(field.typeName)) {
+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;
     }
 
-    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,
+    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;
@@ -106,96 +181,56 @@ export function collectResolvedFields(
     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;
+    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 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,
-        });
+      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 = originalDescriptor.codecId;
+      scalarCodecId = resolved.descriptor.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')) {
+      const resolved = resolveFieldTypeDescriptor(resolveInput);
+      if (!resolved.ok) {
+        if (!resolved.alreadyReported) {
           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.',
+            code: 'PSL_UNSUPPORTED_FIELD_TYPE',
+            message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
             sourceId,
-            span: pgvectorColumnAttribute.span,
+            span: field.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 },
-                  };
-            }
-          }
         }
+        continue;
       }
+      descriptor = resolved.descriptor;
     }
 
     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;
     }
 
@@ -235,23 +270,11 @@ export function collectResolvedFields(
       }
     }
     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,
+    const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
+      model,
+      field,
       sourceId,
       diagnostics,
-      entityLabel: `Field "${model.name}.${field.name}" @unique`,
-      span: field.span,
-      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
     });
 
     resolvedFields.push({