@eclipse-glsp/server 1.1.0-RC05

package/src/common/features/popup/request-popup-model-action-handler.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 { Action, MaybePromise, RequestPopupModelAction, SetPopupModelAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+import { Logger } from '../../utils/logger';
+import { GModelSerializer } from '../model/gmodel-serializer';
+import { ModelState } from '../model/model-state';
+import { PopupModelFactory } from './popup-model-factory';
+
+@injectable()
+export class RequestPopupModelActionHandler implements ActionHandler {
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(PopupModelFactory)
+    @optional()
+    protected popupModelFactory?: PopupModelFactory;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(GModelSerializer)
+    protected modelSerializer: GModelSerializer;
+
+    actionKinds = [RequestPopupModelAction.KIND];
+
+    execute(action: RequestPopupModelAction): MaybePromise<Action[]> {
+        if (this.popupModelFactory) {
+            const hoverElement = this.modelState.index.find(action.elementId);
+            if (hoverElement) {
+                const popupModel = this.popupModelFactory.createPopupModel(hoverElement, action);
+                if (popupModel) {
+                    const modelSchema = this.modelSerializer.createSchema(popupModel);
+                    return [SetPopupModelAction.create(modelSchema)];
+                }
+                return [];
+            }
+            throw new GLSPServerError(`Could not process 'RequestPopupModelAction'. Hover element with id ${action.elementId} not found`);
+        }
+        this.logger.warn('Could not process `RequestPopupModelAction`. No `PopupModelFactory` is bound');
+        return [];
+    }
+
+    priority?: number | undefined;
+}

package/src/common/features/validation/model-validator.ts

@@ -0,0 +1,34 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/graph';
+import { Marker, MaybePromise } from '@eclipse-glsp/protocol';
+
+export const ModelValidator = Symbol('ModelValidator');
+
+/**
+ * Validates a list of {@link GModelElement}s based on a set of validation rules and returns corresponding issue
+ * {@link Marker}s.
+ * An issue marker is a serializable description of the validation violation that can be visualized by the GLSP client.
+ */
+export interface ModelValidator {
+    /**
+     * Validates the given list of {@link GModelElement}s and returns a list of {@link Marker}s.
+     *
+     * @param elements The list of {@link GModelElement} to validate.
+     * @returns A list of {@link Marker}s for the validated {@link GModelElement}s.
+     */
+    validate(elements: GModelElement[]): MaybePromise<Marker[]>;
+}

package/src/common/features/validation/request-markers-handler.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * 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 { GGraph } from '@eclipse-glsp/graph';
+import { Action, Marker, RequestMarkersAction, SetMarkersAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+import { ModelState } from '../model/model-state';
+import { ModelValidator } from './model-validator';
+
+@injectable()
+export class RequestMarkersHandler implements ActionHandler {
+    actionKinds = [RequestMarkersAction.KIND];
+
+    @inject(ModelValidator) @optional() validator: ModelValidator;
+    @inject(ModelState) modelState: ModelState;
+
+    async execute(action: RequestMarkersAction): Promise<Action[]> {
+        let elementIDs = action.elementsIDs;
+        if (!this.validator) {
+            throw new GLSPServerError('Cannot compute markers! No implementation for ModelValidator has been bound');
+        }
+
+        if (!elementIDs || elementIDs.length === 0 || (elementIDs.length === 1 && elementIDs[0] === 'EMPTY')) {
+            elementIDs = [this.modelState.root.id];
+        }
+
+        let markers: Marker[] = [];
+        const currentModelIndex = this.modelState.index;
+        for (const elementID of elementIDs) {
+            const modelElement = currentModelIndex.findByClass(elementID, GGraph);
+            if (modelElement) {
+                markers = markers.concat(await this.validator.validate([modelElement]));
+            }
+        }
+        return [SetMarkersAction.create(markers)];
+    }
+}

package/src/common/gmodel/README.md

@@ -0,0 +1,7 @@
+# Eclipse GLSP - Node Server
+
+## Direct GModel Library
+
+A collection of reusable base handlers and services to implement GLSP diagram languages directly use the graphical model as source model.
+This means the source model is a serializable representation of the graphical model. All operation and action handlers are operating
+directly on the graphical model.

package/src/common/gmodel/apply-label-edit-operation-handler.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * 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 { GLabel } from '@eclipse-glsp/graph';
+import { ApplyLabelEditOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { getOrThrow } from '../utils/glsp-server-error';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+@injectable()
+export class GModelApplyLabelEditOperationHandler extends GModelOperationHandler {
+    readonly operationType = ApplyLabelEditOperation.KIND;
+
+    createCommand(operation: ApplyLabelEditOperation): MaybePromise<Command | undefined> {
+        const label = getOrThrow(
+            this.modelState.index.findByClass(operation.labelId, GLabel),
+            'Element with provided ID cannot be found or is not a GLabel'
+        );
+        return label.text !== operation.text //
+            ? this.commandOf(() => (label.text = operation.text))
+            : undefined;
+    }
+}

package/src/common/gmodel/change-bounds-operation-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 { GModelRoot, GNode } from '@eclipse-glsp/graph';
+import { ChangeBoundsOperation, Dimension, MaybePromise, Point } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+/**
+ * Applies {@link ChangeBoundsOperation} directly to the GModel.
+ */
+@injectable()
+export class GModelChangeBoundsOperationHandler extends GModelOperationHandler {
+    operationType = ChangeBoundsOperation.KIND;
+
+    createCommand(operation: ChangeBoundsOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeChangeBounds(operation));
+    }
+
+    protected executeChangeBounds(operation: ChangeBoundsOperation): void {
+        for (const element of operation.newBounds) {
+            this.changeElementBounds(element.elementId, element.newSize, element.newPosition);
+        }
+    }
+
+    protected changeElementBounds(elementId: string, newSize: Dimension, newPosition: Point | undefined): void {
+        const index = this.modelState.index;
+        const nodeToUpdate = index.findByClass(elementId, GNode);
+        if (!nodeToUpdate) {
+            return;
+        }
+
+        const parent = nodeToUpdate.parent;
+        let positionToSet = { x: 0, y: 0 };
+        if (newPosition) {
+            positionToSet = parent instanceof GModelRoot ? newPosition : { x: Math.max(0, newPosition.x), y: Math.max(0, newPosition.y) };
+        }
+        if (nodeToUpdate.layout) {
+            if (!nodeToUpdate.layoutOptions) {
+                nodeToUpdate.layoutOptions = {};
+            }
+            nodeToUpdate.layoutOptions['prefWidth'] = newSize.width;
+            nodeToUpdate.layoutOptions['prefHeight'] = newSize.height;
+        }
+
+        nodeToUpdate.size = newSize;
+        nodeToUpdate.position = positionToSet;
+    }
+}

package/src/common/gmodel/change-routing-points-operation-handler.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * 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 { ChangeRoutingPointsOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GLSPServerError } from '../utils/glsp-server-error';
+import { applyRoutingPoints } from '../utils/layout-util';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+@injectable()
+export class GModelChangeRoutingPointsOperationHandler extends GModelOperationHandler {
+    operationType = ChangeRoutingPointsOperation.KIND;
+
+    createCommand(operation: ChangeRoutingPointsOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeChangeRoutingPoints(operation));
+    }
+
+    executeChangeRoutingPoints(operation: ChangeRoutingPointsOperation): MaybePromise<void> {
+        if (!operation.newRoutingPoints) {
+            throw new GLSPServerError('Incomplete change routingPoints  action');
+        }
+
+        const index = this.modelState.index;
+        operation.newRoutingPoints.forEach(routingPoints => applyRoutingPoints(routingPoints, index));
+    }
+}

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

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * 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 { CutOperation, DeleteElementOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionDispatcher } from '../actions/action-dispatcher';
+import { Command } from '../command/command';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+@injectable()
+export class GModelCutOperationHandler extends GModelOperationHandler {
+    readonly operationType = CutOperation.KIND;
+
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    createCommand(operation: CutOperation): MaybePromise<Command | undefined> {
+        const cuttableElementIds = this.getElementToCut(operation);
+        return cuttableElementIds.length > 0 //
+            ? this.commandOf(() => this.actionDispatcher.dispatch(DeleteElementOperation.create(cuttableElementIds)))
+            : undefined;
+    }
+
+    protected getElementToCut(cutOperation: CutOperation): string[] {
+        return cutOperation.editorContext.selectedElementIds;
+    }
+}

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

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * 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, GModelElement, GNode } from '@eclipse-glsp/graph';
+import { DeleteElementOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GModelIndex } from '../features/model/gmodel-index';
+import { Logger } from '../utils/logger';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+@injectable()
+export class GModelDeleteOperationHandler extends GModelOperationHandler {
+    @inject(Logger)
+    protected logger: Logger;
+
+    protected allDependentsIds: Set<string>;
+
+    get operationType(): string {
+        return DeleteElementOperation.KIND;
+    }
+
+    createCommand(operation: DeleteElementOperation): MaybePromise<Command | undefined> {
+        const elementIds = operation.elementIds;
+        if (!elementIds || elementIds.length === 0) {
+            this.logger.warn('Elements to delete are not specified');
+            return undefined;
+        }
+        return this.commandOf(() => this.deleteElements(elementIds));
+    }
+
+    deleteElements(elementIds: string[]): MaybePromise<void> {
+        if (!elementIds || elementIds.length === 0) {
+            this.logger.warn('Elements to delete are not specified');
+            return;
+        }
+        const index = this.modelState.index;
+        this.allDependentsIds = new Set<string>();
+        const success = elementIds.every(eId => this.delete(eId, index));
+        if (!success) {
+            this.logger.warn('Could not delete all elements as requested (see messages above to find out why)');
+        }
+    }
+
+    protected delete(elementId: string, index: GModelIndex): boolean {
+        if (this.allDependentsIds.has(elementId)) {
+            return true;
+        }
+
+        const element = index.find(elementId);
+        if (!element) {
+            this.logger.warn('Element not found: ' + elementId);
+            return false;
+        }
+
+        const nodeToDelete = this.findTopLevelElement(element);
+        if (!nodeToDelete.parent) {
+            this.logger.warn("The requested node doesn't have a parent; it can't be deleted");
+            return false;
+        }
+
+        const dependents = new Set<GModelElement>();
+        this.collectDependents(dependents, nodeToDelete);
+
+        dependents.forEach(dependant => {
+            const index = this.modelState.root.children.findIndex(element => element === dependant);
+            if (index > -1) {
+                this.modelState.root.children.splice(index, 1);
+            }
+            this.allDependentsIds.add(dependant.id);
+        });
+
+        return true;
+    }
+
+    protected collectDependents(dependents: Set<GModelElement>, nodeToDelete: GModelElement): void {
+        if (dependents.has(nodeToDelete)) {
+            return;
+        }
+
+        if (nodeToDelete.children.length > 0) {
+            nodeToDelete.children.forEach(child => this.collectDependents(dependents, child));
+        }
+
+        if (nodeToDelete instanceof GNode) {
+            const index = this.modelState.index;
+            index.getIncomingEdges(nodeToDelete).forEach(incoming => {
+                this.collectDependents(dependents, incoming);
+            });
+            index.getOutgoingEdges(nodeToDelete).forEach(outgoing => {
+                this.collectDependents(dependents, outgoing);
+            });
+        }
+
+        dependents.add(nodeToDelete);
+    }
+
+    protected findTopLevelElement(element: GModelElement): GModelElement {
+        if (element instanceof GNode || element instanceof GEdge) {
+            return element;
+        }
+
+        const parent = element.parent;
+        if (!parent) {
+            return element;
+        }
+        return this.findTopLevelElement(parent);
+    }
+}

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

@@ -0,0 +1,64 @@
+/********************************************************************************
+ * 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, GModelElement, GPort } from '@eclipse-glsp/graph';
+import { GNode } from '@eclipse-glsp/graph/lib/gnode';
+import { CreateEdgeOperation, MaybePromise, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { CreateOperationHandler, CreateOperationKind } from '../operations/create-operation-handler';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+/**
+ * An abstract base implementation of {@link CreateEdgeOperation} handlers for diagram implementations
+ * where the graphical model is also directly used as source model.
+ * (i.e. all operation handlers directly modify the graphical model).
+ */
+@injectable()
+export abstract class GModelCreateEdgeOperationHandler extends GModelOperationHandler implements CreateOperationHandler {
+    override readonly operationType: CreateOperationKind = CreateEdgeOperation.KIND;
+    abstract override label: string;
+    abstract elementTypeIds: string[];
+
+    override createCommand(operation: CreateEdgeOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeCreation(operation));
+    }
+
+    getTriggerActions(): TriggerEdgeCreationAction[] {
+        return this.elementTypeIds.map(typeId => TriggerEdgeCreationAction.create(typeId));
+    }
+
+    executeCreation(operation: CreateEdgeOperation): void {
+        const index = this.modelState.index;
+
+        const source = index.find(operation.sourceElementId, element => element instanceof GNode || element instanceof GPort);
+        const target = index.find(operation.targetElementId, element => element instanceof GNode || element instanceof GPort);
+
+        if (!source || !target) {
+            throw new Error(
+                `Invalid source or target for source ID ${operation.sourceElementId} and target ID ${operation.targetElementId}`
+            );
+        }
+
+        const connection = this.createEdge(source, target);
+        if (connection) {
+            const currentModel = this.modelState.root;
+            currentModel.children.push(connection);
+        }
+    }
+
+    abstract createEdge(source: GModelElement, target: GModelElement): GEdge | undefined;
+}

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

@@ -0,0 +1,95 @@
+/********************************************************************************
+ * 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 { GModelElement, GNode } from '@eclipse-glsp/graph';
+import { CreateNodeOperation, MaybePromise, Point, SelectAction, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionDispatcher } from '../actions/action-dispatcher';
+import { Command } from '../command/command';
+import { CreateOperationHandler, CreateOperationKind } from '../operations/create-operation-handler';
+import { getRelativeLocation } from '../utils/layout-util';
+import { GModelOperationHandler } from './gmodel-operation-handler';
+
+/**
+ * An abstract base implementation of {@link CreateNodeOperationHandler} for diagram implementations
+ * where the graphical model is also directly used as source model.
+ * (i.e. all operation handlers directly modify the graphical model).
+ */
+@injectable()
+export abstract class GModelCreateNodeOperationHandler extends GModelOperationHandler implements CreateOperationHandler {
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    abstract elementTypeIds: string[];
+
+    abstract override label: string;
+
+    override operationType: CreateOperationKind = CreateNodeOperation.KIND;
+
+    override createCommand(operation: CreateNodeOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeCreation(operation));
+    }
+
+    executeCreation(operation: CreateNodeOperation): void {
+        const container = this.getContainer(operation) ?? this.modelState.root;
+        const relativeLocation = this.getRelativeLocation(operation);
+        const element = this.createNode(operation, relativeLocation);
+        if (element) {
+            container.children.push(element);
+            element.parent = container;
+            this.actionDispatcher.dispatchAfterNextUpdate(SelectAction.create({ selectedElementsIDs: [element.id] }));
+        }
+    }
+
+    getTriggerActions(): TriggerNodeCreationAction[] {
+        return this.elementTypeIds.map(typeId => TriggerNodeCreationAction.create(typeId));
+    }
+
+    /**
+     * Return the GModelElement that will contain the newly created node. It is usually
+     * the target element ({@link CreateNodeOperation.containerId}), but could also
+     * be e.g. an intermediate compartment, or even a different Node.
+     *
+     * @param operation
+     * @return the GModelElement that will contain the newly created node.
+     */
+    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
+        const index = this.modelState.index;
+        return operation.containerId ? index.get(operation.containerId) : undefined;
+    }
+
+    getLocation(operation: CreateNodeOperation): Point | undefined {
+        return operation.location;
+    }
+
+    /**
+     * Retrieves the diagram absolute location and the target container from the given {@link CreateNodeOperation}
+     * and converts the absolute location to coordinates relative to the given container.
+     *  Relative coordinates can only be retrieved if the given container element is part of
+     * a hierarchy of {@link GBoundsAware} elements. This means each (recursive) parent element need to
+     * implement {@link GBoundsAware}. If that is not the case this method returns `undefined`.
+     * @param absoluteLocation The diagram absolute position.
+     * @param container The container element.
+     * @returns The relative position or `undefined`.
+     */
+    getRelativeLocation(operation: CreateNodeOperation): Point | undefined {
+        const container = this.getContainer(operation) ?? this.modelState.root;
+        const absoluteLocation = this.getLocation(operation) ?? Point.ORIGIN;
+        return getRelativeLocation(absoluteLocation, container);
+    }
+
+    abstract createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined;
+}