@prisma-next/mongo-contract-psl 0.14.0-dev.3 → 0.14.0-dev.31

package/src/interpreter.ts

@@ -5,12 +5,24 @@ import type {
 import { computeProfileHash, computeStorageHash } from '@prisma-next/contract/hashing';
 import {
   type Contract,
+  type ContractEnum,
   type ContractField,
   type ContractReferenceRelation,
   type ContractValueObject,
   type CrossReference,
   crossRef,
+  type JsonValue,
+  type ValueSetRef,
 } from '@prisma-next/contract/types';
+import type { EnumTypeHandle } from '@prisma-next/contract-authoring';
+import type {
+  AuthoringContributions,
+  AuthoringEntityContext,
+} from '@prisma-next/framework-components/authoring';
+import {
+  instantiateAuthoringEntityType,
+  isAuthoringEntityTypeDescriptor,
+} from '@prisma-next/framework-components/authoring';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
@@ -24,13 +36,19 @@ import {
 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,
+  PslExtensionBlock,
   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 { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { deriveJsonSchema, derivePolymorphicJsonSchema } from './derive-json-schema';
 import {
@@ -45,41 +63,31 @@ 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[];
+  readonly authoringContributions?: AuthoringContributions;
 }
 
 /**
- * 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),
     });
   }
 }
@@ -101,16 +109,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);
 }
 
@@ -123,12 +131,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 {
@@ -136,7 +144,7 @@ function mongoCrossRef(modelName: string): CrossReference {
 }
 
 function collectPolymorphismDeclarations(
-  document: ParsePslDocumentResult,
+  models: readonly ModelSymbol[],
   sourceId: string,
   diagnostics: ContractSourceDiagnostic[],
 ): {
@@ -145,32 +153,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);
@@ -178,7 +185,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,
           });
@@ -188,14 +195,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 });
       }
     }
   }
@@ -207,7 +214,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>;
@@ -225,11 +232,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;
@@ -249,9 +255,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)) {
@@ -312,9 +318,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({
@@ -339,7 +345,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) };
@@ -483,9 +489,7 @@ function parseJsonArg(raw: string | undefined): Record<string, unknown> | undefi
   return undefined;
 }
 
-function parseCollation(
-  attr: import('@prisma-next/psl-parser').PslAttribute,
-): CollationOptions | null | undefined {
+function parseCollation(attr: ResolvedAttribute): CollationOptions | null | undefined {
   const locale = stripQuotesHelper(getNamedArgument(attr, 'collationLocale'));
   if (!locale) {
     const hasAnyCollationArg =
@@ -545,7 +549,7 @@ function parseProjectionList(
 }
 
 function collectIndexes(
-  pslModel: PslModel,
+  pslModel: ModelSymbol,
   fieldMappings: FieldMappings,
   modelNames: ReadonlySet<string>,
   sourceId: string,
@@ -561,12 +565,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;
@@ -800,7 +804,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);
 }
 
@@ -808,17 +812,18 @@ 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>,
+  codecIdByEnumName: ReadonlyMap<string, string>,
   sourceId: string,
   diagnostics: ContractSourceDiagnostic[],
 ): ContractField | undefined {
@@ -830,6 +835,29 @@ function resolveNonRelationField(
     return field.list ? { ...result, many: true } : result;
   }
 
+  // If this field's declared type is a known enum name, treat the field as a scalar
+  // with that enum's codec and stamp the domain valueSet ref.
+  const enumCodecId = codecIdByEnumName.get(field.typeName);
+  if (enumCodecId !== undefined) {
+    const valueSet: ValueSetRef = {
+      plane: 'domain',
+      entityKind: 'enum',
+      namespaceId: UNBOUND_NAMESPACE_ID,
+      entityName: field.typeName,
+    };
+    const result: ContractField = {
+      type: { kind: 'scalar', codecId: enumCodecId },
+      nullable: field.optional,
+      valueSet,
+    };
+    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({
@@ -848,27 +876,105 @@ function resolveNonRelationField(
   return field.list ? { ...result, many: true } : result;
 }
 
+function processEnumDeclarations(input: {
+  readonly enumBlocks: readonly PslExtensionBlock[];
+  readonly sourceId: string;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly entityContext: AuthoringEntityContext;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): Record<string, ContractEnum> {
+  const builtEnums: Record<string, ContractEnum> = {};
+
+  if (input.enumBlocks.length === 0) return builtEnums;
+
+  const enumDescriptor =
+    input.authoringContributions?.entityTypes?.['enum'] !== undefined &&
+    isAuthoringEntityTypeDescriptor(input.authoringContributions.entityTypes['enum'])
+      ? input.authoringContributions.entityTypes['enum']
+      : undefined;
+
+  if (!enumDescriptor) {
+    for (const decl of input.enumBlocks) {
+      input.diagnostics.push({
+        code: 'PSL_ENUM_MISSING_FACTORY',
+        message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
+        sourceId: input.sourceId,
+        span: decl.span,
+      });
+    }
+    return builtEnums;
+  }
+
+  for (const decl of input.enumBlocks) {
+    const handle = instantiateAuthoringEntityType<EnumTypeHandle | undefined>(
+      'enum',
+      enumDescriptor,
+      [decl],
+      input.entityContext,
+    );
+
+    if (handle === undefined || handle === null) continue;
+
+    builtEnums[decl.name] = {
+      codecId: handle.codecId,
+      members: handle.enumMembers.map((m) => ({
+        name: m.name,
+        value: blindCast<JsonValue, 'factory-validated enum members are JsonValue-compatible'>(
+          m.value,
+        ),
+      })),
+    };
+  }
+
+  return builtEnums;
+}
+
 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));
 
+  const topLevelEnumBlocks = Object.values(topLevel.blocks)
+    .filter((b) => b.keyword === 'enum')
+    .map((b) => b.block);
+
+  const builtEnums = processEnumDeclarations({
+    enumBlocks: topLevelEnumBlocks,
+    sourceId,
+    authoringContributions: input.authoringContributions,
+    entityContext: {
+      family: 'mongo',
+      target: 'mongo',
+      ...ifDefined('codecLookup', codecLookup),
+      sourceId,
+      diagnostics: {
+        push: (d) => {
+          diagnostics.push(
+            blindCast<ContractSourceDiagnostic, 'sink diagnostics are span-compatible'>(d),
+          );
+        },
+      },
+    },
+    diagnostics,
+  });
+
+  const codecIdByEnumName: Map<string, string> = new Map(
+    Object.entries(builtEnums).map(([name, e]) => [name, e.codecId]),
+  );
+
   const models: Record<string, MongoModelEntry> = {};
   const collections: Record<string, Record<string, unknown>> = {};
   const roots: Record<string, CrossReference> = {};
@@ -882,7 +988,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[] = [];
 
@@ -893,7 +999,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);
 
@@ -902,9 +1008,7 @@ export function interpretPslDocumentToMongoContract(
             modelName: pslModel.name,
             fieldName: field.name,
             targetModelName: field.typeName,
-            ...(relation?.relationName !== undefined
-              ? { relationName: relation.relationName }
-              : {}),
+            ...ifDefined('relationName', relation?.relationName),
             cardinality: field.list ? '1:N' : '1:1',
             field,
           });
@@ -933,7 +1037,7 @@ export function interpretPslDocumentToMongoContract(
             declaringModel: pslModel.name,
             fieldName: field.name,
             targetModel: field.typeName,
-            ...(relation.relationName !== undefined ? { relationName: relation.relationName } : {}),
+            ...ifDefined('relationName', relation.relationName),
             localFields: localMapped,
             targetFields: targetMapped,
           });
@@ -946,6 +1050,7 @@ export function interpretPslDocumentToMongoContract(
         pslModel.name,
         compositeTypeNames,
         scalarTypeDescriptors,
+        codecIdByEnumName,
         sourceId,
         diagnostics,
       );
@@ -956,7 +1061,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) {
@@ -1011,12 +1118,13 @@ 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,
         compositeTypeNames,
         scalarTypeDescriptors,
+        codecIdByEnumName,
         sourceId,
         diagnostics,
       );
@@ -1078,7 +1186,7 @@ export function interpretPslDocumentToMongoContract(
   }
 
   const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(
-    document,
+    allModels,
     sourceId,
     diagnostics,
   );
@@ -1086,7 +1194,7 @@ export function interpretPslDocumentToMongoContract(
     models,
     roots,
     collections,
-    document,
+    allModels,
     discriminatorDeclarations,
     baseDeclarations,
     modelNames,
@@ -1125,9 +1233,15 @@ export function interpretPslDocumentToMongoContract(
         variantEntries,
         valueObjects,
         codecLookup,
+        builtEnums,
       );
     } else {
-      coll['validator'] = deriveJsonSchema(modelEntry.fields, valueObjects, codecLookup);
+      coll['validator'] = deriveJsonSchema(
+        modelEntry.fields,
+        valueObjects,
+        codecLookup,
+        builtEnums,
+      );
     }
   }
 
@@ -1173,6 +1287,8 @@ export function interpretPslDocumentToMongoContract(
   }) as Contract['storage'];
   const capabilities: Record<string, Record<string, boolean>> = {};
 
+  const hasEnums = Object.keys(builtEnums).length > 0;
+
   return ok({
     targetFamily,
     target,
@@ -1182,6 +1298,7 @@ export function interpretPslDocumentToMongoContract(
         [UNBOUND_NAMESPACE_ID]: {
           models: polyResult.models,
           ...(Object.keys(valueObjects).length > 0 ? { valueObjects } : {}),
+          ...(hasEnums ? { enum: builtEnums } : {}),
         },
       },
     },

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,15 +55,29 @@ 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,
+          authoringContributions: context.authoringContributions,
         });
         if (!interpreted.ok) {
           return interpreted;