@prisma-next/psl-parser 0.13.0 → 0.14.0

package/src/syntax/ast/declarations.ts

@@ -9,23 +9,20 @@ import { IdentifierAst } from './identifier';
 import { TypeAnnotationAst } from './type-annotation';
 
 /**
- * What may appear inside a `namespace` block: models, enums, composite types,
- * and extension (block) declarations. Mirrors what `parsePslDocument` accepts
- * in a namespace body. `types {}` blocks and nested `namespace` blocks are
- * document-only, so they are not namespace members.
+ * What may appear inside a `namespace` block: models, composite types, and
+ * extension (block) declarations. `types {}` blocks and nested `namespace`
+ * blocks are document-only, so they are not namespace members.
  */
 export type NamespaceMemberAst =
   | ModelDeclarationAst
-  | EnumDeclarationAst
   | CompositeTypeDeclarationAst
-  | BlockDeclarationAst;
+  | GenericBlockDeclarationAst;
 
 function castNamespaceMember(node: SyntaxNode): NamespaceMemberAst | undefined {
   return (
     ModelDeclarationAst.cast(node) ??
-    EnumDeclarationAst.cast(node) ??
     CompositeTypeDeclarationAst.cast(node) ??
-    BlockDeclarationAst.cast(node)
+    GenericBlockDeclarationAst.cast(node)
   );
 }
 
@@ -85,42 +82,6 @@ export class ModelDeclarationAst implements AstNode {
   }
 }
 
-export class EnumDeclarationAst implements AstNode {
-  readonly syntax: SyntaxNode;
-
-  constructor(syntax: SyntaxNode) {
-    this.syntax = syntax;
-  }
-
-  keyword(): Token | undefined {
-    return findChildToken(this.syntax, 'Ident');
-  }
-
-  name(): IdentifierAst | undefined {
-    return findFirstChild(this.syntax, IdentifierAst.cast);
-  }
-
-  lbrace(): Token | undefined {
-    return findChildToken(this.syntax, 'LBrace');
-  }
-
-  rbrace(): Token | undefined {
-    return findChildToken(this.syntax, 'RBrace');
-  }
-
-  *values(): Iterable<EnumValueDeclarationAst> {
-    yield* filterChildren(this.syntax, EnumValueDeclarationAst.cast);
-  }
-
-  *attributes(): Iterable<ModelAttributeAst> {
-    yield* filterChildren(this.syntax, ModelAttributeAst.cast);
-  }
-
-  static cast(node: SyntaxNode): EnumDeclarationAst | undefined {
-    return node.kind === 'EnumDeclaration' ? new EnumDeclarationAst(node) : undefined;
-  }
-}
-
 export class CompositeTypeDeclarationAst implements AstNode {
   readonly syntax: SyntaxNode;
 
@@ -219,7 +180,7 @@ export class TypesBlockAst implements AstNode {
   }
 }
 
-export class BlockDeclarationAst implements AstNode {
+export class GenericBlockDeclarationAst implements AstNode {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
@@ -246,8 +207,14 @@ export class BlockDeclarationAst implements AstNode {
     yield* filterChildren(this.syntax, KeyValuePairAst.cast);
   }
 
-  static cast(node: SyntaxNode): BlockDeclarationAst | undefined {
-    return node.kind === 'BlockDeclaration' ? new BlockDeclarationAst(node) : undefined;
+  *attributes(): Iterable<ModelAttributeAst> {
+    yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): GenericBlockDeclarationAst | undefined {
+    return node.kind === 'GenericBlockDeclaration'
+      ? new GenericBlockDeclarationAst(node)
+      : undefined;
   }
 }
 
@@ -310,26 +277,6 @@ export class FieldDeclarationAst implements AstNode {
   }
 }
 
-export class EnumValueDeclarationAst implements AstNode {
-  readonly syntax: SyntaxNode;
-
-  constructor(syntax: SyntaxNode) {
-    this.syntax = syntax;
-  }
-
-  name(): IdentifierAst | undefined {
-    return findFirstChild(this.syntax, IdentifierAst.cast);
-  }
-
-  *attributes(): Iterable<FieldAttributeAst> {
-    yield* filterChildren(this.syntax, FieldAttributeAst.cast);
-  }
-
-  static cast(node: SyntaxNode): EnumValueDeclarationAst | undefined {
-    return node.kind === 'EnumValueDeclaration' ? new EnumValueDeclarationAst(node) : undefined;
-  }
-}
-
 export class NamedTypeDeclarationAst implements AstNode {
   readonly syntax: SyntaxNode;
 

package/src/syntax/ast/expressions.ts

@@ -3,6 +3,7 @@ import type { AstNode } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
 import { SyntaxNode } from '../red';
 import { IdentifierAst } from './identifier';
+import { QualifiedNameAst } from './qualified-name';
 
 export class FunctionCallAst implements AstNode {
   readonly syntax: SyntaxNode;
@@ -11,8 +12,24 @@ export class FunctionCallAst implements AstNode {
     this.syntax = syntax;
   }
 
-  name(): IdentifierAst | undefined {
-    return findFirstChild(this.syntax, IdentifierAst.cast);
+  /** The qualified-name callee, or `undefined` when identifier segments sit directly under the node. */
+  name(): QualifiedNameAst | undefined {
+    return findFirstChild(this.syntax, QualifiedNameAst.cast);
+  }
+
+  /**
+   * The dotted call path, in source order. A bare `Vector(…)` yields
+   * `['Vector']`; a namespace-qualified `pgvector.Vector(…)` yields
+   * `['pgvector', 'Vector']`. Empty when the call carries no identifier.
+   */
+  path(): readonly string[] {
+    const qualified = this.name();
+    const segments: string[] = [];
+    for (const segment of filterChildren(qualified?.syntax ?? this.syntax, IdentifierAst.cast)) {
+      const text = segment.token()?.text;
+      if (text !== undefined) segments.push(text);
+    }
+    return segments;
   }
 
   lparen(): Token | undefined {
@@ -56,6 +73,82 @@ export class ArrayLiteralAst implements AstNode {
   }
 }
 
+const HEX = /^[0-9a-fA-F]+$/;
+
+function decodeFixedHex(raw: string, start: number, width: number): string | undefined {
+  if (start + width > raw.length) return undefined;
+  const hex = raw.slice(start, start + width);
+  if (!HEX.test(hex)) return undefined;
+  return String.fromCharCode(Number.parseInt(hex, 16));
+}
+
+function decodeStringLiteral(raw: string): string {
+  let out = '';
+  let i = 0;
+  while (i < raw.length) {
+    const ch = raw.charAt(i);
+    if (ch !== '\\' || i + 1 >= raw.length) {
+      out += ch;
+      i++;
+      continue;
+    }
+    const next = raw.charAt(i + 1);
+    switch (next) {
+      case 'n':
+        out += '\n';
+        i += 2;
+        continue;
+      case 'r':
+        out += '\r';
+        i += 2;
+        continue;
+      case 't':
+        out += '\t';
+        i += 2;
+        continue;
+      case '"':
+        out += '"';
+        i += 2;
+        continue;
+      case "'":
+        out += "'";
+        i += 2;
+        continue;
+      case '\\':
+        out += '\\';
+        i += 2;
+        continue;
+      case 'x': {
+        const decoded = decodeFixedHex(raw, i + 2, 2);
+        if (decoded === undefined) {
+          out += '\\x';
+          i += 2;
+          continue;
+        }
+        out += decoded;
+        i += 4;
+        continue;
+      }
+      case 'u': {
+        const decoded = decodeFixedHex(raw, i + 2, 4);
+        if (decoded === undefined) {
+          out += '\\u';
+          i += 2;
+          continue;
+        }
+        out += decoded;
+        i += 6;
+        continue;
+      }
+      default:
+        out += `\\${next}`;
+        i += 2;
+        continue;
+    }
+  }
+  return out;
+}
+
 export class StringLiteralExprAst implements AstNode {
   readonly syntax: SyntaxNode;
 
@@ -70,23 +163,7 @@ export class StringLiteralExprAst implements AstNode {
   value(): string | undefined {
     const tok = this.token();
     if (!tok) return undefined;
-    const raw = tok.text.slice(1, -1);
-    return raw.replace(/\\(.)/g, (_match, char: string) => {
-      switch (char) {
-        case 'n':
-          return '\n';
-        case 'r':
-          return '\r';
-        case 't':
-          return '\t';
-        case '"':
-          return '"';
-        case '\\':
-          return '\\';
-        default:
-          return `\\${char}`;
-      }
-    });
+    return decodeStringLiteral(tok.text.slice(1, -1));
   }
 
   static cast(node: SyntaxNode): StringLiteralExprAst | undefined {
@@ -140,12 +217,102 @@ export class BooleanLiteralExprAst implements AstNode {
   }
 }
 
+export class ObjectLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *fields(): Iterable<ObjectFieldAst> {
+    yield* filterChildren(this.syntax, ObjectFieldAst.cast);
+  }
+
+  static cast(node: SyntaxNode): ObjectLiteralExprAst | undefined {
+    return node.kind === 'ObjectLiteralExpr' ? new ObjectLiteralExprAst(node) : undefined;
+  }
+}
+
+export class ObjectFieldAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  key(): IdentifierAst | undefined {
+    for (const child of this.syntax.children()) {
+      if (!(child instanceof SyntaxNode)) {
+        if (child.kind === 'Colon') break;
+        continue;
+      }
+      return IdentifierAst.cast(child);
+    }
+    return undefined;
+  }
+
+  /**
+   * The field's logical key name, unquoted. An identifier key (`length:`) yields
+   * its text; a string-literal key (`"length":`) yields the decoded string.
+   * `undefined` when the field carries no key node.
+   */
+  keyName(): string | undefined {
+    for (const child of this.syntax.children()) {
+      if (!(child instanceof SyntaxNode)) {
+        if (child.kind === 'Colon') break;
+        continue;
+      }
+      const identifier = IdentifierAst.cast(child);
+      if (identifier) return identifier.token()?.text;
+      const stringKey = StringLiteralExprAst.cast(child);
+      if (stringKey) return stringKey.value();
+      return undefined;
+    }
+    return undefined;
+  }
+
+  colon(): Token | undefined {
+    return findChildToken(this.syntax, 'Colon');
+  }
+
+  value(): ExpressionAst | undefined {
+    if (this.colon()) {
+      let pastColon = false;
+      for (const child of this.syntax.children()) {
+        if (!(child instanceof SyntaxNode)) {
+          if (child.kind === 'Colon') pastColon = true;
+          continue;
+        }
+        if (pastColon) {
+          const expr = castExpression(child);
+          if (expr) return expr;
+        }
+      }
+      return undefined;
+    }
+    return findFirstChild(this.syntax, castExpression);
+  }
+
+  static cast(node: SyntaxNode): ObjectFieldAst | undefined {
+    return node.kind === 'ObjectField' ? new ObjectFieldAst(node) : undefined;
+  }
+}
+
 export type ExpressionAst =
   | FunctionCallAst
   | ArrayLiteralAst
   | StringLiteralExprAst
   | NumberLiteralExprAst
   | BooleanLiteralExprAst
+  | ObjectLiteralExprAst
   | IdentifierAst;
 
 export function castExpression(node: SyntaxNode): ExpressionAst | undefined {
@@ -155,6 +322,7 @@ export function castExpression(node: SyntaxNode): ExpressionAst | undefined {
     StringLiteralExprAst.cast(node) ??
     NumberLiteralExprAst.cast(node) ??
     BooleanLiteralExprAst.cast(node) ??
+    ObjectLiteralExprAst.cast(node) ??
     IdentifierAst.cast(node)
   );
 }

package/src/syntax/ast/identifier.ts

@@ -14,6 +14,10 @@ export class IdentifierAst implements AstNode {
     return findChildToken(this.syntax, 'Ident');
   }
 
+  name(): string | undefined {
+    return this.token()?.text;
+  }
+
   static cast(node: SyntaxNode): IdentifierAst | undefined {
     return node.kind === 'Identifier' ? new IdentifierAst(node) : undefined;
   }

package/src/syntax/ast/qualified-name.ts

@@ -0,0 +1,87 @@
+import type { Token } from '../../tokenizer';
+import type { AstNode } from '../ast-helpers';
+import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
+import { SyntaxNode } from '../red';
+import { IdentifierAst } from './identifier';
+
+/** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
+export class QualifiedNameAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  #lastSegment(): IdentifierAst | undefined {
+    let last: IdentifierAst | undefined;
+    for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+      last = segment;
+    }
+    return last;
+  }
+
+  #penultimateSegment(): IdentifierAst | undefined {
+    let last: IdentifierAst | undefined;
+    let penultimate: IdentifierAst | undefined;
+    for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+      penultimate = last;
+      last = segment;
+    }
+    return penultimate;
+  }
+
+  #separatorCount(kind: 'Dot' | 'Colon'): number {
+    let count = 0;
+    for (const child of this.syntax.children()) {
+      if (!(child instanceof SyntaxNode) && child.kind === kind) count++;
+    }
+    return count;
+  }
+
+  colon(): Token | undefined {
+    return findChildToken(this.syntax, 'Colon');
+  }
+
+  dot(): Token | undefined {
+    return findChildToken(this.syntax, 'Dot');
+  }
+
+  space(): IdentifierAst | undefined {
+    if (!this.colon()) return undefined;
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  namespace(): IdentifierAst | undefined {
+    if (!this.dot()) return undefined;
+    return this.#penultimateSegment();
+  }
+
+  identifier(): IdentifierAst | undefined {
+    return this.#lastSegment();
+  }
+
+  /**
+   * Every identifier segment, in source order. A bare `Vector` yields
+   * `['Vector']`; a qualified `pgvector.Vector` yields `['pgvector', 'Vector']`.
+   */
+  path(): readonly string[] {
+    const segments: string[] = [];
+    for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+      const text = segment.token()?.text;
+      if (text !== undefined) segments.push(text);
+    }
+    return segments;
+  }
+
+  /**
+   * Flags a malformed name with more qualifier segments than allowed (a second
+   * `:`-space or a second `.`-namespace).
+   */
+  isOverQualified(): boolean {
+    return this.#separatorCount('Dot') > 1 || this.#separatorCount('Colon') > 1;
+  }
+
+  static cast(node: SyntaxNode): QualifiedNameAst | undefined {
+    return node.kind === 'QualifiedName' ? new QualifiedNameAst(node) : undefined;
+  }
+}

package/src/syntax/ast/type-annotation.ts

@@ -1,9 +1,9 @@
 import type { Token } from '../../tokenizer';
 import type { AstNode } from '../ast-helpers';
-import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
+import { findChildToken, findFirstChild } from '../ast-helpers';
 import type { SyntaxNode } from '../red';
-import { FunctionCallAst } from './expressions';
-import { IdentifierAst } from './identifier';
+import { AttributeArgListAst } from './attributes';
+import { QualifiedNameAst } from './qualified-name';
 
 export class TypeAnnotationAst implements AstNode {
   readonly syntax: SyntaxNode;
@@ -12,48 +12,18 @@ export class TypeAnnotationAst implements AstNode {
     this.syntax = syntax;
   }
 
-  #lastSegment(): IdentifierAst | undefined {
-    let last: IdentifierAst | undefined;
-    for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
-      last = segment;
-    }
-    return last;
+  /** The annotation's reference, doubling as the constructor callee when an {@link argList} follows. */
+  name(): QualifiedNameAst | undefined {
+    return findFirstChild(this.syntax, QualifiedNameAst.cast);
   }
 
-  #penultimateSegment(): IdentifierAst | undefined {
-    let last: IdentifierAst | undefined;
-    let penultimate: IdentifierAst | undefined;
-    for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
-      penultimate = last;
-      last = segment;
-    }
-    return penultimate;
+  /** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
+  argList(): AttributeArgListAst | undefined {
+    return findFirstChild(this.syntax, AttributeArgListAst.cast);
   }
 
-  name(): IdentifierAst | undefined {
-    return this.#lastSegment();
-  }
-
-  colon(): Token | undefined {
-    return findChildToken(this.syntax, 'Colon');
-  }
-
-  dot(): Token | undefined {
-    return findChildToken(this.syntax, 'Dot');
-  }
-
-  spaceName(): IdentifierAst | undefined {
-    if (!this.colon()) return undefined;
-    return findFirstChild(this.syntax, IdentifierAst.cast);
-  }
-
-  namespaceName(): IdentifierAst | undefined {
-    if (!this.dot()) return undefined;
-    return this.#penultimateSegment();
-  }
-
-  constructorCall(): FunctionCallAst | undefined {
-    return findFirstChild(this.syntax, FunctionCallAst.cast);
+  isConstructor(): boolean {
+    return this.argList() !== undefined;
   }
 
   lbracket(): Token | undefined {

package/src/syntax/ast-helpers.ts

@@ -34,3 +34,15 @@ export function* filterChildren<T>(
     if (result !== undefined) yield result;
   }
 }
+
+/**
+ * Raw source text of a CST node, verbatim (quotes and brackets preserved). For
+ * the decoded value of a string literal, decode it instead.
+ */
+export function printSyntax(node: SyntaxNode): string {
+  let text = '';
+  for (const token of node.tokens()) {
+    text += token.text;
+  }
+  return text;
+}

package/src/syntax/syntax-kind.ts

@@ -1,13 +1,13 @@
 export type SyntaxKind =
   | 'Document'
   | 'ModelDeclaration'
-  | 'EnumDeclaration'
   | 'CompositeTypeDeclaration'
   | 'Namespace'
   | 'TypesBlock'
-  | 'BlockDeclaration'
+  // The generic/extension block node: the `kw [name] { key = value }` form,
+  // distinct from the reserved `model`/`namespace`/`type`/`types` declarations.
+  | 'GenericBlockDeclaration'
   | 'FieldDeclaration'
-  | 'EnumValueDeclaration'
   | 'NamedTypeDeclaration'
   | 'KeyValuePair'
   | 'FieldAttribute'
@@ -16,8 +16,12 @@ export type SyntaxKind =
   | 'AttributeArg'
   | 'TypeAnnotation'
   | 'Identifier'
+  // A namespace-qualified name `[space ':']? Ident ('.' Ident)*`.
+  | 'QualifiedName'
   | 'FunctionCall'
   | 'ArrayLiteral'
   | 'StringLiteralExpr'
   | 'NumberLiteralExpr'
-  | 'BooleanLiteralExpr';
+  | 'BooleanLiteralExpr'
+  | 'ObjectLiteralExpr'
+  | 'ObjectField';

package/src/tokenizer.ts

@@ -86,6 +86,7 @@ function scan(source: string, pos: number): Token {
     scanWhitespace(source, pos) ??
     scanComment(source, pos) ??
     scanAt(source, pos) ??
+    scanKeywordNumber(source, pos) ??
     scanIdent(source, pos) ??
     scanNumber(source, pos) ??
     scanString(source, pos) ??
@@ -151,6 +152,20 @@ function scanIdent(source: string, pos: number): Token | undefined {
   return { kind: 'Ident', text: source.slice(pos, end) };
 }
 
+const KEYWORD_NUMBERS = ['-Infinity', 'Infinity', 'NaN'] as const;
+
+// `NaN`, `Infinity`, and `-Infinity` are numeric literals; they must match
+// before `scanIdent` and are word-bounded, so `Infinityx` stays an `Ident`.
+function scanKeywordNumber(source: string, pos: number): Token | undefined {
+  for (const word of KEYWORD_NUMBERS) {
+    if (!source.startsWith(word, pos)) continue;
+    const after = readChar(source, pos + word.length);
+    if (after !== '' && isIdentPart(after)) return undefined;
+    return { kind: 'NumberLiteral', text: word };
+  }
+  return undefined;
+}
+
 function scanNumber(source: string, pos: number): Token | undefined {
   let end = pos;
   if (source.charAt(end) === '-') {
@@ -164,7 +179,7 @@ function scanNumber(source: string, pos: number): Token | undefined {
     end++;
   }
   if (source.charAt(end) === '.' && end + 1 < source.length && isDigit(source.charAt(end + 1))) {
-    end++; // consume the dot
+    end++;
     while (end < source.length && isDigit(source.charAt(end))) {
       end++;
     }
@@ -173,28 +188,53 @@ function scanNumber(source: string, pos: number): Token | undefined {
 }
 
 function scanString(source: string, pos: number): Token | undefined {
-  if (source.charAt(pos) !== '"') return undefined;
+  const quote = source.charAt(pos);
+  if (quote !== '"' && quote !== "'") return undefined;
   let end = pos + 1;
   while (end < source.length) {
     const c = source.charAt(end);
     if (c === '\\' && end + 1 < source.length) {
-      end += 2; // skip escape sequence
+      end += 2;
       continue;
     }
-    if (c === '"') {
-      end++; // include closing quote
+    if (c === quote) {
+      end++;
       return { kind: 'StringLiteral', text: source.slice(pos, end) };
     }
     if (c === '\n' || c === '\r') {
-      // Unterminated: stop before newline
+      // Unterminated string: stop before the newline.
       return { kind: 'StringLiteral', text: source.slice(pos, end) };
     }
     end++;
   }
-  // Unterminated at EOF
   return { kind: 'StringLiteral', text: source.slice(pos, end) };
 }
 
+/**
+ * `scanString` emits the same `StringLiteral` kind for well-formed and
+ * unterminated strings, so callers ask here to tell them apart.
+ *
+ * The closing quote is unescaped iff an **even** number of backslashes precede
+ * it (each `\\` pair cancels; an odd run leaves the final `\` escaping the
+ * quote), so counting the trailing backslash run suffices — no full re-scan:
+ *
+ * - `"ok"`  → 0 backslashes (even) → terminated
+ * - `'a\'`  → 1 backslash  (odd)   → the quote is escaped → unterminated
+ * - `"a\\"` → 2 backslashes (even) → escaped `\`, real `"` → terminated
+ */
+export function isTerminatedStringLiteral(text: string): boolean {
+  const quote = text.charAt(0);
+  if (quote !== '"' && quote !== "'") return false;
+  if (text.length < 2 || text.charAt(text.length - 1) !== quote) {
+    return false;
+  }
+  let backslashes = 0;
+  for (let i = text.length - 2; i >= 1 && text.charAt(i) === '\\'; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 0;
+}
+
 function scanPunctuation(source: string, pos: number): Token | undefined {
   const kind = PUNCTUATION[source.charAt(pos)];
   if (kind === undefined) return undefined;