Support asynchronous action handlers on client-side (#457)

Fixes eclipse-glsp/glsp#1609

Author: martin-fleck-at

packages/client/src/base/action-dispatcher.ts

@@ -16,17 +16,20 @@
 import {
     Action,
     ActionDispatcher,
+    ActionHandler,
     ActionHandlerRegistry,
     Deferred,
     EMPTY_ROOT,
     GModelRoot,
     IActionDispatcher,
+    RejectAction,
     RequestAction,
     ResponseAction,
     SetModelAction,
     TYPES
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import * as sprotty from 'sprotty-protocol/lib/actions';
 import { GLSPActionHandlerRegistry } from './action-handler-registry';
 import { IGModelRootListener } from './editor-context-service';
 import { OptionalAction } from './model/glsp-model-source';
@@ -125,26 +128,96 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
         return result;
     }
 
-    protected override handleAction(action: Action): Promise<void> {
+    protected override async handleAction(action: Action): Promise<void> {
         if (ResponseAction.hasValidResponseId(action)) {
-            // clear timeout
-            const timeout = this.timeouts.get(action.responseId);
-            if (timeout !== undefined) {
-                clearTimeout(timeout);
-                this.timeouts.delete(action.responseId);
-            }
+            return this.handleResponseAction(action);
+        }
+        if (OptionalAction.is(action) && !this.hasHandler(action)) {
+            return Promise.resolve();
+        }
+        if (sprotty.UndoAction.KIND === action.kind) {
+            return this.handleUndoAction(action);
+        }
+        if (sprotty.RedoAction.KIND === action.kind) {
+            return this.handleRedoAction(action);
+        }
+        return this.doHandleAction(action);
+    }
+
+    protected handleResponseAction(action: ResponseAction): Promise<void> {
+        // clear any pending timeout
+        const timeout = this.timeouts.get(action.responseId);
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
+            this.timeouts.delete(action.responseId);
+        }
 
-            // Check if we have a pending request for the response.
-            // If not the  we clear the responseId => action will be dispatched normally
-            const deferred = this.requests.get(action.responseId);
-            if (deferred === undefined) {
-                action.responseId = '';
+        // check for matching request
+        const request = this.requests.get(action.responseId);
+        if (!request) {
+            // treat no matching request by dispatching action normally
+            this.logger.log(this, 'No matching request for response, dispatch normally', action);
+            action.responseId = '';
+            return this.handleAction(action);
+        }
+
+        this.requests.delete(action.responseId);
+        if (RejectAction.is(action)) {
+            // translation reject action to request rejection
+            request.reject(new Error(action.message));
+            this.logger.warn(this, `Request with id ${action.responseId} failed.`, action.message, action.detail);
+        } else {
+            request.resolve(action);
+        }
+        return Promise.resolve();
+    }
+
+    protected handleUndoAction(action: Action): Promise<void> {
+        return this.commandStack.undo().then(() => {});
+    }
+
+    protected handleRedoAction(action: Action): Promise<void> {
+        return this.commandStack.redo().then(() => {});
+    }
+
+    protected async doHandleAction(action: Action): Promise<void> {
+        const handlers = this.actionHandlerRegistry.get(action.kind);
+        if (handlers.length === 0) {
+            return this.handleActionWithoutHandler(action);
+        } else {
+            return this.handlerActionWithHandler(action, handlers);
+        }
+    }
+
+    protected handleActionWithoutHandler(action: Action): Promise<void> {
+        this.logger.warn(this, 'Missing handler for action', action);
+        const error = new Error(`Missing handler for action '${action.kind}'`);
+        if (RequestAction.is(action)) {
+            const request = this.requests.get(action.requestId);
+            if (request !== undefined) {
+                this.requests.delete(action.requestId);
+                request.reject(error);
             }
         }
-        if (!this.hasHandler(action) && OptionalAction.is(action)) {
-            return Promise.resolve();
+        return Promise.reject(error);
+    }
+
+    protected async handlerActionWithHandler(action: Action, handlers: ActionHandler[]): Promise<any> {
+        this.logger.log(this, 'Handle', action);
+        const handlerResults: Promise<any>[] = [];
+        for (const handler of handlers) {
+            const handlerResult = Promise.resolve(handler.handle(action)).then<any>(result => {
+                if (Action.is(result)) {
+                    return this.dispatch(result);
+                } else if (result !== undefined) {
+                    this.blockUntil = result.blockUntil;
+                    return this.commandStack.execute(result);
+                }
+                return undefined;
+            });
+            handlerResults.push(handlerResult);
         }
-        return super.handleAction(action);
+        return Promise.all(handlerResults) as Promise<any>;
     }
 
     override request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {

packages/glsp-sprotty/src/action-handler-override.ts

@@ -0,0 +1,90 @@
+/********************************************************************************
+ * 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 { Action } from '@eclipse-glsp/protocol';
+import { injectable, interfaces, multiInject, optional } from 'inversify';
+import { ICommand, MultiInstanceRegistry, TYPES } from 'sprotty';
+import {
+    ActionHandlerRegistry as SActionHandlerRegistry,
+    IActionHandler as SIActionHandler,
+    configureActionHandler as sconfigureActionHandler
+} from 'sprotty/lib/base/actions/action-handler';
+
+export type SyncActionHandleResult = ICommand | Action | void;
+export type ASyncActionHandleResult = Promise<SyncActionHandleResult>;
+export type ActionHandleResult = SyncActionHandleResult | ASyncActionHandleResult;
+
+/**
+ * An action handler accepts an action and reacts to it by returning either a command to be
+ * executed, or another action to be dispatched.
+ */
+export interface IActionHandler {
+    handle(action: Action): ActionHandleResult;
+}
+
+export interface ActionHandlerRegistration {
+    actionKind: string;
+    factory: () => IActionHandler;
+}
+
+export interface IActionHandlerInitializer {
+    initialize(registry: ActionHandlerRegistry): void;
+}
+
+export type ActionHandler = IActionHandler & SIActionHandler;
+
+@injectable()
+export class ActionHandlerRegistry extends MultiInstanceRegistry<ActionHandler> implements SActionHandlerRegistry {
+    constructor(
+        @multiInject(TYPES.ActionHandlerRegistration) @optional() registrations: ActionHandlerRegistration[],
+        @multiInject(TYPES.IActionHandlerInitializer) @optional() initializers: IActionHandlerInitializer[]
+    ) {
+        super();
+        registrations.forEach(registration => this.register(registration.actionKind, registration.factory()));
+        initializers.forEach(initializer => this.initializeActionHandler(initializer));
+    }
+
+    override register(key: string, instance: IActionHandler): void;
+    override register(key: string, instance: SIActionHandler): void;
+    override register(key: string, instance: ActionHandler): void {
+        super.register(key, instance);
+    }
+
+    initializeActionHandler(initializer: IActionHandlerInitializer): void {
+        initializer.initialize(this);
+    }
+}
+
+export function configureActionHandler(
+    context: { bind: interfaces.Bind; isBound: interfaces.IsBound },
+    kind: string,
+    constr: interfaces.ServiceIdentifier<IActionHandler>
+): void {
+    sconfigureActionHandler(context, kind, constr);
+}
+
+/**
+ * Utility function to register an action handler for an action kind.
+ */
+export function onAction(
+    context: { bind: interfaces.Bind; isBound: interfaces.IsBound },
+    kind: string,
+    handle: (action: Action) => ReturnType<IActionHandler['handle']>
+): void {
+    context.bind(TYPES.ActionHandlerRegistration).toConstantValue({
+        actionKind: kind,
+        factory: () => ({ handle })
+    });
+}

packages/glsp-sprotty/src/api-override.ts

@@ -22,7 +22,6 @@ import {
     SModelRootImpl as GModelRoot,
     ICommand,
     IActionDispatcher as SIActionDispatcher,
-    IActionHandler as SIActionHandler,
     IButtonHandler as SIButtonHandler,
     ICommandPaletteActionProvider as SICommandPaletteActionProvider,
     ICommandStack as SICommandStack,
@@ -43,14 +42,6 @@ import {
  *
  */
 
-/**
- * An action handler accepts an action and reacts to it by returning either a command to be
- * executed, or another action to be dispatched.
- */
-export interface IActionHandler extends SIActionHandler {
-    handle(action: Action): ICommand | Action | void;
-}
-
 export interface IButtonHandler extends SIButtonHandler {
     buttonPressed(button: GButton): (Action | Promise<Action>)[];
 }

packages/glsp-sprotty/src/index.ts

@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+export * from './action-handler-override';
 export * from './api-override';
 export * from './feature-modules';
 export * from './layout-override';

packages/glsp-sprotty/src/re-exports.ts

@@ -29,13 +29,7 @@ export * from '@eclipse-glsp/protocol/lib/di';
 // export * from 'sprotty/lib/base/actions/action';
 // Exclude IActionDispatcher and IActionDispatcherProvider. Exported via api-override module instead
 export { ActionDispatcher, PostponedAction } from 'sprotty/lib/base/actions/action-dispatcher';
-export {
-    ActionHandlerRegistration,
-    ActionHandlerRegistry,
-    configureActionHandler,
-    IActionHandlerInitializer,
-    onAction
-} from 'sprotty/lib/base/actions/action-handler';
+// export * from 'sprotty/lib/base/actions/action-handler';
 export * from 'sprotty/lib/base/actions/diagram-locker';
 
 export * from 'sprotty/lib/base/animations/animation';