@hydranium/glsp-server 1.0.0-next.10

package/src/testing/make-noop-glsp-logger.ts

@@ -0,0 +1,66 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { type Logger as GlspLogger, NullLogger } from '@eclipse-glsp/server';
+
+/**
+ * No-op GLSP {@link GlspLogger} for tests — discards every message. GLSP's
+ * `Logger` is an abstract class declaring `logLevel` / `caller` alongside the
+ * emit methods, so an object literal never structurally satisfies it and each
+ * test otherwise writes `{ info, warn, error, debug } as unknown as Logger`.
+ * This returns GLSP's shipped {@link NullLogger}, so call sites fill a
+ * `GlspLogger` slot cast-free — the GLSP-server sibling of `makeNoopLogger`.
+ */
+export function makeNoopGlspLogger(): GlspLogger {
+   return new NullLogger();
+}
+
+/** GLSP emit level a {@link CapturedGlspLine} was recorded at. */
+export type GlspLogLevel = 'info' | 'warn' | 'error' | 'debug';
+
+/** A captured GLSP emission: level, rendered message, and trailing params. */
+export interface CapturedGlspLine {
+   readonly level: GlspLogLevel;
+   readonly message: string;
+   readonly params: readonly unknown[];
+}
+
+/** A GLSP {@link GlspLogger} whose emitted lines are captured for assertions. */
+export interface CapturingGlspLogger {
+   readonly logger: GlspLogger;
+   /** Every line emitted through the logger, in order. */
+   readonly lines: CapturedGlspLine[];
+}
+
+/**
+ * Capturing GLSP {@link GlspLogger} for tests that assert on emitted output
+ * (e.g. an error surfaced through the logger). Backed by a {@link NullLogger}
+ * subclass so it is a complete `Logger`; each emit records into
+ * {@link CapturingGlspLogger.lines}. Filter by `level` to assert on one tier —
+ * `lines.filter(line => line.level === 'error')`. Prefer this over hand-rolling
+ * an `{ error } as unknown as Logger` stub.
+ */
+export function makeCapturingGlspLogger(): CapturingGlspLogger {
+   const lines: CapturedGlspLine[] = [];
+   class Capturing extends NullLogger {
+      override info(message: string, ...params: unknown[]): void {
+         lines.push({ level: 'info', message, params });
+      }
+      override warn(message: string, ...params: unknown[]): void {
+         lines.push({ level: 'warn', message, params });
+      }
+      override error(message: string, ...params: unknown[]): void {
+         lines.push({ level: 'error', message, params });
+      }
+      override debug(message: string, ...params: unknown[]): void {
+         lines.push({ level: 'debug', message, params });
+      }
+   }
+   return { logger: new Capturing(), lines };
+}

package/src/util/index.ts

@@ -0,0 +1,10 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+export * from './service-identifier.js';

package/src/util/service-identifier.ts

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import type { interfaces } from 'inversify';
+
+/**
+ * Create an Inversify service identifier for type `T`.
+ *
+ * Returns a fresh Symbol cast to Inversify's typed
+ * {@link interfaces.ServiceIdentifier} shape. The cast is necessary
+ * because TypeScript cannot infer the generic parameter from a Symbol
+ * literal alone — Symbols carry no type information at the value level,
+ * so `bind` and `@inject` would receive `any` without it. The cast lets
+ * Inversify type-check the bound value at `bind(...).toConstantValue(x)`
+ * sites and infer the field type at `@inject(...)` declarations.
+ *
+ * **Why a Symbol + cast, not a class or string token.**
+ *
+ * - **Class-as-token** doesn't work for interface-typed services —
+ *   interfaces have no runtime value to bind against. Using a concrete
+ *   class as the token would force adopters to extend that specific
+ *   class rather than implement the interface.
+ * - **String tokens** carry cross-package collision risk; two packages
+ *   that independently bind the same name would clash in a shared
+ *   container.
+ * - **`Symbol.for(name)`** uses Node's cross-realm registry — that sharing
+ *   is rarely needed, and it makes module-reload behaviour a foot-gun.
+ *
+ * Fresh `Symbol(description)` per token is the right primitive; this
+ * helper centralises the cast so consumers don't repeat the
+ * `as interfaces.ServiceIdentifier<T>` boilerplate at every binding
+ * site declaration.
+ *
+ * Only the GLSP head uses Inversify, which is why this lives here; LSP /
+ * data-server / `@hydranium/core` use Langium's plain constructor-arg DI
+ * through the typed services tree, where binding tokens aren't needed. Adopters
+ * mint a token per service they expose to their `@injectable()` GLSP components;
+ * the framework's own are grouped in `HydraniumTypes` so token identity
+ * stays decoupled from the implementation class name.
+ */
+export function serviceIdentifier<T>(description: string): interfaces.ServiceIdentifier<T> {
+   return Symbol(description) as interfaces.ServiceIdentifier<T>;
+}

package/src/validation/diagnostic-markers.ts

@@ -0,0 +1,93 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { type Marker, MarkerKind } from '@eclipse-glsp/protocol';
+import { type AstNode } from '@hydranium/langium';
+import { Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types';
+import { type TransferLspDiagnostic } from '@hydranium/core';
+
+/**
+ * The model-shaped lookups the diagnostic→marker translation needs, injected so
+ * the pure mapping can be unit-tested without GLSP/Langium DI. The validator
+ * wires them to the live services.
+ */
+export interface DiagnosticMarkerLookups {
+   /**
+    * Resolve a diagnostic's `element` AST-path (as produced by
+    * `AstNodeLocator.getAstNodePath`) to its node in the current source root,
+    * or `undefined` if it no longer resolves.
+    */
+   resolveElement(elementPath: string): AstNode | undefined;
+   /**
+    * The GModel ids that currently render `node` on this diagram. Usually one,
+    * but a single AST element can be drawn as several nodes, and then every
+    * representing node is marked. Empty when `node` is not drawn here.
+    */
+   renderedIdsFor(node: AstNode): readonly string[];
+}
+
+/**
+ * Translate the current document's LSP diagnostics into GLSP {@link Marker}s
+ * for the diagram.
+ *
+ * Each diagnostic's `element` path is resolved to an AST node; if that node is
+ * not drawn on this diagram, the mapping walks up the `$container` chain to the
+ * nearest ancestor that is, and marks every GModel node representing it — so a
+ * deeply nested error still surfaces, on the innermost drawn container, at each
+ * of its occurrences. A diagnostic whose element — and every ancestor — is
+ * absent from this diagram is dropped: the model may span several diagrams, and
+ * the text editor / Problems view still report it.
+ *
+ * The full set is recomputed on every call; callers dispatch it under a single
+ * `MarkersReason` so a fresh `SetMarkersAction` replaces the previous markers
+ * (an empty result clears them when all errors are fixed).
+ */
+export function diagnosticsToMarkers(diagnostics: readonly TransferLspDiagnostic[], lookups: DiagnosticMarkerLookups): Marker[] {
+   const markers: Marker[] = [];
+   for (const diagnostic of diagnostics) {
+      const kind = markerKind(diagnostic.severity);
+      // LSP 3.18 allows a `MarkupContent` message; GLSP markers are plain text.
+      const message = Diagnostic.getMessageString(diagnostic);
+      for (const elementId of renderedElementIds(diagnostic.element, lookups)) {
+         markers.push({ elementId, kind, label: message, description: message });
+      }
+   }
+   return markers;
+}
+
+/**
+ * The ids of the elements drawn on this diagram for the diagnostic's target,
+ * starting at the node it points at and walking up its containers; empty when
+ * the path does not resolve or nothing on the chain is rendered.
+ */
+function renderedElementIds(elementPath: string, lookups: DiagnosticMarkerLookups): readonly string[] {
+   let node: AstNode | undefined = lookups.resolveElement(elementPath);
+   while (node !== undefined) {
+      const ids = lookups.renderedIdsFor(node);
+      if (ids.length > 0) {
+         return ids;
+      }
+      node = node.$container;
+   }
+   return [];
+}
+
+/** Map an LSP {@link DiagnosticSeverity} to a GLSP {@link MarkerKind}; unset severity is treated as an error. */
+function markerKind(severity: DiagnosticSeverity | undefined): string {
+   switch (severity) {
+      case DiagnosticSeverity.Warning:
+         return MarkerKind.WARNING;
+      case DiagnosticSeverity.Information:
+      case DiagnosticSeverity.Hint:
+         return MarkerKind.INFO;
+      case DiagnosticSeverity.Error:
+      default:
+         return MarkerKind.ERROR;
+   }
+}

package/src/validation/hydranium-glsp-model-validator.ts

@@ -0,0 +1,105 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { type Marker } from '@eclipse-glsp/protocol';
+import { type GModelElement, ModelState, type ModelValidator } from '@eclipse-glsp/server';
+import { inject, injectable } from 'inversify';
+import { type AstNode } from '@hydranium/langium';
+import { URI } from '@hydranium/langium';
+import { type ServerSharedServices, type TransferLspDiagnostic } from '@hydranium/core';
+import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+import { type DiagnosticMarkerLookups, diagnosticsToMarkers } from './diagnostic-markers.js';
+
+/**
+ * Framework {@link ModelValidator} that surfaces the model server's LSP
+ * diagnostics as GLSP diagram markers. Bound per diagram via
+ * `DiagramModule.bindModelValidator()`; the framework submission handler also
+ * pushes its output as a `SetMarkersAction` after every model submit so
+ * markers refresh live (the GLSP client otherwise only re-requests markers on
+ * the tool-palette validate command).
+ *
+ * The translation itself ({@link diagnosticsToMarkers}) is pure; this class
+ * supplies its model-shaped lookups from the live services: the per-language
+ * `AstNodeLocator` resolves a diagnostic's `element` path back to its AST node,
+ * and the GModel index assigns the node's diagram id and reports whether that
+ * id is currently drawn.
+ *
+ * **Cross-document.** A diagram routinely renders elements defined in *other*
+ * documents, and their validation errors are published on those documents, not
+ * on the diagram's own. The validator therefore scans the diagnostics of every
+ * document the index reports as contributing a rendered element (the index's
+ * `renderedDocumentUris`: the diagram's own document plus those reached via
+ * reference projections) and lets the index's rendered-check keep only those
+ * that map to an element drawn on this diagram; the rest fall away. The
+ * `elements` argument of {@link validate} is ignored — the diagnostic set is
+ * the source of truth, and the default `RequestMarkersAction` requests the
+ * whole diagram anyway.
+ */
+@injectable()
+export class HydraniumGlspModelValidator<TRoot extends AstNode = AstNode> implements ModelValidator {
+   @inject(HydraniumTypes.SharedCoreServices) protected readonly sharedServices!: ServerSharedServices;
+   @inject(ModelState) protected readonly modelState!: AbstractHydraniumGlspState<TRoot>;
+
+   validate(_elements: GModelElement[], _reason?: string): Marker[] {
+      return this.markers();
+   }
+
+   /**
+    * Markers for everything drawn on this diagram, gathered from the
+    * diagnostics of every document the index reports as contributing a
+    * rendered element. Empty before the source model is loaded, and for any
+    * diagnostic whose element is not rendered here.
+    */
+   markers(): Marker[] {
+      // `sourceUri` is a definite-assignment field — undefined until the
+      // storage load flow calls `setSourceRoot`. Guard so a marker request that
+      // races initial load returns empty rather than scanning an empty index.
+      if (!this.modelState.sourceUri) {
+         return [];
+      }
+      const index = this.modelState.index;
+      const markers: Marker[] = [];
+      // Scan only the documents that contribute rendered elements, not every
+      // loaded document. The rendered-check below still keeps only what is
+      // drawn here.
+      for (const uri of index.renderedDocumentUris()) {
+         const document = this.sharedServices.workspace.LangiumDocuments.getDocument(URI.parse(uri));
+         if (!document) {
+            continue;
+         }
+         // Diagnostics are produced by the framework's `HydraniumDocumentValidator`,
+         // which emits `TransferLspDiagnostic` (LSP `Diagnostic` + `element` path).
+         // Parser/lexer diagnostics carry no `element`; the lookup drops them.
+         const diagnostics = document.diagnostics as TransferLspDiagnostic[] | undefined;
+         if (!diagnostics || diagnostics.length === 0) {
+            continue;
+         }
+         const root = document.parseResult.value;
+         const locator = this.sharedServices.ServiceRegistry.getServices(document.uri).workspace.AstNodeLocator;
+         const lookups: DiagnosticMarkerLookups = {
+            resolveElement: path => (path ? locator.getAstNode(root, path) : undefined),
+            renderedIdsFor: astNode => {
+               // A node renders as: every GModel element explicitly registered as
+               // representing it (reference projections, possibly several), plus its
+               // own stable id, for an element keyed directly by it. Keep only the
+               // ids actually drawn on this diagram.
+               const candidates = new Set(index.findElementIds(astNode));
+               const stableId = index.findId(astNode);
+               if (stableId !== undefined) {
+                  candidates.add(stableId);
+               }
+               return [...candidates].filter(id => index.find(id) !== undefined);
+            }
+         };
+         markers.push(...diagnosticsToMarkers(diagnostics, lookups));
+      }
+      return markers;
+   }
+}

package/src/validation/index.ts

@@ -0,0 +1,11 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+export * from './diagnostic-markers.js';
+export * from './hydranium-glsp-model-validator.js';