@prisma-next/psl-parser 0.14.0-dev.3 → 0.14.0-dev.30

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@prisma-next/psl-parser",
-  "version": "0.14.0-dev.3",
+  "version": "0.14.0-dev.30",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Reusable parser for Prisma Schema Language (PSL)",
   "dependencies": {
-    "@prisma-next/framework-components": "0.14.0-dev.3",
-    "@prisma-next/utils": "0.14.0-dev.3"
+    "@prisma-next/framework-components": "0.14.0-dev.30",
+    "@prisma-next/utils": "0.14.0-dev.30"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.14.0-dev.3",
-    "@prisma-next/tsdown": "0.14.0-dev.3",
+    "@prisma-next/tsconfig": "0.14.0-dev.30",
+    "@prisma-next/tsdown": "0.14.0-dev.30",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"
@@ -31,7 +31,7 @@
   "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
-    "./parser": "./dist/parser.mjs",
+    "./format": "./dist/format.mjs",
     "./syntax": "./dist/syntax.mjs",
     "./tokenizer": "./dist/tokenizer.mjs",
     "./package.json": "./package.json"

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/format.ts

@@ -0,0 +1,3 @@
+export { PslFormatError } from '../format/error';
+export { format } from '../format/format';
+export type { FormatOptions } from '../format/options';

package/src/exports/index.ts

@@ -1,6 +1,4 @@
 export type {
-  ParsePslDocumentInput,
-  ParsePslDocumentResult,
   PslAttribute,
   PslAttributeArgument,
   PslAttributeNamedArgument,
@@ -38,4 +36,30 @@ export {
   namespacePslExtensionBlocks,
 } from '@prisma-next/framework-components/psl-ast';
 export { getPositionalArgument, parseQuotedStringLiteral } from '../attribute-helpers';
-export { parsePslDocument } from '../parser';
+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,

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;
+}