@prisma-next/psl-parser 0.14.0 → 0.15.0-dev.1

package/src/format/error.ts

@@ -0,0 +1,13 @@
+import type { ParseDiagnostic } from '../parse';
+
+export class PslFormatError extends Error {
+  readonly diagnostics: readonly ParseDiagnostic[];
+
+  constructor(diagnostics: readonly ParseDiagnostic[]) {
+    const summary = diagnostics[0]?.message ?? 'unknown parse error';
+    const more = diagnostics.length > 1 ? ` (and ${diagnostics.length - 1} more)` : '';
+    super(`Cannot format PSL with parse errors: ${summary}${more}`);
+    this.name = 'PslFormatError';
+    this.diagnostics = diagnostics;
+  }
+}

package/src/format/format.ts

@@ -0,0 +1,13 @@
+import { parse } from '../parse';
+import { emitDocument } from './emit';
+import { PslFormatError } from './error';
+import { type FormatOptions, resolveFormatOptions } from './options';
+
+export function format(source: string, options?: FormatOptions): string {
+  const resolved = resolveFormatOptions(options);
+  const { document, diagnostics } = parse(source);
+  if (diagnostics.length > 0) {
+    throw new PslFormatError(diagnostics);
+  }
+  return emitDocument(document, resolved.indentUnit, resolved.newline);
+}

package/src/format/options.ts

@@ -0,0 +1,28 @@
+export interface FormatOptions {
+  readonly indent?: number | 'tab';
+  readonly newline?: 'LF' | 'CRLF';
+}
+
+export interface ResolvedFormatOptions {
+  readonly indentUnit: string;
+  readonly newline: string;
+}
+
+export function resolveFormatOptions(options: FormatOptions | undefined): ResolvedFormatOptions {
+  const indent = options?.indent ?? 2;
+  if (indent !== 'tab' && (typeof indent !== 'number' || !Number.isInteger(indent) || indent < 1)) {
+    throw new TypeError(
+      `Invalid format options: indent must be a positive integer or 'tab', got ${String(indent)}`,
+    );
+  }
+  const newline = options?.newline ?? 'LF';
+  if (newline !== 'LF' && newline !== 'CRLF') {
+    throw new TypeError(
+      `Invalid format options: newline must be 'LF' or 'CRLF', got ${String(newline)}`,
+    );
+  }
+  return {
+    indentUnit: indent === 'tab' ? '\t' : ' '.repeat(indent),
+    newline: newline === 'CRLF' ? '\r\n' : '\n',
+  };
+}

package/src/interpret.ts

@@ -0,0 +1,67 @@
+import type {
+  ContractSourceContext,
+  ContractSourceDiagnostic,
+  ContractSourceDiagnostics,
+  ContractSourceProvider,
+  PslContractSourceProvider,
+} from '@prisma-next/config/config-types';
+import type { Contract } from '@prisma-next/contract/types';
+import { notOk, type Result } from '@prisma-next/utils/result';
+import type { SourceFile } from './source-file';
+import type { SymbolTable } from './symbol-table';
+import type { DocumentAst } from './syntax/ast/declarations';
+
+/**
+ * Lets editor tooling that already parses incrementally (e.g. the language
+ * server) hand cached artifacts to the interpreter instead of forcing a
+ * disk re-parse.
+ */
+export interface PslInterpretInput {
+  readonly document: DocumentAst;
+  readonly sourceFile: SourceFile;
+  readonly symbolTable: SymbolTable;
+  readonly sourceId: string;
+}
+
+/**
+ * Declared here — the authoring layer that owns `DocumentAst` / `SourceFile` /
+ * `SymbolTable` — because `@prisma-next/config` (core) cannot name authoring
+ * types. `interpret` must not read disk or `context.resolvedInputs` — those
+ * are load-path concerns.
+ */
+export interface PslInterpretCapable extends PslContractSourceProvider {
+  interpret(
+    input: PslInterpretInput,
+    context: ContractSourceContext,
+  ): Result<Contract, ContractSourceDiagnostics>;
+}
+
+/**
+ * Merges caller-side diagnostics (e.g. parse / symbol-table findings) into an
+ * interpretation result. The authored headline is deliberately uniform — it
+ * reports how many errors the schema has, never which pipeline stage found
+ * them.
+ */
+export function withSeedDiagnostics(
+  result: Result<Contract, ContractSourceDiagnostics>,
+  seedDiagnostics: readonly ContractSourceDiagnostic[],
+): Result<Contract, ContractSourceDiagnostics> {
+  if (seedDiagnostics.length === 0) {
+    return result;
+  }
+  const diagnostics = result.ok
+    ? seedDiagnostics
+    : [...seedDiagnostics, ...result.failure.diagnostics];
+  return notOk({
+    summary: `Schema has ${diagnostics.length} error${diagnostics.length === 1 ? '' : 's'}`,
+    diagnostics,
+    ...(result.ok || result.failure.meta === undefined ? {} : { meta: result.failure.meta }),
+  });
+}
+
+/** The single seam that narrows a contract source to the interpret capability. */
+export function hasPslInterpreter(source: ContractSourceProvider): source is PslInterpretCapable {
+  return (
+    source.sourceFormat === 'psl' && 'interpret' in source && typeof source.interpret === 'function'
+  );
+}

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;
@@ -693,7 +711,16 @@ function invalidMember(cursor: Cursor, code: PslDiagnosticCode, message: string)
 export function parseField(cursor: Cursor): GreenNode | undefined {
   if (cursor.peekKind() !== 'Ident') return undefined;
   cursor.startNode('FieldDeclaration');
+  const nameMark = cursor.mark();
+  const nameText = cursor.peekToken().text;
   parseIdentifier(cursor);
+  if (cursor.peekKind() !== 'Ident') {
+    cursor.diagnostic(
+      'PSL_INVALID_MODEL_MEMBER',
+      `Expected a type after field "${nameText}"`,
+      nameMark,
+    );
+  }
   parseTypeAnnotation(cursor);
   while (cursor.peekKind() === 'At') {
     parseAttribute(cursor);

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);