@prisma-next/sql-contract-psl 0.14.0-dev.5 → 0.14.0-dev.7

package/src/provider.ts

@@ -1,15 +1,18 @@
 import { readFile } from 'node:fs/promises';
-import type { ContractConfig } from '@prisma-next/config/config-types';
+import type { ContractConfig, ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';
 import type { ControlPolicy } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import { parsePslDocument } from '@prisma-next/psl-parser';
+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 type { SqlNamespaceTablesInput } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { basename, extname } from 'pathe';
+
 import { interpretPslDocumentToSqlContract } from './interpreter';
 import type { ColumnDescriptor } from './psl-column-resolution';
 
@@ -42,6 +45,19 @@ function defaultOutputFromSchemaPath(schemaPath: string): string {
   return `${base}.json`;
 }
 
+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),
+  }));
+}
+
 function buildColumnDescriptorMap(
   scalarTypeDescriptors: ReadonlyMap<string, string>,
   codecLookup: CodecLookup,
@@ -85,19 +101,31 @@ export function prismaContract(schemaPath: string, options: PrismaContractOption
           });
         }
 
-        const document = parsePslDocument({
-          schema,
-          sourceId: schemaPath,
-          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,
-        });
-
         const scalarTypeDescriptors = buildColumnDescriptorMap(
           context.scalarTypeDescriptors,
           context.codecLookup,
         );
 
-        const interpreted = interpretPslDocumentToSqlContract({
+        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 = interpretPslDocumentToSqlContract({
+          symbolTable,
+          sourceFile,
+          sourceId: schemaPath,
+          seedDiagnostics,
           target: options.target,
           authoringContributions: context.authoringContributions,
           scalarTypeDescriptors,

package/src/psl-attribute-parsing.ts

@@ -1,9 +1,13 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import type { ControlPolicy } from '@prisma-next/contract/types';
-import type { PslAttribute, PslSpan } from '@prisma-next/psl-parser';
-import { getPositionalArgument, parseQuotedStringLiteral } from '@prisma-next/psl-parser';
+import type { PslSpan, ResolvedAttribute } from '@prisma-next/psl-parser';
+import { parseQuotedStringLiteral } from '@prisma-next/psl-parser';
 
-export { getPositionalArgument, parseQuotedStringLiteral };
+export { parseQuotedStringLiteral };
+
+export function getPositionalArgument(attribute: ResolvedAttribute, index = 0): string | undefined {
+  return attribute.args.filter((arg) => arg.kind === 'positional')[index]?.value;
+}
 
 export function lowerFirst(value: string): string {
   if (value.length === 0) return value;
@@ -11,13 +15,13 @@ export function lowerFirst(value: string): string {
 }
 
 export function getAttribute(
-  attributes: readonly PslAttribute[] | undefined,
+  attributes: readonly ResolvedAttribute[] | undefined,
   name: string,
-): PslAttribute | undefined {
+): ResolvedAttribute | undefined {
   return attributes?.find((attribute) => attribute.name === name);
 }
 
-export function getNamedArgument(attribute: PslAttribute, name: string): string | undefined {
+export function getNamedArgument(attribute: ResolvedAttribute, name: string): string | undefined {
   const entry = attribute.args.find((arg) => arg.kind === 'named' && arg.name === name);
   if (!entry || entry.kind !== 'named') {
     return undefined;
@@ -26,7 +30,7 @@ export function getNamedArgument(attribute: PslAttribute, name: string): string
 }
 
 export function getPositionalArgumentEntry(
-  attribute: PslAttribute,
+  attribute: ResolvedAttribute,
   index = 0,
 ): { value: string; span: PslSpan } | undefined {
   const entries = attribute.args.filter((arg) => arg.kind === 'positional');
@@ -63,7 +67,7 @@ export function parseFieldList(value: string): readonly string[] | undefined {
 }
 
 export function parseMapName(input: {
-  readonly attribute: PslAttribute | undefined;
+  readonly attribute: ResolvedAttribute | undefined;
   readonly defaultValue: string;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
@@ -98,7 +102,7 @@ export function parseMapName(input: {
 }
 
 export function parseConstraintMapArgument(input: {
-  readonly attribute: PslAttribute | undefined;
+  readonly attribute: ResolvedAttribute | undefined;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly entityLabel: string;
@@ -128,7 +132,7 @@ export function parseConstraintMapArgument(input: {
   return undefined;
 }
 
-export function getPositionalArguments(attribute: PslAttribute): readonly string[] {
+export function getPositionalArguments(attribute: ResolvedAttribute): readonly string[] {
   return attribute.args
     .filter((arg) => arg.kind === 'positional')
     .map((arg) => (arg.kind === 'positional' ? arg.value : ''));
@@ -276,7 +280,7 @@ export function pushInvalidAttributeArgument(input: {
 }
 
 export function parseOptionalSingleIntegerArgument(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly entityLabel: string;
@@ -319,7 +323,7 @@ export function parseOptionalSingleIntegerArgument(input: {
 }
 
 export function parseOptionalNumericArguments(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly entityLabel: string;
@@ -374,7 +378,7 @@ export function parseOptionalNumericArguments(input: {
 }
 
 export function parseAttributeFieldList(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly code: string;
@@ -426,7 +430,7 @@ function isControlPolicyLiteral(value: string): value is ControlPolicy {
 }
 
 export function parseControlPolicyAttribute(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
 }): ControlPolicy | undefined {

package/src/psl-authoring-arguments.ts

@@ -1,6 +1,6 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import type { AuthoringArgumentDescriptor } from '@prisma-next/framework-components/authoring';
-import type { PslAttributeArgument, PslSpan } from '@prisma-next/psl-parser';
+import type { PslSpan, ResolvedAttributeArg } from '@prisma-next/psl-parser';
 import { unquoteStringLiteral } from './psl-attribute-parsing';
 
 const INVALID_AUTHORING_ARGUMENT = Symbol('invalidAuthoringArgument');
@@ -351,7 +351,7 @@ function pushInvalidPslHelperArgument(input: {
 }
 
 export function mapPslHelperArgs(input: {
-  readonly args: readonly PslAttributeArgument[];
+  readonly args: readonly ResolvedAttributeArg[];
   readonly descriptors: readonly AuthoringArgumentDescriptor[];
   readonly helperLabel: string;
   readonly span: PslSpan;

package/src/psl-column-resolution.ts

@@ -20,12 +20,13 @@ import type {
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
 import type {
-  PslAttribute,
-  PslField,
+  FieldSymbol,
   PslSpan,
-  PslTypeConstructorCall,
+  ResolvedAttribute,
+  ResolvedTypeConstructorCall,
 } from '@prisma-next/psl-parser';
 import { blindCast } from '@prisma-next/utils/casts';
+
 import {
   lowerDefaultFunctionWithRegistry,
   parseDefaultFunctionCall,
@@ -207,7 +208,7 @@ export function reportUnknownFieldPreset(input: {
 }
 
 export function instantiatePslTypeConstructor(input: {
-  readonly call: PslTypeConstructorCall;
+  readonly call: ResolvedTypeConstructorCall;
   readonly descriptor: AuthoringTypeConstructorDescriptor;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
@@ -265,7 +266,7 @@ function pushUnsupportedTypeConstructorDiagnostic(input: {
 }
 
 export function resolvePslTypeConstructorDescriptor(input: {
-  readonly call: PslTypeConstructorCall;
+  readonly call: ResolvedTypeConstructorCall;
   readonly authoringContributions: AuthoringContributions | undefined;
   readonly composedExtensions: ReadonlySet<string>;
   readonly familyId: string;
@@ -314,8 +315,8 @@ export function resolvePslTypeConstructorDescriptor(input: {
  *
  * Symmetric with `instantiatePslTypeConstructor` but richer: a field preset can contribute `default`, `executionDefaults`, `id`, `unique`, and `nullable` in addition to the storage-type triple. PSL → typed-args coercion happens here (via `mapPslHelperArgs`) so that `instantiateAuthoringFieldPreset` itself stays typed-input-only and TS keeps its zero-runtime-validation cost.
  */
-export function instantiatePslFieldPreset(input: {
-  readonly call: PslTypeConstructorCall;
+export function instantiateFieldPreset(input: {
+  readonly call: ResolvedTypeConstructorCall;
   readonly descriptor: AuthoringFieldPresetDescriptor;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
@@ -395,7 +396,7 @@ export type ResolveFieldTypeResult =
   | { readonly ok: false; readonly alreadyReported: boolean };
 
 export function resolveFieldTypeDescriptor(input: {
-  readonly field: PslField;
+  readonly field: FieldSymbol;
   readonly enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
@@ -407,6 +408,10 @@ export function resolveFieldTypeDescriptor(input: {
   readonly sourceId: string;
   readonly entityLabel: string;
 }): ResolveFieldTypeResult {
+  // Avoid cascading unsupported-type diagnostics after invalid qualification.
+  if (input.field.malformedType) {
+    return { ok: false, alreadyReported: true };
+  }
   if (input.field.typeConstructor) {
     // Field presets carry richer semantics than type constructors, so a field preset match is the complete answer. Shared composition rejects exact cross-registry collisions before PSL resolution can observe them.
     const presetDescriptor = getAuthoringFieldPreset(
@@ -414,7 +419,7 @@ export function resolveFieldTypeDescriptor(input: {
       input.field.typeConstructor.path,
     );
     if (presetDescriptor) {
-      const instantiated = instantiatePslFieldPreset({
+      const instantiated = instantiateFieldPreset({
         call: input.field.typeConstructor,
         descriptor: presetDescriptor,
         diagnostics: input.diagnostics,
@@ -588,7 +593,7 @@ export const NATIVE_TYPE_SPECS: Readonly<Record<string, NativeTypeSpec>> = {
 };
 
 export function resolveDbNativeTypeAttribute(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly baseType: string;
   readonly baseDescriptor: ColumnDescriptor;
   readonly diagnostics: ContractSourceDiagnostic[];
@@ -703,7 +708,7 @@ export function parseDefaultLiteralValue(expression: string): ColumnDefault | un
 export function lowerDefaultForField(input: {
   readonly modelName: string;
   readonly fieldName: string;
-  readonly defaultAttribute: PslAttribute;
+  readonly defaultAttribute: ResolvedAttribute;
   readonly columnDescriptor: ColumnDescriptor;
   readonly generatorDescriptorById: ReadonlyMap<string, MutationDefaultGeneratorDescriptor>;
   readonly sourceId: string;
@@ -809,14 +814,11 @@ export function lowerDefaultForField(input: {
 }
 
 export function resolveColumnDescriptor(
-  field: PslField,
+  field: FieldSymbol,
   enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
   namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
   scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
 ): ColumnDescriptor | undefined {
-  if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) {
-    return namedTypeDescriptors.get(field.typeRef);
-  }
   if (namedTypeDescriptors.has(field.typeName)) {
     return namedTypeDescriptors.get(field.typeName);
   }

package/src/psl-field-resolution.ts

@@ -9,13 +9,12 @@ import type {
   ControlMutationDefaultRegistry,
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
-import type { PslAttribute, PslField, PslModel } from '@prisma-next/psl-parser';
+import type { FieldSymbol, ModelSymbol, ResolvedAttribute } from '@prisma-next/psl-parser';
 import type { EnumTypeHandle } from '@prisma-next/sql-contract-ts/contract-builder';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import {
   getAttribute,
-  getPositionalArgumentEntry,
   lowerFirst,
   parseConstraintMapArgument,
   parseMapName,
@@ -36,13 +35,21 @@ type LoweredFieldDefault = {
 function lowerEnumDefaultForField(input: {
   readonly modelName: string;
   readonly fieldName: string;
-  readonly defaultAttribute: PslAttribute;
+  readonly defaultAttribute: ResolvedAttribute;
   readonly enumHandle: EnumTypeHandle;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
 }): LoweredFieldDefault {
-  const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
-  if (!expressionEntry) {
+  const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === 'positional');
+  const hasNamedEntries = input.defaultAttribute.args.some((arg) => arg.kind === 'named');
+  const expressionEntry = positionalEntries[0];
+  if (hasNamedEntries || positionalEntries.length !== 1 || expressionEntry === undefined) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT',
+      message: `Field "${input.modelName}.${input.fieldName}" @default on an enum field expects exactly one positional enum member argument.`,
+      sourceId: input.sourceId,
+      span: input.defaultAttribute.span,
+    });
     return {};
   }
 
@@ -84,9 +91,10 @@ function lowerEnumDefaultForField(input: {
 }
 
 export type ResolvedField = {
-  readonly field: PslField;
+  readonly field: FieldSymbol;
   readonly columnName: string;
   readonly descriptor: ColumnDescriptor;
+  readonly nullable: boolean;
   readonly defaultValue?: ColumnDefault;
   readonly executionDefaults?: ExecutionMutationDefaultPhases;
   readonly isId: boolean;
@@ -99,7 +107,7 @@ export type ResolvedField = {
 };
 
 export type ModelNameMapping = {
-  readonly model: PslModel;
+  readonly model: ModelSymbol;
   readonly tableName: string;
   readonly fieldColumns: Map<string, string>;
 };
@@ -112,7 +120,7 @@ export type ModelNameMapping = {
  * {@link modelCoordinateKey} rather than the bare model name.
  */
 export type ModelNamespaceEntry = {
-  readonly model: PslModel;
+  readonly model: ModelSymbol;
   readonly namespaceId: string | undefined;
 };
 
@@ -123,7 +131,7 @@ export function modelCoordinateKey(namespaceId: string, modelName: string): stri
 }
 
 export interface CollectResolvedFieldsInput {
-  readonly model: PslModel;
+  readonly model: ModelSymbol;
   readonly mapping: ModelNameMapping;
   readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
   readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
@@ -163,7 +171,7 @@ const BUILTIN_FIELD_ATTRIBUTE_NAMES: ReadonlySet<string> = new Set([
  */
 interface RemovedAttributeRule {
   readonly hint: string;
-  readonly suppressWhen: (field: PslField) => boolean;
+  readonly suppressWhen: (field: FieldSymbol) => boolean;
 }
 
 const REMOVED_ATTRIBUTE_RULES: ReadonlyMap<string, RemovedAttributeRule> = new Map([
@@ -193,8 +201,8 @@ const REMOVED_ATTRIBUTE_RULES: ReadonlyMap<string, RemovedAttributeRule> = new M
 }
 
 function validateFieldAttributes(input: {
-  readonly model: PslModel;
-  readonly field: PslField;
+  readonly model: ModelSymbol;
+  readonly field: FieldSymbol;
   readonly composedExtensions: ReadonlySet<string>;
   readonly authoringContributions: AuthoringContributions | undefined;
   readonly diagnostics: ContractSourceDiagnostic[];
@@ -240,13 +248,13 @@ function validateFieldAttributes(input: {
 }
 
 function extractFieldConstraintNames(input: {
-  readonly model: PslModel;
-  readonly field: PslField;
+  readonly model: ModelSymbol;
+  readonly field: FieldSymbol;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
 }): {
-  readonly idAttribute: PslAttribute | undefined;
-  readonly uniqueAttribute: PslAttribute | undefined;
+  readonly idAttribute: ResolvedAttribute | undefined;
+  readonly uniqueAttribute: ResolvedAttribute | undefined;
   readonly idName: string | undefined;
   readonly uniqueName: string | undefined;
 } {
@@ -292,7 +300,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
   } = input;
   const resolvedFields: ResolvedField[] = [];
 
-  for (const field of model.fields) {
+  for (const field of Object.values(model.fields)) {
     const isModelField = modelNames.has(field.typeName);
 
     if (field.list && isModelField) {
@@ -448,8 +456,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       });
       continue;
     }
-    const fieldUsesNamedType =
-      field.typeRef !== undefined || namedTypeDescriptors.has(field.typeName);
+    const fieldUsesNamedType = namedTypeDescriptors.has(field.typeName);
     if (loweredOnCreate && !fieldUsesNamedType) {
       const generatorDescriptor = generatorDescriptorById.get(loweredOnCreate.id);
       const generatedDescriptor = generatorDescriptor?.resolveGeneratedColumnDescriptor?.({
@@ -502,6 +509,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       field,
       columnName: mappedColumnName,
       descriptor,
+      nullable: presetContributions?.nullable ?? field.optional,
       ...ifDefined('defaultValue', fieldDefaultValue),
       ...ifDefined('executionDefaults', fieldExecutionDefaults),
       isId: isIdField || Boolean(presetContributions?.id),
@@ -535,7 +543,7 @@ export function buildModelMappings(
       span: model.span,
     });
     const fieldColumns = new Map<string, string>();
-    for (const field of model.fields) {
+    for (const field of Object.values(model.fields)) {
       const fieldMapAttribute = getAttribute(field.attributes, 'map');
       const columnName = parseMapName({
         attribute: fieldMapAttribute,