@eclipse-glsp/server 2.6.0-next.3 → 2.7.0-next.6

package/src/common/protocol/glsp-server.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,6 +25,9 @@ import {
     InitializeResult,
     MaybePromise,
     MessageAction,
+    RejectAction,
+    RequestAction,
+    ResponseAction,
     ServerActions,
     distinctAdd,
     remove
@@ -68,7 +71,6 @@ export class DefaultGLSPServer implements GLSPServer {
     protected validateProtocolVersion(params: InitializeParameters): void {
         if (params.protocolVersion !== DefaultGLSPServer.PROTOCOL_VERSION) {
             throw new Error(
-                // eslint-disable-next-line max-len
                 `Protocol version mismatch! The client protocol version ${params.protocolVersion} is not compatible with the server protocol version ${DefaultGLSPServer.PROTOCOL_VERSION}!`
             );
         }
@@ -151,9 +153,46 @@ export class DefaultGLSPServer implements GLSPServer {
         }
         const action = message.action;
         ClientAction.mark(action);
+        if (RequestAction.is(action)) {
+            this.handleClientRequest(clientSession, action, message.clientId);
+            return;
+        }
         clientSession.actionDispatcher.dispatch(action).catch(error => this.handleProcessError(message, error));
     }
 
+    // Fire-and-forget: intentionally not awaited by process()
+    protected async handleClientRequest(
+        clientSession: ClientSession,
+        action: RequestAction<ResponseAction>,
+        clientId: string
+    ): Promise<void> {
+        try {
+            const response =
+                action.timeout !== undefined
+                    ? await clientSession.actionDispatcher.requestUntil(action, action.timeout, true)
+                    : await clientSession.actionDispatcher.request(action);
+            if (response) {
+                this.sendResponseToClient(clientId, response);
+            }
+        } catch (error) {
+            const detail = error instanceof GLSPServerError ? error.cause?.toString?.() : error?.toString?.();
+            this.logger.error(`Failed to handle request '${action.kind}' (${action.requestId}):`, detail);
+            try {
+                const reject = RejectAction.create(`Failed to handle request '${action.kind}' (${action.requestId})`, {
+                    responseId: action.requestId,
+                    detail
+                });
+                this.sendResponseToClient(clientId, reject);
+            } catch (sendError) {
+                this.logger.error(`Failed to send rejection for request '${action.requestId}':`, sendError);
+            }
+        }
+    }
+
+    protected sendResponseToClient(clientId: string, response: ResponseAction): void {
+        this.sendToClient({ clientId, action: response });
+    }
+
     protected handleProcessError(message: ActionMessage, reason: any): void | PromiseLike<void> {
         let errorMsg = `Could not process action: '${message.action.kind}`;
         this.logger.error(errorMsg);

package/src/common/test/mock-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-/* eslint-disable @typescript-eslint/no-empty-function */
+
 // Stub-implementation classes used for unit testing
 
 import { GEdge, GModelElement, GModelElementConstructor, GNode } from '@eclipse-glsp/graph';
@@ -30,7 +30,9 @@ import {
     MaybeArray,
     MaybePromise,
     Point,
+    RequestAction,
     RequestEditValidationAction,
+    ResponseAction,
     ShapeTypeHint,
     ValidationStatus
 } from '@eclipse-glsp/protocol';
@@ -95,7 +97,7 @@ export function createClientSession(
 export class StubActionHandler implements ActionHandler {
     constructor(public actionKinds: string[]) {}
 
-    execute(action: Action): Action[] {
+    execute(action: Action): MaybePromise<Action[]> {
         return [];
     }
 }
@@ -136,6 +138,18 @@ export class StubActionDispatcher implements ActionDispatcher {
     dispatchAll(...actions: MaybeArray<Action>[]): Promise<void> {
         return Promise.resolve();
     }
+
+    request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {
+        return Promise.reject(new Error('Not implemented in stub'));
+    }
+
+    requestUntil<Res extends ResponseAction>(
+        action: RequestAction<Res>,
+        timeoutMs?: number,
+        rejectOnTimeout?: boolean
+    ): Promise<Res | undefined> {
+        return Promise.reject(new Error('Not implemented in stub'));
+    }
 }
 
 export class StubClientSessionFactory implements ClientSessionFactory {

package/src/common/utils/action-queue.spec.ts

@@ -0,0 +1,133 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { expect } from 'chai';
+import { expectToThrowAsync } from '../test/mock-util';
+import { ActionQueue } from './action-queue';
+
+describe('ActionQueue', () => {
+    it('yields pushed items in FIFO order', async () => {
+        const channel = new ActionQueue<number>();
+        const consumed: number[] = [];
+
+        const consumer = (async (): Promise<void> => {
+            for await (const entry of channel.consume()) {
+                consumed.push(entry.item);
+                entry.resolve();
+            }
+        })();
+
+        await Promise.all([channel.push(1), channel.push(2), channel.push(3)]);
+        channel.stop();
+        await consumer;
+
+        expect(consumed).to.deep.equal([1, 2, 3]);
+    });
+
+    it('resolves the push promise once the consumer resolves the entry', async () => {
+        const channel = new ActionQueue<string>();
+        let entryResolver: (() => void) | undefined;
+
+        const consumer = (async (): Promise<void> => {
+            for await (const entry of channel.consume()) {
+                entryResolver = entry.resolve;
+                return;
+            }
+        })();
+
+        const pushed = channel.push('a');
+        // Give the consumer a turn to pick up the entry.
+        await Promise.resolve();
+        await consumer;
+        expect(entryResolver).to.exist;
+        entryResolver!();
+        await pushed;
+    });
+
+    it('propagates reject() from the consumer back to the pushing caller', async () => {
+        const channel = new ActionQueue<number>();
+
+        const consumer = (async (): Promise<void> => {
+            for await (const entry of channel.consume()) {
+                entry.reject(new Error('boom'));
+                return;
+            }
+        })();
+
+        const pushed = channel.push(1);
+        await consumer;
+        await expectToThrowAsync(() => pushed, 'boom');
+    });
+
+    it('rejects push() after stop()', async () => {
+        const channel = new ActionQueue<number>();
+        channel.stop();
+        await expectToThrowAsync(() => channel.push(1), 'ActionQueue is stopped');
+    });
+
+    it('consumer exits after stop() and drain', async () => {
+        const channel = new ActionQueue<number>();
+        const consumed: number[] = [];
+
+        const consumer = (async (): Promise<void> => {
+            for await (const entry of channel.consume()) {
+                consumed.push(entry.item);
+                entry.resolve();
+            }
+        })();
+
+        await channel.push(1);
+        await channel.push(2);
+        channel.stop();
+        await consumer;
+
+        expect(consumed).to.deep.equal([1, 2]);
+        expect(channel.isStopped).to.be.true;
+    });
+
+    it('rejectPending() rejects all queued push() promises without stopping', async () => {
+        const channel = new ActionQueue<number>();
+        const pushes = [channel.push(1), channel.push(2)];
+        expect(channel.size).to.equal(2);
+
+        channel.rejectPending(new Error('cleared'));
+
+        await expectToThrowAsync(() => pushes[0], 'cleared');
+        await expectToThrowAsync(() => pushes[1], 'cleared');
+        expect(channel.size).to.equal(0);
+        expect(channel.isStopped).to.be.false;
+    });
+
+    it('size reflects the number of unconsumed entries', async () => {
+        const channel = new ActionQueue<number>();
+        channel.push(1);
+        channel.push(2);
+        channel.push(3);
+        expect(channel.size).to.equal(3);
+    });
+
+    it('throws when a second consumer is started', async () => {
+        const channel = new ActionQueue<number>();
+        const first = channel.consume();
+        // Kick off the first consumer so it registers as the active consumer.
+        const firstStep = first.next();
+
+        const second = channel.consume();
+        await expectToThrowAsync(() => second.next().then(() => undefined), 'ActionQueue supports only a single consumer');
+
+        channel.stop();
+        await firstStep;
+    });
+});

package/src/common/utils/action-queue.ts

@@ -0,0 +1,107 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+/**
+ * An entry yielded by {@link ActionQueue.consume}. The consumer must call either
+ * `resolve()` or `reject(error)` exactly once after processing `item`.
+ */
+export interface ActionQueueEntry<T> {
+    item: T;
+    resolve: () => void;
+    reject: (error: unknown) => void;
+}
+
+/**
+ * Producer/consumer queue with a single async consumer loop. Items are processed in FIFO order.
+ */
+export class ActionQueue<T> {
+    protected queue: ActionQueueEntry<T>[] = [];
+    protected notify: (() => void) | undefined;
+    protected stopped = false;
+    protected consuming = false;
+
+    /**
+     * Enqueues an item. The returned promise settles when the consumer finishes processing it,
+     * propagating results back to the producer. Rejects immediately if the queue has been stopped.
+     */
+    push(item: T): Promise<void> {
+        if (this.stopped) {
+            return Promise.reject(new Error('ActionQueue is stopped'));
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({ item, resolve, reject });
+            this.notify?.();
+        });
+    }
+
+    /**
+     * Yields pending entries, suspending until the next {@link push} when the queue is empty. Exits
+     * once the queue is stopped and has been drained.
+     *
+     * Single-consumer: calling `consume()` a second time throws an error.
+     */
+    async *consume(): AsyncGenerator<ActionQueueEntry<T>> {
+        if (this.consuming) {
+            throw new Error('ActionQueue supports only a single consumer');
+        }
+        this.consuming = true;
+        try {
+            while (!this.stopped || this.queue.length > 0) {
+                while (this.queue.length > 0) {
+                    yield this.queue.shift()!;
+                }
+                if (this.stopped) {
+                    return;
+                }
+                await new Promise<void>(resolve => {
+                    this.notify = resolve;
+                });
+                this.notify = undefined;
+            }
+        } finally {
+            this.consuming = false;
+        }
+    }
+
+    /**
+     * Stops the queue. Further {@link push} calls reject. The consumer loop exits after
+     * the remaining queued entries have been yielded (or immediately if the queue is empty).
+     */
+    stop(): void {
+        this.stopped = true;
+        this.notify?.();
+    }
+
+    /**
+     * Rejects all queued entries with the given reason so producers awaiting their
+     * `push()` promises do not hang. Does not stop the queue.
+     */
+    rejectPending(reason: Error = new Error('ActionQueue cleared')): void {
+        const pending = this.queue;
+        this.queue = [];
+        for (const entry of pending) {
+            entry.reject(reason);
+        }
+    }
+
+    get size(): number {
+        return this.queue.length;
+    }
+
+    get isStopped(): boolean {
+        return this.stopped;
+    }
+}

package/src/common/utils/promise-queue.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -14,8 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { delay } from '../test/mock-util';
-import { PromiseQueue } from './promise-queue';
+
 import { expect } from 'chai';
+// eslint-disable-next-line import-x/no-deprecated
+import { PromiseQueue } from './promise-queue';
 
 // Helper types and functions that are needed for test setup
 
@@ -74,11 +76,13 @@ function newTestPromise(resolveTime: number): TestPromise {
     return { state, promise };
 }
 
+// eslint-disable-next-line @typescript-eslint/no-deprecated, import-x/no-deprecated
 let queue = new PromiseQueue();
 
 // Test execution
 describe('test PromiseQueue', () => {
     beforeEach(() => {
+        // eslint-disable-next-line import-x/no-deprecated, @typescript-eslint/no-deprecated
         queue = new PromiseQueue();
     });
     it('enqueue - one element', async () => {

package/src/common/utils/promise-queue.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -29,6 +29,10 @@ export interface PromiseQueueElement<T = void> {
  * of promises. Promises that are put in this queue are processed one by one.
  * i.e. After the first promise in the queue is resolved, it will be removed from the queue and the resolving of the
  * the next promise (if present) will start. The queue can only resolve one promise at a given time.
+ *
+ * @deprecated Since 2.7. The `DefaultActionDispatcher` no longer uses this queue. Kept for
+ * backwards compatibility; will be removed in a future release. New code should use
+ * {@link ActionQueue} or native async patterns instead.
  */
 export class PromiseQueue<T = void> {
     protected queue: PromiseQueueElement<T>[] = [];