@prisma-next/psl-parser 0.13.0 → 0.14.0-dev.10

package/src/exports/syntax.ts

@@ -1,3 +1,7 @@
+export type { ParseDiagnostic, ParseResult } from '../parse';
+export { parse } from '../parse';
+export type { Position, Range } from '../source-file';
+export { SourceFile } from '../source-file';
 export {
   AttributeArgListAst,
   FieldAttributeAst,
@@ -5,12 +9,10 @@ export {
 } from '../syntax/ast/attributes';
 export type { NamespaceMemberAst } from '../syntax/ast/declarations';
 export {
-  BlockDeclarationAst,
   CompositeTypeDeclarationAst,
   DocumentAst,
-  EnumDeclarationAst,
-  EnumValueDeclarationAst,
   FieldDeclarationAst,
+  GenericBlockDeclarationAst,
   KeyValuePairAst,
   ModelDeclarationAst,
   NamedTypeDeclarationAst,
@@ -25,13 +27,16 @@ export {
   castExpression,
   FunctionCallAst,
   NumberLiteralExprAst,
+  ObjectFieldAst,
+  ObjectLiteralExprAst,
   StringLiteralExprAst,
 } from '../syntax/ast/expressions';
 // AST wrappers
 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 } from '../syntax/ast-helpers';
+export { 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';

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