TML-2946: Add PSL type and generic block completions

apps/lsp-playground/README.md

@@ -41,8 +41,8 @@ Monaco editor + VS Code API shim  --LSP/WebSocket-->  ws bridge  --spawn+stdio--
 ```
 
 - `src/bridge.ts` — `ws` + `vscode-ws-jsonrpc/server` (`createServerProcess` + `forward`), adapted from the TypeFox example (MIT). Each browser WebSocket connection spawns `node <built-cli> lsp --stdio` and forwards JSON-RPC between the browser and the language server process.
-- `src/cli.ts` — arg parsing, config resolution, runtime module generation, and startup for the shared HTTP server that hosts Vite plus the LSP WebSocket bridge.
-- `src/client/main.ts` — Monaco editor setup via `EditorApp`, VS Code API service overrides, and `LanguageClientWrapper` startup for the `prisma` language id.
+- `src/cli.ts` — arg parsing, config resolution, startup for the shared HTTP server that hosts Vite plus the LSP WebSocket bridge, and serving launch-time client config as same-origin JSON at `/__psl_playground_runtime.json` without rewriting tracked source files.
+- `src/client/main.ts` — Monaco editor setup via `EditorApp`, VS Code API service overrides, runtime config fetch/validation, and `LanguageClientWrapper` startup for the `prisma` language id.
 
 ## Semantic tokens
 

apps/lsp-playground/src/cli.ts

@@ -11,6 +11,27 @@ import { findNearestConfig } from './find-config';
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const PORT = 5295;
 const LSP_PATH = '/psl';
+const RUNTIME_CONFIG_PATH = '/__psl_playground_runtime.json';
+const REQUEST_URL_BASE = 'http://localhost/';
+
+interface RuntimeConfig {
+  readonly wsPath: string;
+  readonly documentUri: string;
+  readonly rootUri: string;
+  readonly schemaPath: string;
+  readonly schemaText: string;
+}
+
+function requestPathname(requestUrl: string | undefined): string | undefined {
+  if (requestUrl === undefined) {
+    return undefined;
+  }
+  try {
+    return new URL(requestUrl, REQUEST_URL_BASE).pathname;
+  } catch {
+    return undefined;
+  }
+}
 
 async function fileExists(path: string): Promise<boolean> {
   try {
@@ -132,22 +153,13 @@ async function main(): Promise<void> {
   const documentUri = pathToFileURL(schemaPath).toString();
   const rootUri = pathToFileURL(dirname(configPath)).toString();
 
-  // Hand the browser client its runtime values via a generated module (rather
-  // than Vite `define`, whose bare-identifier substitution is unreliable in the
-  // programmatic dev-server path). The WS URL is relative so the editor and the
-  // LSP bridge share this single origin/port.
-  const runtimeModule = resolve(PACKAGE_ROOT, 'src/client/runtime.ts');
-  await writeFile(
-    runtimeModule,
-    `// Generated by psl-playground at launch. Do not edit.
-export const wsPath = ${JSON.stringify(LSP_PATH)};
-export const documentUri = ${JSON.stringify(documentUri)};
-export const rootUri = ${JSON.stringify(rootUri)};
-export const schemaPath = ${JSON.stringify(schemaPath)};
-export const schemaText = ${JSON.stringify(schemaText)};
-`,
-    'utf8',
-  );
+  const runtimeConfig: RuntimeConfig = {
+    wsPath: LSP_PATH,
+    documentUri,
+    rootUri,
+    schemaPath,
+    schemaText,
+  };
 
   // One HTTP server hosts both the editor (Vite, in middleware mode) and the
   // LSP WebSocket bridge (on LSP_PATH). Vite's HMR WebSocket is bound to the
@@ -192,7 +204,44 @@ export const schemaText = ${JSON.stringify(schemaText)};
       })(),
     },
   });
-  httpServer.on('request', viteServer.middlewares);
+  httpServer.on(
+    'request',
+    (request: nodeHttp.IncomingMessage, response: nodeHttp.ServerResponse) => {
+      const requestPath = requestPathname(request.url);
+      if (requestPath === undefined) {
+        response.statusCode = 400;
+        response.end('Bad Request');
+        return;
+      }
+      if (requestPath === RUNTIME_CONFIG_PATH) {
+        if (request.method !== 'GET' && request.method !== 'HEAD') {
+          response.statusCode = 405;
+          response.setHeader('allow', 'GET, HEAD');
+          response.end('Method Not Allowed');
+          return;
+        }
+        response.statusCode = 200;
+        response.setHeader('content-type', 'application/json; charset=utf-8');
+        response.setHeader('cache-control', 'no-store');
+        response.end(request.method === 'HEAD' ? undefined : JSON.stringify(runtimeConfig));
+        return;
+      }
+
+      viteServer.middlewares(request, response, (error?: unknown) => {
+        if (response.writableEnded) {
+          return;
+        }
+        if (error !== undefined) {
+          console.error(error);
+          response.statusCode = 500;
+          response.end('Internal Server Error');
+          return;
+        }
+        response.statusCode = 404;
+        response.end('Not Found');
+      });
+    },
+  );
 
   const stopBridge = attachBridge(httpServer, { cliEntry, path: LSP_PATH });
 

apps/lsp-playground/src/client/main.ts

@@ -20,9 +20,9 @@ import {
 } from 'monaco-languageclient/vscodeApiWrapper';
 import { defineDefaultWorkerLoaders, useWorkerFactory } from 'monaco-languageclient/workerFactory';
 import * as vscode from 'vscode';
-import { documentUri, rootUri, schemaPath, schemaText, wsPath } from './runtime';
 
 const LANGUAGE_ID = 'prisma';
+const RUNTIME_CONFIG_PATH = '/__psl_playground_runtime.json';
 
 const pslSemanticThemeExtension = {
   name: 'prisma-psl-semantic-theme-bridge',
@@ -52,9 +52,41 @@ const pslSemanticThemeExtension = {
 
 registerExtension(pslSemanticThemeExtension, undefined, { system: true });
 
-const pathEl = document.getElementById('schema-path');
-if (pathEl !== null) {
-  pathEl.textContent = schemaPath;
+interface RuntimeConfig {
+  readonly wsPath: string;
+  readonly documentUri: string;
+  readonly rootUri: string;
+  readonly schemaPath: string;
+  readonly schemaText: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isRuntimeConfig(value: unknown): value is RuntimeConfig {
+  return (
+    isRecord(value) &&
+    typeof value['wsPath'] === 'string' &&
+    typeof value['documentUri'] === 'string' &&
+    typeof value['rootUri'] === 'string' &&
+    typeof value['schemaPath'] === 'string' &&
+    typeof value['schemaText'] === 'string'
+  );
+}
+
+async function loadRuntimeConfig(): Promise<RuntimeConfig> {
+  const response = await fetch(RUNTIME_CONFIG_PATH, { cache: 'no-store' });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to load playground runtime config: ${response.status} ${response.statusText}`,
+    );
+  }
+  const value: unknown = await response.json();
+  if (!isRuntimeConfig(value)) {
+    throw new Error('Invalid playground runtime config');
+  }
+  return value;
 }
 
 function configureWorkerFactory(logger?: ILogger): void {
@@ -64,13 +96,20 @@ function configureWorkerFactory(logger?: ILogger): void {
   useWorkerFactory(config);
 }
 
-function buildWebSocketUrl(): string {
+function buildWebSocketUrl(wsPath: string): string {
   const host = `${window.location.host}${wsPath}`;
   // nosemgrep: javascript.lang.security.detect-insecure-websocket.detect-insecure-websocket
   return window.location.protocol === 'https:' ? `wss://${host}` : `ws://${host}`;
 }
 
 async function main(): Promise<void> {
+  const runtimeConfig = await loadRuntimeConfig();
+
+  const pathEl = document.getElementById('schema-path');
+  if (pathEl !== null) {
+    pathEl.textContent = runtimeConfig.schemaPath;
+  }
+
   const htmlContainer = document.getElementById('editor');
   if (htmlContainer === null) {
     throw new Error('#editor mount point not found');
@@ -81,9 +120,9 @@ async function main(): Promise<void> {
     throw new Error('#format-document button not found');
   }
 
-  const fileUri = vscode.Uri.parse(documentUri);
+  const fileUri = vscode.Uri.parse(runtimeConfig.documentUri);
   const fileSystemProvider = new RegisteredFileSystemProvider(false);
-  fileSystemProvider.registerFile(new RegisteredMemoryFile(fileUri, schemaText));
+  fileSystemProvider.registerFile(new RegisteredMemoryFile(fileUri, runtimeConfig.schemaText));
   registerFileSystemOverlay(1, fileSystemProvider);
 
   const vscodeApiConfig: MonacoVscodeApiConfig = {
@@ -111,7 +150,7 @@ async function main(): Promise<void> {
     },
   };
 
-  const wsUrl = buildWebSocketUrl();
+  const wsUrl = buildWebSocketUrl(runtimeConfig.wsPath);
   const languageClientConfig: LanguageClientConfig = {
     languageId: LANGUAGE_ID,
     connection: {
@@ -133,15 +172,15 @@ async function main(): Promise<void> {
       workspaceFolder: {
         index: 0,
         name: 'workspace',
-        uri: vscode.Uri.parse(rootUri),
+        uri: vscode.Uri.parse(runtimeConfig.rootUri),
       },
     },
   };
 
   const editorAppConfig: EditorAppConfig = {
     codeResources: {
       modified: {
-        text: schemaText,
+        text: runtimeConfig.schemaText,
         uri: fileUri.path,
       },
     },

packages/1-framework/2-authoring/psl-parser/src/exports/syntax.ts

@@ -41,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';

packages/1-framework/2-authoring/psl-parser/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;

packages/1-framework/2-authoring/psl-parser/src/syntax/ast-helpers.ts

@@ -5,6 +5,11 @@ export interface AstNode {
   readonly syntax: SyntaxNode;
 }
 
+export interface BracedBlock extends AstNode {
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+}
+
 export function findChildToken(node: SyntaxNode, kind: TokenKind): SyntaxToken | undefined {
   for (const child of node.children()) {
     if (!(child instanceof SyntaxNode) && child.kind === kind) {
@@ -35,6 +40,25 @@ export function* filterChildren<T>(
   }
 }
 
+type CastTarget<C> = C extends (node: SyntaxNode) => infer R ? Exclude<R, undefined> : never;
+
+export function any<Casts extends readonly ((node: SyntaxNode) => unknown)[]>(
+  ...casts: Casts
+): (node: SyntaxNode) => CastTarget<Casts[number]> | undefined;
+export function any(
+  ...casts: ReadonlyArray<(node: SyntaxNode) => unknown>
+): (node: SyntaxNode) => unknown {
+  return (node) => {
+    for (const cast of casts) {
+      const result = cast(node);
+      if (result !== undefined) {
+        return result;
+      }
+    }
+    return undefined;
+  };
+}
+
 /**
  * Raw source text of a CST node, verbatim (quotes and brackets preserved). For
  * the decoded value of a string literal, decode it instead.