@prisma-next/mongo-contract-psl 0.13.0 → 0.14.0-dev.10

package/src/interpreter.ts

@@ -16,19 +16,25 @@ import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   applyPolymorphicScopeToMongoIndex,
   buildMongoNamespace,
-  MongoCollection,
+  type MongoCollectionInput,
   MongoIndex,
   type MongoIndexKeyDirection,
   MongoStorage,
 } from '@prisma-next/mongo-contract';
 import { mongoContractCanonicalizationHooks } from '@prisma-next/mongo-contract/canonicalization-hooks';
+import type { CollationOptions } from '@prisma-next/mongo-value/mongodb-types';
 import type {
-  ParsePslDocumentResult,
-  PslField,
-  PslModel,
-  PslNamespace,
+  CompositeTypeSymbol,
+  FieldSymbol,
+  ModelSymbol,
+  NamespaceSymbol,
   PslSpan,
+  ResolvedAttribute,
+  SymbolTable,
 } from '@prisma-next/psl-parser';
+import { nodePslSpan } from '@prisma-next/psl-parser';
+import type { SourceFile } from '@prisma-next/psl-parser/syntax';
+import { blindCast } from '@prisma-next/utils/casts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { deriveJsonSchema, derivePolymorphicJsonSchema } from './derive-json-schema';
 import {
@@ -43,41 +49,30 @@ import {
 } from './psl-helpers';
 
 export interface InterpretPslDocumentToMongoContractInput {
-  readonly document: ParsePslDocumentResult;
+  readonly symbolTable: SymbolTable;
+  readonly sourceFile: SourceFile;
+  readonly sourceId: string;
   readonly scalarTypeDescriptors: ReadonlyMap<string, string>;
   readonly codecLookup?: CodecLookup;
+  readonly seedDiagnostics?: readonly ContractSourceDiagnostic[];
 }
 
 /**
- * Name of the framework-parser synthesised bucket for top-level
- * declarations. Re-declared locally so the interpreter does not have to
- * import from `@prisma-next/framework-components/psl-ast`.
- */
-const UNSPECIFIED_PSL_NAMESPACE_NAME = '__unspecified__';
-
-/**
- * Mongo FR16c validation: Mongo's authoring DSL exposes the connection's
- * database as the only namespace surface today, so the PSL interpreter
- * rejects every explicit `namespace { … }` block. The implicit
- * `__unspecified__` bucket (top-level declarations) is the only
- * namespace Mongo accepts. `namespace unbound { … }` is rejected too —
- * Mongo has no late-binding namespace concept on the PSL surface (the
- * database name comes from the connection string, not from PSL).
+ * Mongo's PSL surface binds the database from the connection string, so every
+ * explicit namespace block is invalid, including `namespace unbound { … }`.
  */
 function validateNamespaceBlocksForMongoTarget(input: {
-  readonly namespaces: readonly PslNamespace[];
+  readonly namespaces: readonly NamespaceSymbol[];
   readonly sourceId: string;
+  readonly sourceFile: SourceFile;
   readonly diagnostics: ContractSourceDiagnostic[];
 }): void {
   for (const namespace of input.namespaces) {
-    if (namespace.name === UNSPECIFIED_PSL_NAMESPACE_NAME) {
-      continue;
-    }
     input.diagnostics.push({
       code: 'PSL_UNSUPPORTED_NAMESPACE_BLOCK',
       message: `Mongo does not support \`namespace ${namespace.name} { … }\` blocks (the database is bound by the connection string; declare models at the document top level instead).`,
       sourceId: input.sourceId,
-      span: namespace.span,
+      span: nodePslSpan(namespace.node.syntax, input.sourceFile),
     });
   }
 }
@@ -99,16 +94,16 @@ function fkRelationPairKey(declaringModel: string, targetModel: string): string
   return `${declaringModel}::${targetModel}`;
 }
 
-function resolveFieldMappings(model: PslModel): FieldMappings {
+function resolveFieldMappings(model: ModelSymbol): FieldMappings {
   const pslNameToMapped = new Map<string, string>();
-  for (const field of model.fields) {
+  for (const field of Object.values(model.fields)) {
     const mapped = getMapName(field.attributes) ?? field.name;
     pslNameToMapped.set(field.name, mapped);
   }
   return { pslNameToMapped };
 }
 
-function resolveCollectionName(model: PslModel): string {
+function resolveCollectionName(model: ModelSymbol): string {
   return getMapName(model.attributes) ?? lowerFirst(model.name);
 }
 
@@ -121,12 +116,12 @@ interface MongoModelEntry {
   readonly base?: CrossReference;
 }
 
-type DiscriminatorDeclaration = { readonly fieldName: string; readonly span: PslModel['span'] };
+type DiscriminatorDeclaration = { readonly fieldName: string; readonly span: PslSpan };
 type BaseDeclaration = {
   readonly baseName: string;
   readonly value: string;
   readonly collectionName: string;
-  readonly span: PslModel['span'];
+  readonly span: PslSpan;
 };
 
 function mongoCrossRef(modelName: string): CrossReference {
@@ -134,7 +129,7 @@ function mongoCrossRef(modelName: string): CrossReference {
 }
 
 function collectPolymorphismDeclarations(
-  document: ParsePslDocumentResult,
+  models: readonly ModelSymbol[],
   sourceId: string,
   diagnostics: ContractSourceDiagnostic[],
 ): {
@@ -143,32 +138,31 @@ function collectPolymorphismDeclarations(
 } {
   const discriminatorDeclarations = new Map<string, DiscriminatorDeclaration>();
   const baseDeclarations = new Map<string, BaseDeclaration>();
-  const allPslModels = document.ast.namespaces.flatMap((ns) => ns.models);
 
-  for (const pslModel of allPslModels) {
-    for (const attr of pslModel.attributes) {
+  for (const model of models) {
+    for (const attr of model.attributes) {
       if (attr.name === 'discriminator') {
         const fieldName = getPositionalArgument(attr);
         if (!fieldName) {
           diagnostics.push({
             code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-            message: `Model "${pslModel.name}" @@discriminator requires a field name argument`,
+            message: `Model "${model.name}" @@discriminator requires a field name argument`,
             sourceId,
             span: attr.span,
           });
           continue;
         }
-        const discField = pslModel.fields.find((f) => f.name === fieldName);
+        const discField = model.fields[fieldName];
         if (discField && discField.typeName !== 'String') {
           diagnostics.push({
             code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-            message: `Discriminator field "${fieldName}" on model "${pslModel.name}" must be of type String, but is "${discField.typeName}"`,
+            message: `Discriminator field "${fieldName}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
             sourceId,
             span: attr.span,
           });
           continue;
         }
-        discriminatorDeclarations.set(pslModel.name, { fieldName, span: attr.span });
+        discriminatorDeclarations.set(model.name, { fieldName, span: attr.span });
       }
       if (attr.name === 'base') {
         const baseName = getPositionalArgument(attr, 0);
@@ -176,7 +170,7 @@ function collectPolymorphismDeclarations(
         if (!baseName || !rawValue) {
           diagnostics.push({
             code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-            message: `Model "${pslModel.name}" @@base requires two arguments: base model name and discriminator value`,
+            message: `Model "${model.name}" @@base requires two arguments: base model name and discriminator value`,
             sourceId,
             span: attr.span,
           });
@@ -186,14 +180,14 @@ function collectPolymorphismDeclarations(
         if (value === undefined) {
           diagnostics.push({
             code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-            message: `Model "${pslModel.name}" @@base discriminator value must be a quoted string literal`,
+            message: `Model "${model.name}" @@base discriminator value must be a quoted string literal`,
             sourceId,
             span: attr.span,
           });
           continue;
         }
-        const collectionName = resolveCollectionName(pslModel);
-        baseDeclarations.set(pslModel.name, { baseName, value, collectionName, span: attr.span });
+        const collectionName = resolveCollectionName(model);
+        baseDeclarations.set(model.name, { baseName, value, collectionName, span: attr.span });
       }
     }
   }
@@ -205,7 +199,7 @@ function resolvePolymorphism(input: {
   models: Record<string, MongoModelEntry>;
   roots: Record<string, CrossReference>;
   collections: Record<string, Record<string, unknown>>;
-  document: ParsePslDocumentResult;
+  allModels: readonly ModelSymbol[];
   discriminatorDeclarations: Map<string, DiscriminatorDeclaration>;
   baseDeclarations: Map<string, BaseDeclaration>;
   modelNames: ReadonlySet<string>;
@@ -223,11 +217,10 @@ function resolvePolymorphism(input: {
     baseDeclarations,
     modelNames,
     sourceId,
-    document,
+    allModels: allModelViews,
     indexSpans,
     modelIndexesByName,
   } = input;
-  const allPslModels = document.ast.namespaces.flatMap((ns) => ns.models);
   let patched = input.models;
   let roots = input.roots;
   let collections = input.collections;
@@ -247,9 +240,9 @@ function resolvePolymorphism(input: {
     const model = patched[modelName];
     if (!model) continue;
 
-    const pslModel = allPslModels.find((m) => m.name === modelName);
-    const mappedDiscriminatorField = pslModel
-      ? (resolveFieldMappings(pslModel).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName)
+    const modelView = allModelViews.find((m) => m.name === modelName);
+    const mappedDiscriminatorField = modelView
+      ? (resolveFieldMappings(modelView).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName)
       : decl.fieldName;
 
     if (!Object.hasOwn(model.fields, mappedDiscriminatorField)) {
@@ -310,9 +303,9 @@ function resolvePolymorphism(input: {
     }
 
     const baseModel = patched[baseDecl.baseName];
-    const variantPslModel = allPslModels.find((m) => m.name === variantName);
-    if (!variantPslModel) continue;
-    const hasExplicitMap = getMapName(variantPslModel.attributes) !== undefined;
+    const variantModelView = allModelViews.find((m) => m.name === variantName);
+    if (!variantModelView) continue;
+    const hasExplicitMap = getMapName(variantModelView.attributes) !== undefined;
 
     if (hasExplicitMap && baseModel && baseDecl.collectionName !== baseModel.storage.collection) {
       diagnostics.push({
@@ -337,7 +330,7 @@ function resolvePolymorphism(input: {
       };
     }
 
-    const variantCollectionName = resolveCollectionName(variantPslModel);
+    const variantCollectionName = resolveCollectionName(variantModelView);
     if (roots[variantCollectionName]?.model === variantName) {
       if (variantCollectionName === baseCollection && baseModel) {
         roots = { ...roots, [variantCollectionName]: mongoCrossRef(baseDecl.baseName) };
@@ -481,9 +474,7 @@ function parseJsonArg(raw: string | undefined): Record<string, unknown> | undefi
   return undefined;
 }
 
-function parseCollation(
-  attr: import('@prisma-next/psl-parser').PslAttribute,
-): Record<string, unknown> | null | undefined {
+function parseCollation(attr: ResolvedAttribute): CollationOptions | null | undefined {
   const locale = stripQuotesHelper(getNamedArgument(attr, 'collationLocale'));
   if (!locale) {
     const hasAnyCollationArg =
@@ -498,23 +489,23 @@ function parseCollation(
     return hasAnyCollationArg ? null : undefined;
   }
 
-  const collation: Record<string, unknown> = { locale };
+  const collation: CollationOptions = { locale };
   const strength = parseNumericArg(getNamedArgument(attr, 'collationStrength'));
-  if (strength != null) collation['strength'] = strength;
+  if (strength != null) collation.strength = strength;
   const caseLevel = parseBooleanArg(getNamedArgument(attr, 'collationCaseLevel'));
-  if (caseLevel != null) collation['caseLevel'] = caseLevel;
+  if (caseLevel != null) collation.caseLevel = caseLevel;
   const caseFirst = stripQuotesHelper(getNamedArgument(attr, 'collationCaseFirst'));
-  if (caseFirst != null) collation['caseFirst'] = caseFirst;
+  if (caseFirst != null) collation.caseFirst = caseFirst;
   const numericOrdering = parseBooleanArg(getNamedArgument(attr, 'collationNumericOrdering'));
-  if (numericOrdering != null) collation['numericOrdering'] = numericOrdering;
+  if (numericOrdering != null) collation.numericOrdering = numericOrdering;
   const alternate = stripQuotesHelper(getNamedArgument(attr, 'collationAlternate'));
-  if (alternate != null) collation['alternate'] = alternate;
+  if (alternate != null) collation.alternate = alternate;
   const maxVariable = stripQuotesHelper(getNamedArgument(attr, 'collationMaxVariable'));
-  if (maxVariable != null) collation['maxVariable'] = maxVariable;
+  if (maxVariable != null) collation.maxVariable = maxVariable;
   const backwards = parseBooleanArg(getNamedArgument(attr, 'collationBackwards'));
-  if (backwards != null) collation['backwards'] = backwards;
+  if (backwards != null) collation.backwards = backwards;
   const normalization = parseBooleanArg(getNamedArgument(attr, 'collationNormalization'));
-  if (normalization != null) collation['normalization'] = normalization;
+  if (normalization != null) collation.normalization = normalization;
   return collation;
 }
 
@@ -543,7 +534,7 @@ function parseProjectionList(
 }
 
 function collectIndexes(
-  pslModel: PslModel,
+  pslModel: ModelSymbol,
   fieldMappings: FieldMappings,
   modelNames: ReadonlySet<string>,
   sourceId: string,
@@ -559,12 +550,12 @@ function collectIndexes(
   // rather than fieldMappings.pslNameToMapped because the latter contains
   // every PSL field including relation fields.
   const indexableFieldNames = new Set<string>();
-  for (const f of pslModel.fields) {
+  for (const f of Object.values(pslModel.fields)) {
     if (modelNames.has(f.typeName)) continue;
     indexableFieldNames.add(f.name);
   }
 
-  for (const field of pslModel.fields) {
+  for (const field of Object.values(pslModel.fields)) {
     if (modelNames.has(field.typeName)) continue;
     const uniqueAttr = getAttribute(field.attributes, 'unique');
     if (!uniqueAttr) continue;
@@ -798,7 +789,7 @@ function collectIndexes(
   return indexes;
 }
 
-function isRelationField(field: PslField, modelNames: ReadonlySet<string>): boolean {
+function isRelationField(field: FieldSymbol, modelNames: ReadonlySet<string>): boolean {
   return modelNames.has(field.typeName);
 }
 
@@ -806,14 +797,14 @@ function isRelationField(field: PslField, modelNames: ReadonlySet<string>): bool
 const MONGO_OBJECT_ID_PSL_TYPE = 'ObjectId';
 
 function resolveFieldCodecId(
-  field: PslField,
+  field: FieldSymbol,
   scalarTypeDescriptors: ReadonlyMap<string, string>,
 ): string | undefined {
   return scalarTypeDescriptors.get(field.typeName);
 }
 
 function resolveNonRelationField(
-  field: PslField,
+  field: FieldSymbol,
   ownerName: string,
   compositeTypeNames: ReadonlySet<string>,
   scalarTypeDescriptors: ReadonlyMap<string, string>,
@@ -828,6 +819,11 @@ function resolveNonRelationField(
     return field.list ? { ...result, many: true } : result;
   }
 
+  // Avoid cascading unsupported-type diagnostics after invalid qualification.
+  if (field.malformedType) {
+    return undefined;
+  }
+
   const codecId = resolveFieldCodecId(field, scalarTypeDescriptors);
   if (!codecId) {
     diagnostics.push({
@@ -849,21 +845,18 @@ function resolveNonRelationField(
 export function interpretPslDocumentToMongoContract(
   input: InterpretPslDocumentToMongoContractInput,
 ): Result<Contract, ContractSourceDiagnostics> {
-  const { document, scalarTypeDescriptors, codecLookup } = input;
-  const sourceId = document.ast.sourceId;
-  const diagnostics: ContractSourceDiagnostic[] = [];
+  const { symbolTable, sourceFile, scalarTypeDescriptors, codecLookup } = input;
+  const sourceId = input.sourceId;
+  const diagnostics: ContractSourceDiagnostic[] = [...(input.seedDiagnostics ?? [])];
+  const topLevel = symbolTable.topLevel;
   validateNamespaceBlocksForMongoTarget({
-    namespaces: document.ast.namespaces,
+    namespaces: Object.values(topLevel.namespaces),
     sourceId,
+    sourceFile,
     diagnostics,
   });
-  // Mongo lowers only the implicit `__unspecified__` bucket today —
-  // explicit `namespace { … }` blocks were rejected above. The IR
-  // collection map remains flat (and the Mongo target represents
-  // databases via `MongoTargetDatabase`, populated at compose time by
-  // the connection string rather than authoring-time PSL).
-  const allModels = document.ast.namespaces.flatMap((ns) => ns.models);
-  const allCompositeTypes = document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
+  const allModels: ModelSymbol[] = Object.values(topLevel.models);
+  const allCompositeTypes: CompositeTypeSymbol[] = Object.values(topLevel.compositeTypes);
   const modelNames = new Set(allModels.map((m) => m.name));
   const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
 
@@ -880,7 +873,7 @@ export function interpretPslDocumentToMongoContract(
     readonly targetModelName: string;
     readonly relationName?: string;
     readonly cardinality: '1:1' | '1:N';
-    readonly field: PslField;
+    readonly field: FieldSymbol;
   }
   const backrelationCandidates: BackrelationCandidate[] = [];
 
@@ -891,7 +884,7 @@ export function interpretPslDocumentToMongoContract(
     const fields: Record<string, ContractField> = {};
     const relations: Record<string, ContractReferenceRelation> = {};
 
-    for (const field of pslModel.fields) {
+    for (const field of Object.values(pslModel.fields)) {
       if (isRelationField(field, modelNames)) {
         const relation = parseRelationAttribute(field.attributes);
 
@@ -954,7 +947,9 @@ export function interpretPslDocumentToMongoContract(
     }
 
     const isVariantModel = pslModel.attributes.some((attr) => attr.name === 'base');
-    const hasIdField = pslModel.fields.some((f) => getAttribute(f.attributes, 'id') !== undefined);
+    const hasIdField = Object.values(pslModel.fields).some(
+      (f) => getAttribute(f.attributes, 'id') !== undefined,
+    );
     // Variant models inherit the base's identity and are validated through their base.
     if (!isVariantModel) {
       if (!hasIdField) {
@@ -1009,7 +1004,7 @@ export function interpretPslDocumentToMongoContract(
   const valueObjects: Record<string, ContractValueObject> = {};
   for (const compositeType of allCompositeTypes) {
     const fields: Record<string, ContractField> = {};
-    for (const field of compositeType.fields) {
+    for (const field of Object.values(compositeType.fields)) {
       const resolved = resolveNonRelationField(
         field,
         compositeType.name,
@@ -1076,7 +1071,7 @@ export function interpretPslDocumentToMongoContract(
   }
 
   const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(
-    document,
+    allModels,
     sourceId,
     diagnostics,
   );
@@ -1084,7 +1079,7 @@ export function interpretPslDocumentToMongoContract(
     models,
     roots,
     collections,
-    document,
+    allModels,
     discriminatorDeclarations,
     baseDeclarations,
     modelNames,
@@ -1131,34 +1126,29 @@ export function interpretPslDocumentToMongoContract(
 
   const target = 'mongo';
   const targetFamily = 'mongo';
-  const collectionsAsClasses: Record<string, MongoCollection> = {};
+  const collectionInputs: Record<string, MongoCollectionInput> = {};
   for (const [name, coll] of Object.entries(resolvedCollections)) {
-    const input: {
-      indexes?: ReadonlyArray<MongoIndex>;
-      validator?: unknown;
-      options?: unknown;
-    } = {};
-    if (coll['indexes'] !== undefined) {
-      input.indexes = coll['indexes'] as ReadonlyArray<MongoIndex>;
-    }
-    if (coll['validator'] !== undefined) {
-      input.validator = coll['validator'];
-    }
-    if (coll['options'] !== undefined) {
-      input.options = coll['options'];
-    }
-    // input.validator/options are arktype-validated JSON shapes; MongoCollection
-    // constructor normalises them into MongoValidator / MongoCollectionOptions
-    // instances. The narrow cast is bounded to the field-typed input record.
-    collectionsAsClasses[name] = new MongoCollection(
-      input as ConstructorParameters<typeof MongoCollection>[0],
-    );
+    const raw: Record<string, unknown> = {};
+    if (coll['indexes'] != null) raw['indexes'] = coll['indexes'];
+    if (coll['validator'] != null) raw['validator'] = coll['validator'];
+    if (coll['options'] != null) raw['options'] = coll['options'];
+    collectionInputs[name] = blindCast<
+      MongoCollectionInput,
+      'arktype-validated JSON shapes satisfy MongoCollectionInput by construction'
+    >(raw);
   }
+  const unboundNamespace = buildMongoNamespace({
+    id: UNBOUND_NAMESPACE_ID,
+    entries: { collection: collectionInputs },
+  });
+  // Hash the constructed (normalized) collection map, not the raw input
+  // literals — persisted storageHash values were computed over the
+  // constructed form.
   const storageWithoutHash = {
     namespaces: {
       [UNBOUND_NAMESPACE_ID]: {
         id: UNBOUND_NAMESPACE_ID,
-        entries: { collection: collectionsAsClasses },
+        entries: { collection: unboundNamespace.entries.collection },
       },
     },
   };
@@ -1171,10 +1161,7 @@ export function interpretPslDocumentToMongoContract(
   const storage = new MongoStorage({
     storageHash,
     namespaces: {
-      [UNBOUND_NAMESPACE_ID]: buildMongoNamespace({
-        id: UNBOUND_NAMESPACE_ID,
-        entries: { collection: collectionsAsClasses },
-      }),
+      [UNBOUND_NAMESPACE_ID]: unboundNamespace,
     },
   }) as Contract['storage'];
   const capabilities: Record<string, Record<string, boolean>> = {};

package/src/provider.ts

@@ -1,17 +1,34 @@
 import { readFile } from 'node:fs/promises';
-import type { ContractConfig } from '@prisma-next/config/config-types';
-import { parsePslDocument } from '@prisma-next/psl-parser';
+import type { ContractConfig, ContractSourceDiagnostic } from '@prisma-next/config/config-types';
+import { buildSymbolTable, rangeToPslSpan } from '@prisma-next/psl-parser';
+import type { ParseDiagnostic, SourceFile } from '@prisma-next/psl-parser/syntax';
+import { parse } from '@prisma-next/psl-parser/syntax';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
+
 import { interpretPslDocumentToMongoContract } from './interpreter';
 
 export interface MongoContractOptions {
   readonly output?: string;
 }
 
+function mapParseDiagnostics(
+  diagnostics: readonly ParseDiagnostic[],
+  sourceFile: SourceFile,
+  sourceId: string,
+): ContractSourceDiagnostic[] {
+  return diagnostics.map((diagnostic) => ({
+    code: diagnostic.code,
+    message: diagnostic.message,
+    sourceId,
+    span: rangeToPslSpan(diagnostic.range, sourceFile),
+  }));
+}
+
 export function mongoContract(schemaPath: string, options?: MongoContractOptions): ContractConfig {
   return {
     source: {
+      sourceFormat: 'psl',
       inputs: [schemaPath],
       load: async (context) => {
         const [absoluteSchemaPath] = context.resolvedInputs;
@@ -38,13 +55,26 @@ export function mongoContract(schemaPath: string, options?: MongoContractOptions
           });
         }
 
-        const document = parsePslDocument({
-          schema,
-          sourceId: schemaPath,
+        const { document, sourceFile, diagnostics: parseDiagnostics } = parse(schema);
+        const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({
+          document,
+          sourceFile,
+          scalarTypes: [...context.scalarTypeDescriptors.keys()],
+          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,
         });
 
+        // Do not short-circuit on provider-level diagnostics; recovered CST can
+        // still produce interpreter diagnostics in the same response.
+        const seedDiagnostics = [
+          ...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath),
+          ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath),
+        ];
+
         const interpreted = interpretPslDocumentToMongoContract({
-          document,
+          symbolTable,
+          sourceFile,
+          sourceId: schemaPath,
+          seedDiagnostics,
           scalarTypeDescriptors: context.scalarTypeDescriptors,
           codecLookup: context.codecLookup,
         });

package/src/psl-helpers.ts

@@ -1,9 +1,14 @@
-import type { PslAttribute, PslAttributeArgument } from '@prisma-next/psl-parser';
-import { getPositionalArgument, parseQuotedStringLiteral } from '@prisma-next/psl-parser';
+import type { ResolvedAttribute, ResolvedAttributeArg } from '@prisma-next/psl-parser';
+import { parseQuotedStringLiteral } from '@prisma-next/psl-parser';
+import { ifDefined } from '@prisma-next/utils/defined';
 
-export { getPositionalArgument, parseQuotedStringLiteral };
+export { parseQuotedStringLiteral };
 
-export function getNamedArgument(attr: PslAttribute, name: string): string | undefined {
+export function getPositionalArgument(attr: ResolvedAttribute, index = 0): string | undefined {
+  return attr.args.filter((arg) => arg.kind === 'positional')[index]?.value;
+}
+
+export function getNamedArgument(attr: ResolvedAttribute, name: string): string | undefined {
   const arg = attr.args.find((a) => a.kind === 'named' && a.name === name);
   return arg?.value;
 }
@@ -72,13 +77,13 @@ export function lowerFirst(value: string): string {
 }
 
 export function getAttribute(
-  attributes: readonly PslAttribute[],
+  attributes: readonly ResolvedAttribute[],
   name: string,
-): PslAttribute | undefined {
+): ResolvedAttribute | undefined {
   return attributes.find((attr) => attr.name === name);
 }
 
-export function getMapName(attributes: readonly PslAttribute[]): string | undefined {
+export function getMapName(attributes: readonly ResolvedAttribute[]): string | undefined {
   const mapAttr = getAttribute(attributes, 'map');
   if (!mapAttr) return undefined;
   const arg = mapAttr.args[0];
@@ -93,14 +98,14 @@ export interface ParsedRelationAttribute {
 }
 
 export function parseRelationAttribute(
-  attributes: readonly PslAttribute[],
+  attributes: readonly ResolvedAttribute[],
 ): ParsedRelationAttribute | undefined {
   const relationAttr = getAttribute(attributes, 'relation');
   if (!relationAttr) return undefined;
 
   let relationName: string | undefined;
-  let fieldsArg: PslAttributeArgument | undefined;
-  let referencesArg: PslAttributeArgument | undefined;
+  let fieldsArg: ResolvedAttributeArg | undefined;
+  let referencesArg: ResolvedAttributeArg | undefined;
 
   for (const arg of relationAttr.args) {
     if (arg.kind === 'positional') {
@@ -118,9 +123,9 @@ export function parseRelationAttribute(
   const references = referencesArg ? parseFieldList(referencesArg.value) : undefined;
 
   return {
-    ...(relationName !== undefined ? { relationName } : {}),
-    ...(fields !== undefined ? { fields } : {}),
-    ...(references !== undefined ? { references } : {}),
+    ...ifDefined('relationName', relationName),
+    ...ifDefined('fields', fields),
+    ...ifDefined('references', references),
   };
 }