@prisma-next/psl-parser 0.14.0-dev.5 → 0.14.0-dev.50

package/src/block-reconstruction.ts

@@ -0,0 +1,139 @@
+import type { AuthoringPslBlockDescriptor } from '@prisma-next/framework-components/authoring';
+import type {
+  PslBlockParam,
+  PslExtensionBlock,
+  PslExtensionBlockAttribute,
+  PslExtensionBlockParamValue,
+  PslSpan,
+} from '@prisma-next/framework-components/psl-ast';
+import type { ParseDiagnostic } from './parse';
+import { nodePslSpan } from './resolve';
+import type { SourceFile } from './source-file';
+import type { GenericBlockDeclarationAst, KeyValuePairAst } from './syntax/ast/declarations';
+import { ArrayLiteralAst, type ExpressionAst } from './syntax/ast/expressions';
+import { printSyntax } from './syntax/ast-helpers';
+
+/**
+ * Descriptor-free and unknown parameters become `value` stubs so validation can
+ * report them via key-set comparison. Duplicate member names are first-wins.
+ */
+export function reconstructExtensionBlock(
+  node: GenericBlockDeclarationAst,
+  descriptor: AuthoringPslBlockDescriptor | undefined,
+  sourceFile: SourceFile,
+  diagnostics: ParseDiagnostic[],
+): PslExtensionBlock {
+  const keyword = node.keyword()?.text ?? '';
+  const blockName = node.name()?.name() ?? '';
+
+  const blockAttributes: PslExtensionBlockAttribute[] = [];
+  for (const attribute of node.attributes()) {
+    const name = attribute.name()?.path().join('.') ?? '';
+    const args = Array.from(attribute.argList()?.args() ?? [], (arg) => {
+      const value = arg.value();
+      return {
+        kind: 'positional' as const,
+        value: value === undefined ? '' : printSyntax(value.syntax).trim(),
+        span: nodePslSpan(arg.syntax, sourceFile),
+      };
+    });
+    blockAttributes.push({
+      name,
+      args,
+      span: nodePslSpan(attribute.syntax, sourceFile),
+    });
+  }
+
+  const parameters: Record<string, PslExtensionBlockParamValue> = {};
+  for (const entry of node.entries()) {
+    const key = entry.key()?.name();
+    if (key === undefined) continue;
+    const span = nodePslSpan(entry.syntax, sourceFile);
+    if (Object.hasOwn(parameters, key)) {
+      diagnostics.push({
+        code: 'PSL_EXTENSION_DUPLICATE_PARAMETER',
+        message: `Duplicate parameter "${key}" in "${keyword}" block "${blockName}"; first occurrence wins`,
+        range: {
+          start: sourceFile.positionAt(entry.syntax.offset),
+          end: sourceFile.positionAt(entry.syntax.offset + entry.syntax.green.textLength),
+        },
+      });
+      continue;
+    }
+    parameters[key] = reconstructParamValue(
+      entry,
+      descriptor?.parameters[key],
+      span,
+      sourceFile,
+      diagnostics,
+    );
+  }
+
+  return {
+    kind: descriptor?.discriminator ?? keyword,
+    name: blockName,
+    parameters,
+    blockAttributes,
+    span: nodePslSpan(node.syntax, sourceFile),
+  };
+}
+
+function reconstructParamValue(
+  entry: KeyValuePairAst,
+  param: PslBlockParam | undefined,
+  span: PslSpan,
+  sourceFile: SourceFile,
+  diagnostics: ParseDiagnostic[],
+): PslExtensionBlockParamValue {
+  const value = entry.value();
+  if (value === undefined) {
+    return { kind: 'bare', span };
+  }
+  return reconstructFromExpression(value, param, span, sourceFile, diagnostics);
+}
+
+function reconstructFromExpression(
+  value: ExpressionAst,
+  param: PslBlockParam | undefined,
+  span: PslSpan,
+  sourceFile: SourceFile,
+  diagnostics?: ParseDiagnostic[],
+): PslExtensionBlockParamValue {
+  const raw = printSyntax(value.syntax).trim();
+  if (param?.kind === 'list') {
+    const array = ArrayLiteralAst.cast(value.syntax);
+    if (!array) {
+      diagnostics?.push({
+        code: 'PSL_EXTENSION_INVALID_VALUE',
+        message: `List parameter expects an array literal, got ${raw}`,
+        range: {
+          start: sourceFile.positionAt(value.syntax.offset),
+          end: sourceFile.positionAt(value.syntax.offset + value.syntax.green.textLength),
+        },
+      });
+      return { kind: 'value', raw, span };
+    }
+
+    const items: PslExtensionBlockParamValue[] = [];
+    for (const element of array.elements()) {
+      items.push(
+        reconstructFromExpression(
+          element,
+          param.of,
+          nodePslSpan(element.syntax, sourceFile),
+          sourceFile,
+          diagnostics,
+        ),
+      );
+    }
+    return { kind: 'list', items, span };
+  }
+  switch (param?.kind) {
+    case 'ref':
+      return { kind: 'ref', identifier: raw, span };
+    case 'option':
+      return { kind: 'option', token: raw, span };
+    default:
+      return { kind: 'value', raw, span };
+  }
+}

package/src/exports/index.ts

@@ -1,6 +1,4 @@
 export type {
-  ParsePslDocumentInput,
-  ParsePslDocumentResult,
   PslAttribute,
   PslAttributeArgument,
   PslAttributeNamedArgument,
@@ -38,4 +36,60 @@ export {
   namespacePslExtensionBlocks,
 } from '@prisma-next/framework-components/psl-ast';
 export { getPositionalArgument, parseQuotedStringLiteral } from '../attribute-helpers';
-export { parsePslDocument } from '../parser';
+export { bool } from '../attribute-spec/combinators/bool';
+export { leafDiagnostic } from '../attribute-spec/combinators/diagnostic';
+export { entityRef } from '../attribute-spec/combinators/entity-ref';
+export type { FieldRefArgType, FieldRefScope } from '../attribute-spec/combinators/field-ref';
+export { fieldRef } from '../attribute-spec/combinators/field-ref';
+export { identifier } from '../attribute-spec/combinators/identifier';
+export { int } from '../attribute-spec/combinators/int';
+export type { ListOptions } from '../attribute-spec/combinators/list';
+export { list } from '../attribute-spec/combinators/list';
+export { oneOf } from '../attribute-spec/combinators/one-of';
+export { record } from '../attribute-spec/combinators/record';
+export { str } from '../attribute-spec/combinators/str';
+export { fieldAttribute } from '../attribute-spec/field-attribute';
+export { interpretAttribute } from '../attribute-spec/interpret';
+export { modelAttribute } from '../attribute-spec/model-attribute';
+export { optional } from '../attribute-spec/optional';
+export type {
+  ArgType,
+  AttributeLevel,
+  AttributeOut,
+  AttributeSpec,
+  InferAttr,
+  InterpretCtx,
+  NamedOut,
+  OptionalArgType,
+  OutOf,
+  Param,
+  PositionalParam,
+  PosOut,
+} from '../attribute-spec/types';
+export { findBlockDescriptor, validateExtensionBlockFromSymbol } from '../extension-block';
+export {
+  keywordPslSpan,
+  nodePslSpan,
+  rangeToPslSpan,
+  readResolvedAttribute,
+  readResolvedAttributes,
+  readResolvedConstructorCall,
+} from '../resolve';
+export type {
+  BlockSymbol,
+  BuildSymbolTableOptions,
+  CompositeTypeSymbol,
+  FieldSymbol,
+  ModelSymbol,
+  NamespaceSymbol,
+  ResolvedAttribute,
+  ResolvedAttributeArg,
+  ResolvedNamedTypeBinding,
+  ResolvedTypeConstructorCall,
+  ScalarSymbol,
+  SymbolTable,
+  SymbolTableResult,
+  TopLevelScope,
+  TypeAliasSymbol,
+} from '../symbol-table';
+export { buildSymbolTable } from '../symbol-table';

package/src/exports/syntax.ts

@@ -7,7 +7,13 @@ export {
   FieldAttributeAst,
   ModelAttributeAst,
 } from '../syntax/ast/attributes';
-export type { NamespaceMemberAst } from '../syntax/ast/declarations';
+export type {
+  AttributeAst,
+  BlockMemberAst,
+  DeclarationAst,
+  GenericBlockMemberAst,
+  NamespaceMemberAst,
+} from '../syntax/ast/declarations';
 export {
   CompositeTypeDeclarationAst,
   DocumentAst,
@@ -35,12 +41,26 @@ export {
 export { IdentifierAst } from '../syntax/ast/identifier';
 export { QualifiedNameAst } from '../syntax/ast/qualified-name';
 export { TypeAnnotationAst } from '../syntax/ast/type-annotation';
-export type { AstNode } from '../syntax/ast-helpers';
-export { filterChildren, findChildToken, findFirstChild, printSyntax } from '../syntax/ast-helpers';
+export type { AstNode, BracedBlock } from '../syntax/ast-helpers';
+export {
+  any,
+  filterChildren,
+  findChildToken,
+  findFirstChild,
+  printSyntax,
+} from '../syntax/ast-helpers';
 export type { GreenElement, GreenNode, GreenToken } from '../syntax/green';
 export { greenNode, greenToken } from '../syntax/green';
 export { GreenNodeBuilder } from '../syntax/green-builder';
+// Navigation helpers
+export type { Direction } from '../syntax/navigation';
+export {
+  isTrivia,
+  isTriviaKind,
+  nonTriviaSibling,
+  skipTriviaToken,
+} from '../syntax/navigation';
 // Red layer
-export type { SyntaxElement, SyntaxToken } from '../syntax/red';
-export { createSyntaxTree, SyntaxNode } from '../syntax/red';
+export type { SyntaxElement } from '../syntax/red';
+export { createSyntaxTree, SyntaxNode, SyntaxToken, TokenAtOffset } from '../syntax/red';
 export type { SyntaxKind } from '../syntax/syntax-kind';

package/src/extension-block.ts

@@ -0,0 +1,107 @@
+import {
+  type AuthoringPslBlockDescriptor,
+  type AuthoringPslBlockDescriptorNamespace,
+  isAuthoringPslBlockDescriptor,
+} from '@prisma-next/framework-components/authoring';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import {
+  makePslNamespace,
+  makePslNamespaceEntries,
+  type PslDiagnostic,
+  type PslModel,
+  type PslSpan,
+  UNSPECIFIED_PSL_NAMESPACE_ID,
+  validateExtensionBlock,
+} from '@prisma-next/framework-components/psl-ast';
+import type { SourceFile } from './source-file';
+import type { BlockSymbol, ModelSymbol, SymbolTable } from './symbol-table';
+
+export function findBlockDescriptor(
+  descriptors: AuthoringPslBlockDescriptorNamespace | undefined,
+  keyword: string,
+): AuthoringPslBlockDescriptor | undefined {
+  if (descriptors === undefined) return undefined;
+  for (const value of Object.values(descriptors)) {
+    if (value === undefined) continue;
+    if (isAuthoringPslBlockDescriptor(value)) {
+      if (value.keyword === keyword) return value;
+      continue;
+    }
+    const nested = findBlockDescriptor(value, keyword);
+    if (nested !== undefined) return nested;
+  }
+  return undefined;
+}
+
+export function validateExtensionBlockFromSymbol(input: {
+  readonly block: BlockSymbol;
+  readonly descriptor: AuthoringPslBlockDescriptor;
+  readonly symbolTable: SymbolTable;
+  readonly sourceFile: SourceFile;
+  readonly sourceId: string;
+  readonly codecLookup: CodecLookup;
+}): readonly PslDiagnostic[] {
+  const refCtx = buildRefResolutionContext(input.symbolTable, input.block);
+  return validateExtensionBlock(
+    input.block.block,
+    input.descriptor,
+    input.sourceId,
+    input.codecLookup,
+    refCtx,
+  );
+}
+
+const ZERO_SPAN: PslSpan = {
+  start: { offset: 0, line: 1, column: 1 },
+  end: { offset: 0, line: 1, column: 1 },
+};
+
+function buildRefResolutionContext(
+  symbolTable: SymbolTable,
+  block: BlockSymbol,
+): {
+  ownerNamespace: ReturnType<typeof makePslNamespace>;
+  allNamespaces: readonly ReturnType<typeof makePslNamespace>[];
+} {
+  const unspecifiedNamespace = makeNamespace(
+    UNSPECIFIED_PSL_NAMESPACE_ID,
+    Object.values(symbolTable.topLevel.models),
+  );
+  const namedNamespaces = Object.values(symbolTable.topLevel.namespaces).map((namespace) =>
+    makeNamespace(namespace.name, Object.values(namespace.models)),
+  );
+  const allNamespaces = [unspecifiedNamespace, ...namedNamespaces];
+  const ownerNamespaceName = findOwnerNamespaceName(symbolTable, block);
+  const ownerNamespace =
+    allNamespaces.find((namespace) => namespace.name === ownerNamespaceName) ??
+    unspecifiedNamespace;
+  return { ownerNamespace, allNamespaces };
+}
+
+function makeNamespace(
+  name: string,
+  models: readonly ModelSymbol[],
+): ReturnType<typeof makePslNamespace> {
+  const modelStubs: PslModel[] = models.map((model) => ({
+    kind: 'model',
+    name: model.name,
+    fields: [],
+    attributes: [],
+    span: ZERO_SPAN,
+  }));
+  return makePslNamespace({
+    kind: 'namespace',
+    name,
+    entries: makePslNamespaceEntries(modelStubs, [], []),
+    span: ZERO_SPAN,
+  });
+}
+
+function findOwnerNamespaceName(symbolTable: SymbolTable, block: BlockSymbol): string {
+  for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
+    if (Object.values(namespace.blocks).some((candidate) => candidate === block)) {
+      return namespace.name;
+    }
+  }
+  return UNSPECIFIED_PSL_NAMESPACE_ID;
+}

package/src/parse.ts

@@ -399,14 +399,24 @@ function parseParenArgs(cursor: Cursor): void {
   }
 }
 
-export function parseAttributeArg(cursor: Cursor): GreenNode {
+export function parseAttributeArg(cursor: Cursor): void {
+  const kind = cursor.peekKind();
+  if (
+    kind !== 'Ident' &&
+    kind !== 'StringLiteral' &&
+    kind !== 'NumberLiteral' &&
+    kind !== 'LBracket' &&
+    kind !== 'LBrace'
+  ) {
+    return;
+  }
   cursor.startNode('AttributeArg');
   if (cursor.peekKind() === 'Ident' && cursor.peekKind(1) === 'Colon') {
     parseIdentifier(cursor);
     cursor.bump();
   }
   parseArgValue(cursor);
-  return cursor.finishNode();
+  cursor.finishNode();
 }
 
 function parseArgValue(cursor: Cursor): void {
@@ -435,8 +445,16 @@ export function parseAttribute(cursor: Cursor): GreenNode {
   return cursor.finishNode();
 }
 
-/** A type annotation: `QualifiedName (argList)? ([])? (?)?`, e.g. `pgvector.Vector(1536)[]?`. */
-export function parseTypeAnnotation(cursor: Cursor): GreenNode {
+/**
+ * A type annotation: `QualifiedName (argList)? ([])? (?)?`, e.g.
+ * `pgvector.Vector(1536)[]?`. When the field has no type, no node is emitted —
+ * a missing type is the absence of a `TypeAnnotation`, not a zero-width one.
+ */
+export function parseTypeAnnotation(cursor: Cursor): void {
+  const kind = cursor.peekKind();
+  if (kind !== 'Ident' && kind !== 'LBracket' && kind !== 'Question') {
+    return;
+  }
   cursor.startNode('TypeAnnotation');
   if (cursor.peekKind() === 'Ident') {
     parseQualifiedName(cursor);
@@ -453,7 +471,7 @@ export function parseTypeAnnotation(cursor: Cursor): GreenNode {
   if (cursor.peekKind() === 'Question') {
     cursor.bump();
   }
-  return cursor.finishNode();
+  cursor.finishNode();
 }
 
 type MemberParser = (cursor: Cursor) => void;

package/src/resolve.ts

@@ -0,0 +1,123 @@
+import type { PslSpan } from '@prisma-next/framework-components/psl-ast';
+import type { Position, Range, SourceFile } from './source-file';
+import type {
+  AttributeArgListAst,
+  FieldAttributeAst,
+  ModelAttributeAst,
+} from './syntax/ast/attributes';
+import type { ExpressionAst } from './syntax/ast/expressions';
+import type { QualifiedNameAst } from './syntax/ast/qualified-name';
+import type { TypeAnnotationAst } from './syntax/ast/type-annotation';
+import { printSyntax } from './syntax/ast-helpers';
+import type { SyntaxNode } from './syntax/red';
+
+export interface ResolvedAttributeArg {
+  readonly kind: 'positional' | 'named';
+  readonly name?: string;
+  readonly value: string;
+  readonly expression?: ExpressionAst;
+  readonly span: PslSpan;
+}
+
+export interface ResolvedAttribute {
+  readonly name: string;
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+
+export interface ResolvedTypeConstructorCall {
+  readonly path: readonly string[];
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+
+export function readResolvedAttribute(
+  attribute: FieldAttributeAst | ModelAttributeAst,
+  sourceFile: SourceFile,
+): ResolvedAttribute {
+  return {
+    name: attributeName(attribute.name()),
+    args: readResolvedArgList(attribute.argList(), sourceFile),
+    span: nodePslSpan(attribute.syntax, sourceFile),
+  };
+}
+
+export function readResolvedAttributes(
+  attributes: Iterable<FieldAttributeAst | ModelAttributeAst>,
+  sourceFile: SourceFile,
+): readonly ResolvedAttribute[] {
+  return Array.from(attributes, (attribute) => readResolvedAttribute(attribute, sourceFile));
+}
+
+export function readResolvedConstructorCall(
+  annotation: TypeAnnotationAst | undefined,
+  sourceFile: SourceFile,
+): ResolvedTypeConstructorCall | undefined {
+  const argList = annotation?.argList();
+  if (annotation === undefined || argList === undefined) return undefined;
+  return {
+    path: annotation.name()?.path() ?? [],
+    args: readResolvedArgList(argList, sourceFile),
+    span: nodePslSpan(annotation.syntax, sourceFile),
+  };
+}
+
+function readResolvedArgList(
+  argList: AttributeArgListAst | undefined,
+  sourceFile: SourceFile,
+): readonly ResolvedAttributeArg[] {
+  if (argList === undefined) return [];
+  const args: ResolvedAttributeArg[] = [];
+  for (const arg of argList.args()) {
+    const name = arg.name()?.name();
+    const expression = arg.value();
+    args.push({
+      kind: name !== undefined ? 'named' : 'positional',
+      ...(name !== undefined ? { name } : {}),
+      value: renderExpression(expression),
+      ...(expression !== undefined ? { expression } : {}),
+      span: nodePslSpan(arg.syntax, sourceFile),
+    });
+  }
+  return args;
+}
+
+function attributeName(name: QualifiedNameAst | undefined): string {
+  return name?.path().join('.') ?? '';
+}
+
+function renderExpression(expression: ExpressionAst | undefined): string {
+  if (expression === undefined) return '';
+  return printSyntax(expression.syntax).trim();
+}
+
+export function nodePslSpan(node: SyntaxNode, sourceFile: SourceFile): PslSpan {
+  const start = node.offset;
+  const end = start + node.green.textLength;
+  return {
+    start: offsetToPslPosition(start, sourceFile),
+    end: offsetToPslPosition(end, sourceFile),
+  };
+}
+
+/** Unsupported-top-level-block diagnostics are anchored to the keyword token. */
+export function keywordPslSpan(node: SyntaxNode, keyword: string, sourceFile: SourceFile): PslSpan {
+  const start = node.offset;
+  const end = start + keyword.length;
+  return {
+    start: offsetToPslPosition(start, sourceFile),
+    end: offsetToPslPosition(end, sourceFile),
+  };
+}
+
+export function rangeToPslSpan(range: Range, sourceFile: SourceFile): PslSpan {
+  return {
+    start: offsetToPslPosition(sourceFile.offsetAt(range.start), sourceFile),
+    end: offsetToPslPosition(sourceFile.offsetAt(range.end), sourceFile),
+  };
+}
+
+function offsetToPslPosition(offset: number, sourceFile: SourceFile): PslSpan['start'] {
+  const position: Position = sourceFile.positionAt(offset);
+  return { offset, line: position.line + 1, column: position.character + 1 };
+}

package/src/source-file.ts

@@ -1,3 +1,4 @@
+const CARRIAGE_RETURN = 13;
 const LINE_FEED = 10;
 
 export interface Position {
@@ -41,6 +42,30 @@ export class SourceFile {
     return this.#lineStarts;
   }
 
+  lineStartOffset(line: number): number {
+    if (line <= 0) {
+      return 0;
+    }
+    return this.#lineStarts[line] ?? this.#text.length;
+  }
+
+  lineEndOffset(line: number): number {
+    if (line < 0) {
+      return 0;
+    }
+
+    const nextLineStart = this.#lineStarts[line + 1];
+    if (nextLineStart === undefined) {
+      return this.#text.length;
+    }
+
+    const lineFeedOffset = nextLineStart - 1;
+    const carriageReturnOffset = lineFeedOffset - 1;
+    return this.#text.charCodeAt(carriageReturnOffset) === CARRIAGE_RETURN
+      ? carriageReturnOffset
+      : lineFeedOffset;
+  }
+
   positionAt(offset: number): Position {
     const clamped = clamp(offset, 0, this.#text.length);
     const line = this.#lineIndexAt(clamped);