@eclipse-glsp/server 1.1.0-RC05

package/src/common/gmodel/gmodel-diagram-module.ts

@@ -0,0 +1,76 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { ActionHandlerConstructor } from '../actions/action-handler';
+import { BindingTarget } from '../di/binding-target';
+import { DiagramModule } from '../di/diagram-module';
+import { InstanceMultiBinding } from '../di/multi-binding';
+import { RequestClipboardDataActionHandler } from '../features/clipboard/request-clipboard-data-action-handler';
+import { GModelFactory, GModelFactoryNullImpl } from '../features/model/gmodel-factory';
+import { DefaultModelState, ModelState } from '../features/model/model-state';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { OperationHandler, OperationHandlerConstructor } from '../operations/operation-handler';
+import { GModelApplyLabelEditOperationHandler } from './apply-label-edit-operation-handler';
+import { GModelChangeBoundsOperationHandler } from './change-bounds-operation-handler';
+import { GModelChangeRoutingPointsOperationHandler } from './change-routing-points-operation-handler';
+import { GModelCutOperationHandler } from './cut-operation-handler';
+import { GModelDeleteOperationHandler } from './delete-operation-handler';
+import { GModelPasteOperationHandler } from './paste-operation-handler';
+import { GModelReconnectEdgeOperationHandler } from './reconnect-edge-operation-handler';
+
+/**
+ * Extension of the {@link DiagramModule} to provide GModel integration.
+ *
+ * Contains all bindings of {@link DiagramModule}.
+ *
+ * Additionally binds:
+ * - {@link GModelFactory} to {@link GModelFactoryNullImpl}
+ * - {@link RequestClipboardDataActionHandler} to {@link ActionHandler}
+ * - {@link GModelApplyLabelEditOperationHandler} to {@link OperationHandler}
+ * - {@link GModelChangeBoundsOperationHandler} to {@link OperationHandler}
+ * - {@link GModelCutOperationHandler} to {@link OperationHandler}
+ * - {@link GModelDeleteOperationHandler} to {@link OperationHandler}
+ * - {@link GModelPasteOperationHandler} to {@link OperationHandler}
+ * - {@link GModelReconnectEdgeOperationHandler} to {@link OperationHandler}
+ * - {@link GModelChangeRoutingPointsOperationHandler} to {@link OperationHandler}
+
+ */
+@injectable()
+export abstract class GModelDiagramModule extends DiagramModule {
+    protected override bindGModelFactory(): BindingTarget<GModelFactory> {
+        return GModelFactoryNullImpl;
+    }
+
+    protected bindModelState(): BindingTarget<ModelState> {
+        return DefaultModelState;
+    }
+
+    protected override configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
+        super.configureActionHandlers(binding);
+        binding.add(RequestClipboardDataActionHandler);
+    }
+
+    protected override configureOperationHandlers(binding: InstanceMultiBinding<OperationHandlerConstructor>): void {
+        super.configureOperationHandlers(binding);
+        binding.add(GModelApplyLabelEditOperationHandler);
+        binding.add(GModelChangeBoundsOperationHandler);
+        binding.add(GModelCutOperationHandler);
+        binding.add(GModelDeleteOperationHandler);
+        binding.add(GModelPasteOperationHandler);
+        binding.add(GModelReconnectEdgeOperationHandler);
+        binding.add(GModelChangeRoutingPointsOperationHandler);
+    }
+}

package/src/common/gmodel/gmodel-operation-handler.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GModelRecordingCommand } from '../command/recording-command';
+import { GModelSerializer } from '../features/model/gmodel-serializer';
+import { OperationHandler } from '../operations/operation-handler';
+
+injectable();
+export abstract class GModelOperationHandler extends OperationHandler {
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
+    protected commandOf(runnable: () => void): Command {
+        return new GModelRecordingCommand(this.modelState, this.serializer, runnable);
+    }
+}

package/src/common/gmodel/index.ts

@@ -0,0 +1,27 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+export * from './apply-label-edit-operation-handler';
+export * from './change-bounds-operation-handler';
+export * from './change-routing-points-operation-handler';
+export * from './cut-operation-handler';
+export * from './delete-operation-handler';
+export * from './gmodel-create-edge-operation-handler';
+export * from './gmodel-create-node-operation-handler';
+export * from './gmodel-diagram-module';
+export * from './gmodel-operation-handler';
+export * from './paste-operation-handler';
+export * from './reconnect-edge-operation-handler';

package/src/common/gmodel/paste-operation-handler.ts

@@ -0,0 +1,127 @@
+/********************************************************************************
+ * 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 { GBoundsAware, GEdge, GModelElement, isGBoundsAware } from '@eclipse-glsp/graph';
+import { EditorContext, MaybePromise, PasteOperation, Point, SModelElementSchema } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import * as uuid from 'uuid';
+import { Command } from '../command/command';
+import { GModelSerializer } from '../features/model/gmodel-serializer';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+@injectable()
+export class GModelPasteOperationHandler extends GModelOperationHandler {
+    operationType = PasteOperation.KIND;
+
+    protected readonly DEFAULT_OFFSET = 20;
+
+    @inject(GModelSerializer)
+    protected modelSerializer: GModelSerializer;
+
+    createCommand(operation: PasteOperation): MaybePromise<Command | undefined> {
+        const elements = this.getCopiedElements(operation.clipboardData['application/json']);
+        return elements.length > 0 //
+            ? this.commandOf(() => this.executePaste(elements, operation.editorContext))
+            : undefined;
+    }
+
+    protected getCopiedElements(jsonString: string): GModelElement[] {
+        const schemas: SModelElementSchema[] = JSON.parse(jsonString);
+        return schemas.map(schema => this.modelSerializer.createElement(schema, this.modelState.root));
+    }
+
+    protected executePaste(elements: GModelElement[], context: EditorContext): MaybePromise<void> {
+        shift(elements, this.computeOffset(elements, context.lastMousePosition));
+
+        const idMap = this.reassignIds(elements);
+        this.filterElements(elements, idMap);
+        this.rewireEdges(elements, idMap);
+
+        this.modelState.root.children.push(...elements);
+    }
+
+    protected computeOffset(elements: GModelElement[], lastMousePosition?: Point): Point {
+        const offset = { x: this.DEFAULT_OFFSET, y: this.DEFAULT_OFFSET };
+        if (lastMousePosition) {
+            const referenceElement = this.getReferenceElementForPasteOffset(elements);
+            if (referenceElement) {
+                const position = referenceElement.position ?? Point.ORIGIN;
+                offset.x = lastMousePosition.x - position.x;
+                offset.y = lastMousePosition.y - position.y;
+            }
+        }
+        return offset;
+    }
+
+    protected getReferenceElementForPasteOffset(elements: GModelElement[]): GBoundsAware | undefined {
+        let minY = Number.MAX_VALUE;
+        for (const element of elements) {
+            if (isGBoundsAware(element)) {
+                const position = element.position ?? Point.ORIGIN;
+                if (minY > position.y) {
+                    minY = position.y;
+                    return element;
+                }
+            }
+        }
+        return undefined;
+    }
+
+    protected reassignIds(elements: GModelElement[]): Map<string, string> {
+        const idMap = new Map<string, string>();
+        elements.forEach(element => {
+            const newId = uuid.v4();
+            idMap.set(element.id, newId);
+            element.id = newId;
+            const childMap = this.reassignIds(element.children);
+            childMap.forEach((value, key) => {
+                idMap.set(key, value);
+            });
+        });
+        return idMap;
+    }
+
+    protected filterElements(elements: GModelElement[], idMap: Map<string, string>): void {
+        elements.filter(e => !this.shouldExcludeElement(e, idMap));
+    }
+
+    protected shouldExcludeElement(element: GModelElement, idMap: Map<string, string>): boolean {
+        return false;
+    }
+
+    protected rewireEdges(elements: GModelElement[], idMap: Map<string, string>): void {
+        const edges = elements.filter(element => element instanceof GEdge) as GEdge[];
+        edges.forEach(edge => {
+            const sourceId = idMap.get(edge.sourceId);
+            if (sourceId) {
+                edge.sourceId = sourceId;
+            }
+            const targetId = idMap.get(edge.targetId);
+            if (targetId) {
+                edge.targetId = targetId;
+            }
+        });
+    }
+}
+
+export function shift(elements: GModelElement[], offset: Point): void {
+    elements
+        .filter(element => isGBoundsAware(element))
+        .map(element => element as unknown as GBoundsAware)
+        .forEach(gBoundsAware => {
+            const position = gBoundsAware.position ?? Point.ORIGIN;
+            gBoundsAware.position = { x: position.x + offset.x, y: position.y + offset.y };
+        });
+}

package/src/common/gmodel/reconnect-edge-operation-handler.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * 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 { GEdge, GNode, GPort } from '@eclipse-glsp/graph';
+import { MaybePromise, ReconnectEdgeOperation } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GLSPServerError } from '../utils/glsp-server-error';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+@injectable()
+export class GModelReconnectEdgeOperationHandler extends GModelOperationHandler {
+    operationType = ReconnectEdgeOperation.KIND;
+
+    createCommand(operation: ReconnectEdgeOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeReconnect(operation));
+    }
+
+    executeReconnect(operation: ReconnectEdgeOperation): MaybePromise<void> {
+        if (!operation.edgeElementId || !operation.sourceElementId || !operation.targetElementId) {
+            throw new GLSPServerError('Incomplete reconnect connection action');
+        }
+
+        const index = this.modelState.index;
+
+        const edge = index.findByClass(operation.edgeElementId, GEdge);
+        const source = index.findByClass(operation.sourceElementId, GNode || GPort);
+        const target = index.findByClass(operation.targetElementId, GNode || GPort);
+
+        if (!edge) {
+            throw new Error(`Invalid edge: edge ID ${operation.edgeElementId}`);
+        }
+        if (!source) {
+            throw new Error(`Invalid source: source ID ${operation.sourceElementId}`);
+        }
+        if (!target) {
+            throw new Error(`Invalid target: target ID ${operation.targetElementId}`);
+        }
+
+        edge.sourceId = source.id;
+        edge.targetId = target.id;
+        edge.routingPoints = [];
+    }
+}

package/src/common/index.ts

@@ -0,0 +1,89 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+export * from '@eclipse-glsp/graph';
+export * from '@eclipse-glsp/protocol';
+export * from './actions/action-dispatcher';
+export * from './actions/action-handler';
+export * from './actions/action-handler-registry';
+export * from './actions/client-action-handler';
+export * from './actions/global-action-provider';
+export * from './command/command';
+export * from './command/command-stack';
+export * from './di/binding-target';
+export * from './di/client-session-module';
+export * from './di/diagram-module';
+export * from './di/glsp-module';
+export * from './di/multi-binding';
+export * from './di/server-module';
+export * from './di/service-identifiers';
+export * from './diagram/diagram-configuration';
+export * from './diagram/request-type-hints-action-handler';
+export * from './features/clipboard/request-clipboard-data-action-handler';
+export * from './features/contextactions/command-palette-action-provider';
+export * from './features/contextactions/context-actions-provider';
+export * from './features/contextactions/context-actions-provider-registry';
+export * from './features/contextactions/context-menu-item-provider';
+export * from './features/contextactions/request-context-actions-handler';
+export * from './features/contextactions/tool-palette-item-provider';
+export * from './features/directediting/context-edit-validator';
+export * from './features/directediting/context-edit-validator-registry';
+export * from './features/directediting/label-edit-validator';
+export * from './features/directediting/request-edit-validation-handler';
+export * from './features/layout/computed-bounds-action-handler';
+export * from './features/layout/layout-engine';
+export * from './features/layout/layout-operation-handler';
+export * from './features/model/gmodel-factory';
+export * from './features/model/gmodel-index';
+export * from './features/model/gmodel-serializer';
+export * from './features/model/model-state';
+export * from './features/model/model-submission-handler';
+export * from './features/model/request-model-action-handler';
+export * from './features/model/save-model-action-handler';
+export * from './features/model/source-model-storage';
+export * from './features/navigation/json-opener-options';
+export * from './features/navigation/navigation-target-provider';
+export * from './features/navigation/navigation-target-provider-registry';
+export * from './features/navigation/navigation-target-resolution';
+export * from './features/navigation/navigation-target-resolver';
+export * from './features/navigation/request-navigation-targets-action-handler';
+export * from './features/navigation/resolve-navigation-targets-action-handler';
+export * from './features/popup/popup-model-factory';
+export * from './features/popup/request-popup-model-action-handler';
+export * from './features/validation/model-validator';
+export * from './features/validation/request-markers-handler';
+export * from './gmodel/cut-operation-handler';
+export * from './gmodel/index';
+export * from './launch/glsp-server-launcher';
+export * from './operations/compound-operation-handler';
+export * from './operations/create-operation-handler';
+export * from './operations/operation-action-handler';
+export * from './operations/operation-handler';
+export * from './operations/operation-handler-registry';
+export * from './protocol/glsp-client-proxy';
+export * from './protocol/glsp-server';
+export * from './protocol/glsp-server-listener';
+export * from './session/client-session';
+export * from './session/client-session-factory';
+export * from './session/client-session-initializer';
+export * from './session/client-session-listener';
+export * from './session/client-session-manager';
+export * from './utils/args-util';
+export * from './utils/client-options-util';
+export * from './utils/glsp-server-error';
+export * from './utils/logger';
+export * from './utils/promise-queue';
+export * from './utils/registry';

package/src/common/launch/glsp-server-launcher.ts

@@ -0,0 +1,70 @@
+/********************************************************************************
+ * 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 { MaybePromise } from '@eclipse-glsp/protocol';
+import { Container, ContainerModule, inject, injectable, optional } from 'inversify';
+import { ServerModule } from '../di/server-module';
+import { InjectionContainer } from '../di/service-identifiers';
+import { Logger } from '../utils/logger';
+
+export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed';
+
+@injectable()
+export abstract class GLSPServerLauncher<T = undefined> {
+    @inject(Logger) protected logger: Logger;
+
+    protected _modules: ContainerModule[] = [];
+    protected running: boolean;
+
+    @inject(InjectionContainer) @optional() protected parentContainer?: Container;
+
+    configure(serverModule: ServerModule, ...additionalModules: ContainerModule[]): void {
+        this._modules.push(serverModule, ...additionalModules);
+    }
+
+    createContainer(): Container {
+        const container = this.parentContainer ? this.parentContainer.createChild() : new Container();
+        container.load(...this._modules);
+        return container;
+    }
+
+    start(startParams?: T): MaybePromise<void> {
+        if (!this.running) {
+            this.running = true;
+            return this.run(startParams);
+        }
+        this.logger.warn('Could not start launcher. Launcher is already running!');
+    }
+
+    protected abstract run(startParams?: T): MaybePromise<void>;
+
+    shutdown(): MaybePromise<void> {
+        if (this.running) {
+            const result = this.stop();
+            this.running = false;
+            return result;
+        }
+        this.logger.warn('Could not stop launcher. Launcher is not running!');
+    }
+
+    protected abstract stop(): MaybePromise<void>;
+
+    get modules(): ContainerModule[] {
+        if (!this._modules) {
+            throw new Error('The GLSPServerLauncher has not been configured yet');
+        }
+        return this._modules;
+    }
+}

package/src/common/operations/compound-operation-handler.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * 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 { CompoundOperation } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { Command, CompoundCommand } from '../command/command';
+import { OperationHandler } from './operation-handler';
+import { OperationHandlerRegistry } from './operation-handler-registry';
+
+@injectable()
+export class CompoundOperationHandler extends OperationHandler {
+    @inject(OperationHandlerRegistry)
+    protected operationHandlerRegistry: OperationHandlerRegistry;
+
+    operationType = CompoundOperation.KIND;
+
+    async createCommand(operation: CompoundOperation): Promise<Command | undefined> {
+        const maybeCommands = operation.operationList.map(op => this.operationHandlerRegistry.getExecutableCommand(op));
+        const commands: Command[] = [];
+
+        for await (const command of maybeCommands) {
+            if (command) {
+                commands.push(command);
+            }
+        }
+        return new CompoundCommand(commands);
+    }
+}

package/src/common/operations/create-operation-handler.ts

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * 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 {
+    CreateEdgeOperation,
+    CreateNodeOperation,
+    hasArrayProp,
+    hasFunctionProp,
+    hasStringProp,
+    TriggerEdgeCreationAction,
+    TriggerNodeCreationAction
+} from '@eclipse-glsp/protocol';
+import { OperationHandler } from './operation-handler';
+
+/**
+ * A special {@link OperationHandler} that is responsible for the handling of {@link CreateOperation}s. Depending on its
+ * operation type the triggered actions are {@link TriggerNodeCreationAction} or {@link TriggerEdgeCreationAction}s.
+ */
+export interface CreateOperationHandler extends OperationHandler {
+    readonly label: string;
+    elementTypeIds: string[];
+    operationType: CreateOperationKind;
+    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[];
+}
+
+export type CreateOperationKind = typeof CreateNodeOperation.KIND | typeof CreateEdgeOperation.KIND;
+
+export namespace CreateOperationHandler {
+    export function is(object: unknown): object is CreateOperationHandler {
+        return (
+            object instanceof OperationHandler &&
+            hasStringProp(object, 'label') &&
+            hasArrayProp(object, 'elementTypeIds') &&
+            hasFunctionProp(object, 'getTriggerActions')
+        );
+    }
+}

package/src/common/operations/operation-action-handler.ts

@@ -0,0 +1,93 @@
+/********************************************************************************
+ * 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, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../actions/action-handler';
+import { Command } from '../command/command';
+import { CommandStack } from '../command/command-stack';
+import { Operations } from '../di/service-identifiers';
+import { ModelState } from '../features/model/model-state';
+import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
+import { GLSPServerError } from '../utils/glsp-server-error';
+import { OperationHandler } from './operation-handler';
+import { OperationHandlerRegistry } from './operation-handler-registry';
+
+@injectable()
+export class OperationActionHandler implements ActionHandler {
+    @inject(OperationHandlerRegistry)
+    protected operationHandlerRegistry: OperationHandlerRegistry;
+
+    @inject(ModelSubmissionHandler)
+    protected modelSubmissionHandler: ModelSubmissionHandler;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(CommandStack)
+    protected commandStack: CommandStack;
+
+    constructor(@inject(Operations) readonly actionKinds: string[]) {}
+
+    execute(action: Operation): MaybePromise<Action[]> {
+        if (!this.handles(action)) {
+            throw new GLSPServerError(`Unhandled operation kind: ${action.kind}`);
+        }
+        if (this.modelState.isReadonly) {
+            return [
+                ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
+                    severity: 'WARNING'
+                })
+            ];
+        }
+        return this.executeOperation(action);
+    }
+
+    protected executeOperation(operation: Operation): MaybePromise<Action[]> {
+        const operationHandler = OperationActionHandler.getOperationHandler(operation, this.operationHandlerRegistry);
+        if (operationHandler) {
+            return this.executeHandler(operation, operationHandler);
+        }
+        return [];
+    }
+
+    protected async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
+        const command = await handler.execute(operation);
+        if (command) {
+            this.executeCommand(command);
+        }
+        return this.modelSubmissionHandler.submitModel('operation');
+    }
+
+    protected executeCommand(command: Command): void {
+        this.commandStack.execute(command);
+    }
+
+    protected submitModel(): MaybePromise<Action[]> {
+        return this.modelSubmissionHandler.submitModel('operation');
+    }
+
+    handles(action: Action): boolean {
+        return this.actionKinds.includes(action.kind);
+    }
+
+    /**
+     *  @Deprecated Use {@link OperationHandlerRegistry#getOperationHandler(Operation) instead}.
+     */
+
+    static getOperationHandler(operation: Operation, registry: OperationHandlerRegistry): OperationHandler | undefined {
+        return registry.getOperationHandler(operation);
+    }
+}