@eclipse-glsp/server 1.1.0-RC05

package/src/browser/launch/worker-server-launcher.ts

@@ -0,0 +1,58 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { Container, injectable } from 'inversify';
+import * as jsonrpc from 'vscode-jsonrpc/browser';
+import { GLSPServer, GLSPServerLauncher, JsonRpcGLSPServer, MaybePromise, START_UP_COMPLETE_MSG } from '../../common/index';
+
+@injectable()
+export class WorkerServerLauncher extends GLSPServerLauncher {
+    private connection?: jsonrpc.MessageConnection;
+
+    protected run(): MaybePromise<void> {
+        if (this.connection) {
+            throw new Error('Error during launch. Server already has an active client connection');
+        }
+        const container = this.createContainer();
+        this.connection = this.createConnection();
+        const glspServer = container.get<JsonRpcGLSPServer>(JsonRpcGLSPServer);
+        glspServer.connect(this.connection);
+        this.connection.onDispose(() => this.disposeClientConnection(container, glspServer));
+
+        this.logger.info('GLSP server worker connection established');
+        this.connection.listen();
+        postMessage(START_UP_COMPLETE_MSG);
+        return new Promise((resolve, rejects) => {
+            this.connection?.onClose(() => resolve(undefined));
+            this.connection?.onError(error => rejects(error));
+        });
+    }
+
+    protected disposeClientConnection(container: Container, glspServer: GLSPServer): void {
+        glspServer.shutdown();
+        container.unbindAll();
+        this.connection = undefined;
+    }
+
+    protected stop(): MaybePromise<void> {
+        this.logger.info('Shutdown WorkerServerLauncher');
+        this.connection?.dispose();
+    }
+
+    protected createConnection(): jsonrpc.MessageConnection {
+        return jsonrpc.createMessageConnection(new jsonrpc.BrowserMessageReader(self), new jsonrpc.BrowserMessageWriter(self));
+    }
+}

package/src/common/actions/action-dispatcher.spec.ts

@@ -0,0 +1,290 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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
+ * 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, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import * as sinon from 'sinon';
+import { ClientActionKinds, ClientId } from '../di/service-identifiers';
+import { ClientSessionManager } from '../session/client-session-manager';
+import * as mock from '../test/mock-util';
+import { Logger } from '../utils/logger';
+import { DefaultActionDispatcher } from './action-dispatcher';
+import { ActionHandler } from './action-handler';
+import { ActionHandlerRegistry } from './action-handler-registry';
+import assert = require('assert');
+
+function waitSync(timeInMillis: number): void {
+    const start = Date.now();
+    let now = start;
+    while (now - start < timeInMillis) {
+        now = Date.now();
+    }
+}
+
+describe('test DefaultActionDispatcher', () => {
+    const container = new Container();
+    const clientId = 'myClientId';
+    const actionHandlerRegistry = new ActionHandlerRegistry();
+    let registry_get_stub: sinon.SinonStub<[string], ActionHandler[]>;
+    const sandbox = sinon.createSandbox();
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new mock.StubLogger());
+            bind(ClientSessionManager).toConstantValue(new mock.StubClientSessionManager());
+            bind(ClientId).toConstantValue(clientId);
+            bind(ActionHandlerRegistry).toConstantValue(actionHandlerRegistry);
+            bind(ClientActionKinds).toConstantValue(['response', 'response1', 'response2']);
+        })
+    );
+    const actionDispatcher = container.resolve(DefaultActionDispatcher);
+
+    beforeEach(() => {
+        registry_get_stub = sandbox.stub(actionHandlerRegistry, 'get');
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe('test with one-way actions (no response actions)', () => {
+        it('dispatch- unhandled action', async () => {
+            assert.rejects(actionDispatcher.dispatch({ kind: 'unhandled' }));
+        });
+
+        it('dispatch - one action', async () => {
+            // Mock setup
+            const action = 'action';
+            const handler = new mock.StubActionHandler([action]);
+            const getHandler = (kind: string): ActionHandler[] => (kind === action ? [handler] : []);
+            registry_get_stub.callsFake(getHandler);
+            const spy_handler_execute = sinon.spy(handler, 'execute');
+            // Test execution
+            await actionDispatcher.dispatch({ kind: action });
+            expect(spy_handler_execute.calledOnce).true;
+        });
+
+        describe('test multi dispatch with single-handled actions', () => {
+            // Mock Setup
+            const action1 = 'a1';
+            const action2 = 'a2';
+            const action3 = 'a3';
+
+            const handler1 = new mock.StubActionHandler([action1]);
+            const handler2 = new mock.StubActionHandler([action2]);
+            const handler3 = new mock.StubActionHandler([action3]);
+
+            const spy_handler1_execute = sinon.stub(handler1, 'execute').returns([]);
+            const spy_handler2_execute = sinon.stub(handler2, 'execute').returns([]);
+            const spy_handler3_execute = sinon.stub(handler3, 'execute').returns([]);
+            const handlerMockImpl = (kind: string): ActionHandler[] => {
+                switch (kind) {
+                    case action1:
+                        return [handler1];
+                    case action2:
+                        return [handler2];
+                    case action3:
+                        return [handler3];
+                    default:
+                        return [];
+                }
+            };
+
+            it('dispatch - multiple actions', async () => {
+                // Mock setup
+                registry_get_stub.callsFake(handlerMockImpl);
+                // Test execution
+                actionDispatcher.dispatch({ kind: action1 });
+                actionDispatcher.dispatch({ kind: action2 });
+                await actionDispatcher.dispatch({ kind: action3 });
+                // Check if all handlers have been called
+                expect(spy_handler1_execute.called).true;
+                expect(spy_handler2_execute.called).true;
+                expect(spy_handler3_execute.called).true;
+                // Check if all handlers have been called in the right order
+                sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute, spy_handler3_execute);
+            });
+
+            it('dispatchAll- multiple actions', async () => {
+                // Mock setup
+                registry_get_stub.callsFake(handlerMockImpl);
+                // Test execution
+                await actionDispatcher.dispatchAll([{ kind: action1 }, { kind: action2 }, { kind: action3 }]);
+                // Check if all handlers have been called
+                expect(spy_handler1_execute.calledOnce);
+                expect(spy_handler2_execute.calledOnce);
+                expect(spy_handler3_execute.calledOnce);
+                // Check if all handlers have been called in the right order
+                sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute, spy_handler3_execute);
+            });
+
+            it('dispatch - multiple actions (racing execution times)', async () => {
+                // Mock setup
+                registry_get_stub.callsFake(handlerMockImpl);
+                spy_handler1_execute.callsFake((_action: Action) => {
+                    waitSync(500);
+                    return [];
+                });
+                spy_handler2_execute.callsFake((_action: Action) => {
+                    waitSync(200);
+                    return [];
+                });
+                spy_handler3_execute.callsFake((_action: Action) => {
+                    waitSync(100);
+                    return [];
+                });
+                // Test execution
+                actionDispatcher.dispatch({ kind: action1 });
+                actionDispatcher.dispatch({ kind: action2 });
+                await actionDispatcher.dispatch({ kind: action3 });
+                // Check if all handlers have been called
+                expect(spy_handler1_execute.calledOnce);
+                expect(spy_handler2_execute.calledOnce);
+                expect(spy_handler3_execute.calledOnce);
+                // Check if all handlers have been called in the right order
+                sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute, spy_handler3_execute);
+            });
+        });
+
+        it('dispatch- one action & multiple handlers', async () => {
+            // Mock setup
+            const action1 = 'a1';
+
+            const handler1 = new mock.StubActionHandler([action1]);
+            const handler2 = new mock.StubActionHandler([action1]);
+
+            registry_get_stub.callsFake((kind: string) => (kind === action1 ? [handler1, handler2] : []));
+            const spy_handler1_execute = sinon.spy(handler1, 'execute');
+            const spy_handler2_execute = sinon.spy(handler2, 'execute');
+            // Test execution
+            await actionDispatcher.dispatch({ kind: action1 });
+            expect(spy_handler1_execute.calledOnce);
+            expect(spy_handler2_execute.calledOnce);
+            sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute);
+        });
+    });
+
+    describe('test with handler response actions ', () => {
+        it('dispatch - one action & one handler response action', async () => {
+            // Mock setup
+            const request = 'request';
+            const response = 'response';
+
+            const requestHandler = new mock.StubActionHandler([request]);
+            const responseHandler = new mock.StubActionHandler([response]);
+
+            const spy_requestHandler_execute = sinon.stub(requestHandler, 'execute').returns([{ kind: response }]);
+            const spy_responseHandler_execute = sinon.spy(responseHandler, 'execute');
+            registry_get_stub.callsFake((kind: string) => {
+                switch (kind) {
+                    case request:
+                        return [requestHandler];
+                    case response:
+                        return [responseHandler];
+                    default:
+                        return [];
+                }
+            });
+            // Test execution
+            await actionDispatcher.dispatch({ kind: request });
+            // Add a delay so that the action dispatcher has time to dispatch the handler response
+            await mock.delay(200);
+            // Check if all handlers have been called
+            expect(spy_requestHandler_execute.calledOnce);
+            expect(spy_responseHandler_execute.calledOnce);
+        });
+
+        it('dispatch - multiple actions & multiple response', async () => {
+            // Mock setup
+            const request1 = 'request1';
+            const request2 = 'request2';
+            const response1 = 'response1';
+            const response2 = 'response2';
+
+            const responseHandler1 = new mock.StubActionHandler([response1]);
+            const responseHandler2 = new mock.StubActionHandler([response2]);
+            const requestHandler1 = new mock.StubActionHandler([request1]);
+            const requestHandler2 = new mock.StubActionHandler([request2]);
+
+            const spy_requestHandler1_execute = sinon.stub(requestHandler1, 'execute').returns([{ kind: response1 }, { kind: response2 }]);
+            const spy_requestHandler2_execute = sinon.stub(requestHandler2, 'execute').returns([{ kind: response2 }]);
+            const spy_responseHandler1_execute = sinon.spy(responseHandler1, 'execute');
+            const spy_responseHandler2_execute = sinon.spy(responseHandler2, 'execute');
+            registry_get_stub.callsFake((kind: string) => {
+                switch (kind) {
+                    case request1:
+                        return [requestHandler1];
+                    case request2:
+                        return [requestHandler2];
+                    case response1:
+                        return [responseHandler1, responseHandler2];
+                    case response2:
+                        return [responseHandler2];
+                    default:
+                        return [];
+                }
+            });
+            // Test execution
+            actionDispatcher.dispatch({ kind: request1 });
+            await actionDispatcher.dispatch({ kind: request2 });
+
+            // Add a delay so that the action dispatcher has time to dispatch the handler response
+            await mock.delay(100);
+            // Check if all handlers have been called correctly
+            expect(spy_requestHandler1_execute.calledOnce);
+            expect(spy_requestHandler2_execute.calledOnce);
+            expect(spy_responseHandler1_execute.calledOnce);
+            expect(spy_responseHandler2_execute.calledThrice);
+            // Check if all handlers have been called in the right order
+            sinon.assert.callOrder(spy_requestHandler1_execute, spy_requestHandler2_execute);
+            sinon.assert.callOrder(spy_responseHandler1_execute, spy_responseHandler2_execute);
+        });
+    });
+
+    describe('test dispatch after next update', () => {
+        it('dispatchAfterNextUpdate', async () => {
+            // Mock setup
+            const updateModelAction = UpdateModelAction.create({ id: 'newRoot', type: 'myType' });
+            const intermediateAction = 'intermediate';
+            const postUpdateAction = 'postUpdate';
+            const handler = new mock.StubActionHandler([updateModelAction.kind, intermediateAction]);
+            const postUpdateHandler = new mock.StubActionHandler([postUpdateAction]);
+
+            const getHandler = (kind: string): ActionHandler[] => {
+                if (kind === updateModelAction.kind || kind === intermediateAction) {
+                    return [handler];
+                } else if (kind === postUpdateAction) {
+                    return [postUpdateHandler];
+                }
+
+                return [];
+            };
+            registry_get_stub.callsFake(getHandler);
+            const spy_postUpdateHandler_execute = sinon.spy(postUpdateHandler, 'execute');
+
+            // Test execution
+            actionDispatcher.dispatchAfterNextUpdate({ kind: postUpdateAction });
+            expect(spy_postUpdateHandler_execute.called).to.be.false;
+            await actionDispatcher.dispatch({ kind: intermediateAction });
+            expect(spy_postUpdateHandler_execute.called).to.be.false;
+            await actionDispatcher.dispatch(updateModelAction);
+            expect(spy_postUpdateHandler_execute.calledOnce);
+            // Check that action does not get dispatched again
+            await actionDispatcher.dispatch(updateModelAction);
+            expect(spy_postUpdateHandler_execute.calledOnce);
+        });
+    });
+});

package/src/common/actions/action-dispatcher.ts

@@ -0,0 +1,152 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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
+ * 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, Disposable, flatPush, MaybeArray, RequestAction, ResponseAction, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ClientActionKinds, ClientId } from '../di/service-identifiers';
+import { GLSPServerError } from '../utils/glsp-server-error';
+import { Logger } from '../utils/logger';
+import { PromiseQueue } from '../utils/promise-queue';
+import { ActionHandler } from './action-handler';
+import { ActionHandlerRegistry } from './action-handler-registry';
+
+export const ActionDispatcher = Symbol('ActionDispatcher');
+
+/**
+ * The central component that process all {@link Action}s by dispatching them to their designated
+ * handlers.
+ */
+export interface ActionDispatcher {
+    /**
+     * Processes the given action by dispatching it to all registered handlers.
+     *
+     * @param action The action that should be dispatched.
+     * @returns A promise indicating when the action processing is complete.
+     */
+    dispatch(action: Action): Promise<void>;
+
+    /**
+     * Processes all given actions by dispatching to the corresponding handlers.
+     *
+     * @param actions Actions to dispatch
+     * @returns A promise indicating that all actions have been processed.
+     */
+    dispatchAll(actions: Action[]): Promise<void>;
+    dispatchAll(...actions: Action[]): Promise<void>;
+
+    /**
+     * Processes all given actions, by dispatching them to the corresponding handlers, after the next model update.
+     * The given actions are queued until the next model update cycle has been completed i.e. an
+     * `UpdateModelAction` has been dispatched and processed by this action dispatcher.
+     *
+     * @param actions The actions that should be dispatched after the next model update
+     */
+    dispatchAfterNextUpdate(actions: Action[]): void;
+    dispatchAfterNextUpdate(...actions: Action[]): void;
+}
+
+@injectable()
+export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
+    @inject(ActionHandlerRegistry)
+    protected actionHandlerRegistry: ActionHandlerRegistry;
+
+    @inject(ClientActionKinds)
+    protected clientActionKinds: string[];
+
+    @inject(Logger)
+    private logger: Logger;
+
+    @inject(ClientId)
+    protected clientId: string;
+
+    protected actionQueue = new PromiseQueue();
+    protected postUpdateQueue: Action[] = [];
+
+    dispatch(action: Action): Promise<void> {
+        // Dont queue actions that are just delegated to the client
+        if (this.clientActionKinds.includes(action.kind)) {
+            return this.doDispatch(action);
+        }
+        return this.actionQueue.enqueue(() => this.doDispatch(action));
+    }
+
+    protected async doDispatch(action: Action): Promise<void> {
+        this.logger.debug('Dispatch action:', action.kind);
+        const actionHandlers = this.actionHandlerRegistry.get(action.kind);
+        if (actionHandlers.length === 0) {
+            throw new GLSPServerError(`No handler registered for action kind: ${action.kind}`);
+        }
+
+        const responses: Action[] = [];
+        for (const handler of actionHandlers) {
+            const response = await this.executeHandler(handler, action);
+            responses.push(...response);
+        }
+
+        if (UpdateModelAction.is(action) && this.postUpdateQueue.length > 0) {
+            responses.push(...this.postUpdateQueue);
+            this.postUpdateQueue = [];
+        }
+
+        await this.dispatchResponses(responses);
+    }
+
+    protected async executeHandler(handler: ActionHandler, request: Action): Promise<Action[]> {
+        const responseActions = await handler.execute(request);
+        return responseActions.map(action => respond(request, action));
+    }
+
+    protected dispatchResponses(actions: Action[]): Promise<void> {
+        if (actions.length === 0) {
+            return Promise.resolve();
+        }
+        const responseQueue = new PromiseQueue();
+        const responses = actions.map(action => responseQueue.enqueue(() => this.doDispatch(action)));
+        return Promise.all(responses).then(() => Promise.resolve());
+    }
+
+    dispatchAll(...actions: MaybeArray<Action>[]): Promise<void> {
+        if (actions.length === 0) {
+            return Promise.resolve();
+        }
+        const flat: Action[] = [];
+        flatPush(flat, actions);
+        return Promise.all(flat.map(action => this.dispatch(action))).then(() => Promise.resolve());
+    }
+
+    dispatchAfterNextUpdate(...actions: MaybeArray<Action>[]): void {
+        if (actions.length !== 0) {
+            flatPush(this.postUpdateQueue, actions);
+        }
+    }
+
+    dispose(): void {
+        this.actionQueue.clear();
+    }
+}
+
+/**
+ * Transfers the {@link RequestAction.requestId id} from request to response if applicable.
+ *
+ * @param request  potential {@link RequestAction}
+ * @param response potential {@link ResponseAction}
+ * @returns given response action with id set if applicable
+ */
+export function respond(request: Action, response: Action): Action {
+    if (RequestAction.is(request) && ResponseAction.is(response)) {
+        (response as any).responseId = request.requestId;
+    }
+    return response;
+}

package/src/common/actions/action-handler-registry.spec.ts

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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
+ * 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 * as mock from '../test/mock-util';
+import { ActionHandlerRegistry } from './action-handler-registry';
+import { expect } from 'chai';
+
+describe('Test ActionHandlerRegistry (only functionality that is not covered by "registry.spec.ts"', () => {
+    const singleAction = 'singleHandledAction';
+    const multiAction = 'multiHandledAction';
+
+    const h1 = new mock.StubActionHandler([singleAction]);
+    const h2 = new mock.StubActionHandler([multiAction]);
+    const h3 = new mock.StubActionHandler([multiAction]);
+    const h4 = new mock.StubActionHandler([multiAction]);
+    const registry: ActionHandlerRegistry = new ActionHandlerRegistry();
+
+    it('registerHandler - should register given handlers', () => {
+        // setup
+        registry.registerHandler(h1);
+        registry.registerHandler(h2);
+        registry.registerHandler(h3);
+        registry.registerHandler(h4);
+
+        const result = registry.getAll();
+        expect(result).to.have.length(4);
+        expect(result.includes(h1)).true;
+        expect(result.includes(h2)).true;
+        expect(result.includes(h3)).true;
+        expect(result.includes(h4)).true;
+    });
+
+    it('get - should return three handlers sorted by priority', () => {
+        const result = registry.get(multiAction);
+        expect(result.length).to.be.equal(3);
+        expect(result[0]).to.be.deep.equal(h4);
+        expect(result[1]).to.be.deep.equal(h2);
+        expect(result[2]).to.be.deep.equal(h3);
+    });
+});

package/src/common/actions/action-handler-registry.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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
+ * 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 { Args } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ClientSessionInitializer } from '../session/client-session-initializer';
+import { MultiRegistry } from '../utils/registry';
+import { ActionHandler, ActionHandlerConstructor, ActionHandlerFactory } from './action-handler';
+
+/**
+ * An action handler registry keeps track of registered action handlers for a certain action.
+ */
+@injectable()
+export class ActionHandlerRegistry extends MultiRegistry<string, ActionHandler> {
+    registerHandler(handler: ActionHandler): void {
+        return handler.actionKinds.forEach(kind => this.register(kind, handler));
+    }
+
+    /**
+     * Retrieve all registered {@link ActionHandler}s that can handle the given action.
+     * The resulting list is ordered descending using {@link ActionHandler.getPriority}.
+     *
+     * @param action The action
+     * @returns A list of all registered handlers that can handle the given action.
+     */
+    override get(key: string): ActionHandler[] {
+        const result = super.get(key);
+        return result.sort((a, b) => a.priority ?? 0 - (b.priority ?? 0));
+    }
+}
+
+@injectable()
+export class ActionHandlerRegistryInitializer implements ClientSessionInitializer {
+    @inject(ActionHandlerFactory)
+    protected factory: ActionHandlerFactory;
+
+    @inject(ActionHandlerConstructor)
+    @optional()
+    protected handlerConstructors: ActionHandlerConstructor[] = [];
+
+    @inject(ActionHandlerRegistry)
+    protected registry: ActionHandlerRegistry;
+
+    initialize(_args?: Args): void {
+        const handlers = this.handlerConstructors.map(constructor => this.factory(constructor));
+        handlers.forEach(handler => this.registry.registerHandler(handler));
+    }
+}

package/src/common/actions/action-handler.ts

@@ -0,0 +1,62 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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
+ * 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, MaybePromise } from '@eclipse-glsp/protocol';
+import { interfaces } from 'inversify';
+
+export const ActionHandler = Symbol('ActionHandler');
+
+/**
+ * An action handler can execute certain {@link Action} types that are dispatched by the
+ * {@link ActionDispatcher}. The action handler processes the action in the {@link ActionHandler.execute()}
+ * method and returns a list of response actions to be dispatched as a result of processing the original action.
+ * One action handler can handle multiple different action types, see {@link ActionHandler.actionKinds}.
+ */
+export interface ActionHandler {
+    /**
+     * Returns the list of action kinds that can be handled by this action handler.
+     *
+     * @returns A list of action kind strings.
+     */
+    actionKinds: string[];
+
+    /**
+     * Executes the action handler for the given {@link Action} and returns a list of response actions that should be
+     * dispatched as a result of processing the original action. This list can be empty, if no more actions need to be
+     * executed.
+     *
+     * @param action The action that should be processed.
+     * @returns A list of response actions that should be dispatched.
+     */
+    execute(action: Action, ...args: unknown[]): MaybePromise<Action[]>;
+
+    /**
+     * Returns the priority of this action handler. The priority is used to derive the execution order if multiple
+     * action handlers should execute the same {@link Action}. The default priority is `0` and the priority is sorted
+     * descending. This means handlers with a priority &gt; 0 are executed before handlers with a default priority and
+     * handlers with a priority &lt; 0 are executed afterwards.
+     *
+     * @returns the priority as integer.
+     */
+    priority?: number;
+}
+
+export const ActionHandlerConstructor = Symbol('ActionHandlerConstructor');
+
+export type ActionHandlerConstructor = interfaces.Newable<ActionHandler>;
+
+export const ActionHandlerFactory = Symbol('ActionHandlerFactory');
+
+export type ActionHandlerFactory = (constructor: ActionHandlerConstructor) => ActionHandler;