@hydranium/glsp-server 1.0.0-next.31 → 1.0.0-next.315

package/src/command/diagram-edit-dropped-error.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (c) 2026 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 Action, type Logger, RequestAction } from '@eclipse-glsp/server';
+import { describeError, describeErrorWithStack, isConflictError } from '@hydranium/protocol';
+
+/**
+ * Thrown when the reconcile of a diagram edit's write dropped it: a foreign
+ * edit changed a field the edit writes. Declined by design rather than failed,
+ * and the reconcile has logged it, so whoever ends it tells the client without
+ * logging it again. It never crosses a wire, so it carries no error code.
+ */
+export class DiagramEditDroppedError extends Error {
+   constructor(message: string) {
+      super(message);
+      this.name = 'DiagramEditDroppedError';
+   }
+}
+
+/**
+ * Whether `error` is a {@link DiagramEditDroppedError}, by name, so one thrown
+ * by another installed copy of this package counts too.
+ */
+export function isDiagramEditDroppedError(error: unknown): error is DiagramEditDroppedError {
+   return error instanceof Error && error.name === 'DiagramEditDroppedError';
+}
+
+/**
+ * Log an action that failed, once, at the level of what happened: a dropped
+ * edit at `debug`, since its reconcile has logged it, a conflict at `warn`
+ * naming its versions, since it was declined, and anything else at `error`.
+ * A request is named by its id too, which its client's reject carries.
+ */
+export function logActionFailure(logger: Logger, action: Action, error: unknown): void {
+   const named = `'${action.kind}'${RequestAction.is(action) ? ` (${action.requestId})` : ''}`;
+   if (isDiagramEditDroppedError(error)) {
+      logger.debug(`Could not process action ${named}: ${describeError(error)}`);
+   } else if (isConflictError(error)) {
+      logger.warn(
+         `Could not process action ${named}: ${describeError(error)} (model v${error.baseVersion} / text v${error.actualVersion})`
+      );
+   } else {
+      logger.error(`Could not process action ${named}: ${describeErrorWithStack(error)}`);
+   }
+}

package/src/command/hydranium-glsp-command-stack.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * Copyright (c) 2026 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 { DefaultCommandStack, ModelState } from '@eclipse-glsp/server';
+import { type ServerSharedServices } from '@hydranium/core';
+import { inject, injectable } from 'inversify';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+
+/**
+ * GLSP's command stack with the diagram's dirty state read from the text store:
+ * dirty while any document the diagram's client session has open differs from
+ * its file, as the store last knew the file. Undo and redo are GLSP's.
+ *
+ * GLSP's own answer counts the diagram's commands since its last save, so it
+ * misses every change the diagram did not make: another client's unsaved edit
+ * leaves it clean, and a save it did not make of a document other than the
+ * diagram's own leaves it dirty. Every `SetDirtyStateAction` GLSP sends reads
+ * this answer.
+ */
+@injectable()
+export class HydraniumGlspCommandStack extends DefaultCommandStack {
+   @inject(ModelState) protected readonly modelState!: ModelState;
+   @inject(HydraniumTypes.SharedCoreServices) protected readonly sharedServices!: ServerSharedServices;
+
+   override get isDirty(): boolean {
+      const textDocuments = this.sharedServices.workspace.TextDocuments;
+      const clientId = this.modelState.clientId;
+      return textDocuments.openDocuments().some(open => open.clients.includes(clientId) && textDocuments.isDirty(open.uri));
+   }
+
+   /**
+    * Lifted from `@eclipse-glsp/server` 2.7.0's `DefaultCommandStack.handleError`
+    * without its `error` line: the failure is rethrown, and whoever ends it
+    * logs it. The accompanying test pins upstream's source.
+    */
+   protected override handleError(error: unknown): never {
+      this.flush();
+      this.logger.debug('A command failed; the command stack was flushed');
+      throw error;
+   }
+}

package/src/command/hydranium-glsp-operation-action-handler.ts

@@ -0,0 +1,141 @@
+/********************************************************************************
+ * Copyright (c) 2026 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 Action,
+   ActionDispatcher,
+   type AnyObject,
+   GLSPClientProxy,
+   GLSPServerError,
+   Logger,
+   MessageAction,
+   type Operation,
+   OperationActionHandler,
+   type OperationHandler
+} from '@eclipse-glsp/server';
+import { describeErrorWithStack } from '@hydranium/protocol';
+import { inject, injectable } from 'inversify';
+import { logActionFailure } from './diagram-edit-dropped-error.js';
+import { HydraniumGlspOperationCommand, openOperationOf, runOperation } from './hydranium-glsp-operation-command.js';
+import { type HydraniumGlspRecordingState } from './hydranium-glsp-recording-command.js';
+
+/**
+ * GLSP's operation action handler, running each operation as a
+ * {@link HydraniumGlspOperationCommand} inside the state's `runExclusive`,
+ * which covers the operation, its write, the command-stack push and the
+ * submit, so neither another operation, an undo nor the storage's capture
+ * lands between them.
+ *
+ * An operation dispatched while another is open, as a handler's plain
+ * `dispatch` does, is queued behind it and its dispatch resolves at once;
+ * awaited inside the open operation, it would wait for the operation awaiting
+ * it. It writes, pushes and submits on its own, and a failure is reported to
+ * the client as GLSP reports a failed client action.
+ *
+ * Only operations are queued that way, and only while one is open, its undo's
+ * side effects included. Code running inside the boundary otherwise must not
+ * dispatch an operation and await it: a GModel factory or a submit after an
+ * operation, an undo's write and submit, the storage's render. Nor may any code
+ * inside the boundary await a dispatched undo, redo or model request, which
+ * take the boundary themselves. Each waits for the section awaiting it.
+ */
+@injectable()
+export class HydraniumGlspOperationActionHandler extends OperationActionHandler {
+   declare protected modelState: HydraniumGlspRecordingState<AnyObject>;
+   @inject(ActionDispatcher) protected readonly actionDispatcher!: ActionDispatcher;
+   @inject(Logger) protected readonly logger!: Logger;
+   @inject(GLSPClientProxy) protected readonly clientProxy!: GLSPClientProxy;
+
+   protected override executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
+      const queued = openOperationOf(this.modelState) !== undefined;
+      const run = this.modelState.runExclusive(() => this.runOperation(operation, handler));
+      if (!queued) {
+         return run;
+      }
+      run.then(
+         actions => this.deliverQueued(actions),
+         (error: unknown) => this.reportFailure(operation, error)
+      );
+      return Promise.resolve([]);
+   }
+
+   /**
+    * Run `operation`; push it when its command was written, and submit the
+    * model when it executed one, written or dropped.
+    */
+   protected async runOperation(operation: Operation, handler: OperationHandler): Promise<Action[]> {
+      // A queued operation can find the diagram read-only by the time it runs.
+      if (this.modelState.isReadonly) {
+         return [
+            MessageAction.create(`Server is in readonly-mode! Could not execute operation: ${operation.kind}`, { severity: 'WARNING' })
+         ];
+      }
+      const command = new HydraniumGlspOperationCommand(this.modelState);
+      const outcome = await runOperation(command, () => handler.execute(operation));
+      if (outcome === 'none') {
+         return [];
+      }
+      if (outcome === 'executed') {
+         await this.executeCommand(command);
+      }
+      return this.submitModel();
+   }
+
+   /**
+    * Deliver what a queued operation answered: a message straight to the
+    * client, as {@link reportFailure} sends one, the rest through the
+    * dispatcher. A failure to deliver is logged, not reported as the
+    * operation's.
+    */
+   protected deliverQueued(actions: Action[]): void {
+      const messages = actions.filter(action => MessageAction.is(action));
+      messages.forEach(message => this.sendToClient(message));
+      this.actionDispatcher
+         .dispatchAll(actions.filter(action => !MessageAction.is(action)))
+         .catch((error: unknown) =>
+            this.logger.warn(`Could not deliver the result of a queued operation: ${describeErrorWithStack(error)}`)
+         );
+   }
+
+   /**
+    * Log `error` with {@link logActionFailure}, as the server logs a failed
+    * action, and send the client the error message GLSP sends for one. A
+    * queued operation that fails once its diagram has closed, which the
+    * storage's dispose marks by clearing the state's session, is logged at
+    * `debug` and told to no client, as the server treats an ended session.
+    */
+   protected reportFailure(operation: Operation, error: unknown): void {
+      // Queued only after a load registered the session, so none now means the diagram has closed.
+      if (this.modelState.modelSession === undefined) {
+         this.logger.debug(`Operation '${operation.kind}' ended with its diagram: ${describeErrorWithStack(error)}`);
+         return;
+      }
+      logActionFailure(this.logger, operation, error);
+      let message = `Could not process action: '${operation.kind}`;
+      let details = error instanceof Error ? error.toString() : String(error);
+      if (error instanceof GLSPServerError) {
+         details = String(error.cause);
+         message = error.message;
+      }
+      this.sendToClient(MessageAction.create(message, { severity: 'ERROR', details }));
+   }
+
+   /**
+    * Send `action` straight to the client, as GLSP's server sends a failed
+    * action's message. Sent through the dispatcher instead, an action of a
+    * kind the client registered no handler for is rejected.
+    */
+   protected sendToClient(action: Action): void {
+      try {
+         this.clientProxy.process({ clientId: this.modelState.clientId, action });
+      } catch (error: unknown) {
+         this.logger.warn(`Could not send '${action.kind}' to the client: ${describeErrorWithStack(error)}`);
+      }
+   }
+}