@eclipse-glsp/server 1.1.0-next.3d7585d.42 → 1.1.0-next.44aae0c.44

package/src/common/command/command.ts

@@ -14,26 +14,115 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+import { flatPush, MaybeArray, MaybePromise } from '@eclipse-glsp/protocol';
+
 /**
- * An interface that every command is expected to support.
- * A command can be executed, it can be undone, and can then be redone.
+ * A command implements a specific modification of the source model, which can be applied by invoking `execute()`.
+ * Commands may also provide implementations to `undo()` and `redo()` the effect they had.
+ * To maintain an order in which commands can be undone and redone, they are managed in the context of a {@link CommandStack}.
+ *
+ * Each command is self contained and stores all the information it needs to execute, undo or redo itself.
+ *
+ * In theory commands can be used to execute arbitrary activities and not only modify the source model.
+ * However, it is mostly used to record and manage changes made to the source model via GLSP operations.
  */
 export interface Command {
     /**
-     * Performs the command activity required for the effect.
+     * Performs the command activity required for the effect (e.g. source model change).
      */
-    execute(): void;
+    execute(): MaybePromise<void>;
 
     /**
      * Performs the command activity required to `undo` the effects of a preceding `execute` (or `redo`).
      * The effect, if any, of calling `undo` before `execute` or `redo` have been called, is undefined.
      */
-    undo(): void;
+    undo(): MaybePromise<void>;
 
     /**
      * Performs the command activity required to `redo` the effect after undoing the effect.
      * The effect, if any, of calling `redo` before `undo` is called is undefined.
-     * Note that if you implement `redo` to call `execute` then any derived class will be restricted by that decision also.
      */
-    redo(): void;
+    redo(): MaybePromise<void>;
+
+    /**
+     * Returns whether the command can be undone.
+     * This function is optional. If not implemented, it is assumed that the command can be undone.
+     * @returns whether the command can be undone
+     */
+    canUndo?(): boolean;
+}
+
+export namespace Command {
+    export function canUndo(command: Command): boolean {
+        return command.canUndo?.() ?? true;
+    }
+}
+
+/**
+ * A command that comprises a sequence of subcommands.
+ */
+export class CompoundCommand implements Command {
+    protected readonly commands: Command[];
+
+    constructor(commands: Command[]);
+    constructor(...commands: Command[]);
+    constructor(...commands: MaybeArray<Command>[]) {
+        this.commands = [];
+        flatPush(this.commands, commands);
+    }
+
+    async execute(): Promise<void> {
+        const alreadyExecuted: Command[] = [];
+
+        try {
+            for (const command of this.commands) {
+                await command.execute();
+                alreadyExecuted.unshift(command);
+            }
+        } catch (err) {
+            for (const command of alreadyExecuted) {
+                if (Command.canUndo(command)) {
+                    await command.undo();
+                } else {
+                    break;
+                }
+            }
+            throw err;
+        }
+    }
+
+    async undo(): Promise<void> {
+        const alreadyUndone: Command[] = [];
+        try {
+            for (const command of [...this.commands].reverse()) {
+                await command.undo();
+                alreadyUndone.unshift(command);
+            }
+        } catch (err) {
+            for (const command of alreadyUndone) {
+                await command.redo();
+            }
+            throw err;
+        }
+    }
+
+    async redo(): Promise<void> {
+        const alreadyRedone: Command[] = [];
+
+        try {
+            for (const command of this.commands) {
+                await command.redo();
+                alreadyRedone.unshift(command);
+            }
+        } catch (err) {
+            for (const command of alreadyRedone) {
+                await command.undo();
+            }
+            throw err;
+        }
+    }
+
+    canUndo(): boolean {
+        return this.commands.every(Command.canUndo);
+    }
 }

package/src/common/command/recording-command.spec.ts

@@ -0,0 +1,74 @@
+/********************************************************************************
+ * Copyright (c) 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 { AnyObject } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import { RecordingCommand } from './recording-command';
+
+interface TestModel {
+    string: string;
+    number: number;
+    flag: boolean;
+    maybe?: AnyObject;
+}
+
+let jsonObject: TestModel;
+
+describe('RecordingCommand', () => {
+    let beforeState: TestModel;
+
+    beforeEach(() => {
+        jsonObject = {
+            string: 'foo',
+            number: 0,
+            flag: true
+        };
+        beforeState = JSON.parse(JSON.stringify(jsonObject));
+    });
+
+    it('should be undoable after execution', async () => {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        const command = new RecordingCommand(jsonObject, () => {});
+        expect(command.canUndo()).to.be.false;
+        await command.execute();
+        expect(command.canUndo()).to.be.true;
+    });
+
+    it('should restore the pre execution state when undo is called', async () => {
+        const command = new RecordingCommand(jsonObject, () => {
+            jsonObject.string = 'bar';
+            jsonObject.flag = false;
+            jsonObject.maybe = { hello: 'world' };
+        });
+        await command.execute();
+        expect(jsonObject).to.not.be.deep.equals(beforeState);
+        await command.undo();
+        expect(jsonObject).to.be.deep.equals(beforeState);
+    });
+
+    it('should restore the post execution state when redo is called', async () => {
+        const command = new RecordingCommand(jsonObject, () => {
+            jsonObject.string = 'bar';
+            jsonObject.flag = false;
+            jsonObject.maybe = { hello: 'world' };
+        });
+        await command.execute();
+        const afterState = JSON.parse(JSON.stringify(jsonObject));
+        jsonObject = JSON.parse(JSON.stringify(afterState));
+        await command.redo();
+        expect(jsonObject).to.be.deep.equals(afterState);
+    });
+});

package/src/common/command/recording-command.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * Copyright (c) 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 { GModelRootSchema } from '@eclipse-glsp/graph';
+import { AnyObject, MaybePromise } from '@eclipse-glsp/protocol';
+import * as jsonPatch from 'fast-json-patch';
+import { GModelSerializer } from '../features/model/gmodel-serializer';
+import { ModelState } from '../features/model/model-state';
+import { Command } from './command';
+/**
+ * An abstract implementation for {@link Command} that should records changes made to a JSON object during execution.
+ * These changes are recorded in the form of json patches.
+ */
+export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> implements Command {
+    protected undoPatch?: jsonPatch.Operation[];
+    protected redoPatch?: jsonPatch.Operation[];
+
+    async execute(): Promise<void> {
+        const beforeState = this.deepClone(this.getJsonObject());
+        await this.doExecute();
+        const afterState = this.getJsonObject();
+        this.undoPatch = jsonPatch.compare(afterState, beforeState);
+        this.redoPatch = jsonPatch.compare(beforeState, afterState);
+    }
+
+    /**
+     * Retrieves the current state of the JSON object. Is called right before and
+     * right after {@link AbstractRecordingCommand.doExecute} to derive the undo & redo patches.
+     * @returns The current state of the JSON object
+     */
+    protected abstract getJsonObject(): JsonObject;
+
+    /**
+     * The actual execution i.e. series of changes applied to the JSOn object that should be captured.
+     */
+    protected abstract doExecute(): MaybePromise<void>;
+
+    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): void {
+        jsonPatch.applyPatch(object, patch, false, true);
+    }
+
+    /**
+     * Captures the original state of the JSON object before executing the command routine.
+     * This implementation cannot clone circular structures as it relies on `JSON.stringify`.
+     * @param object The object that should be cloned
+     * @returns A deep clone of the given object
+     */
+    protected deepClone(object: JsonObject): JsonObject {
+        return jsonPatch.deepClone(object);
+    }
+
+    undo(): void {
+        if (this.undoPatch) {
+            this.applyPatch(this.getJsonObject(), this.undoPatch);
+        }
+    }
+
+    redo(): void {
+        if (this.redoPatch) {
+            this.applyPatch(this.getJsonObject(), this.redoPatch);
+        }
+    }
+
+    canUndo(): boolean {
+        return !!this.undoPatch && !!this.redoPatch;
+    }
+}
+
+/**
+ * Simple base implementation of {@link AbstractRecordingCommand} that records the changes made to the given JSON object during
+ * the the given `doExecute` function.
+ */
+export class RecordingCommand<JsonObject extends AnyObject = AnyObject> extends AbstractRecordingCommand<JsonObject> {
+    constructor(protected jsonObject: JsonObject, protected doExecute: () => MaybePromise<void>) {
+        super();
+    }
+
+    protected getJsonObject(): JsonObject {
+        return this.jsonObject;
+    }
+}
+
+/**
+ * Simple base implementation of {@link AbstractRecordingCommand} that allows recording of changes made
+ * to the `GModelRoot` ({@link ModelState.root}) during the given `doExecute` function
+ */
+export class GModelRecordingCommand extends AbstractRecordingCommand<GModelRootSchema> {
+    constructor(protected modelState: ModelState, protected serializer: GModelSerializer, protected doExecute: () => MaybePromise<void>) {
+        super();
+    }
+
+    override async execute(): Promise<void> {
+        await super.execute();
+        this.modelState.index.indexRoot(this.modelState.root);
+    }
+
+    protected getJsonObject(): GModelRootSchema {
+        return this.serializer.createSchema(this.modelState.root);
+    }
+
+    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): void {
+        super.applyPatch(rootSchema, patch);
+        const newRoot = this.serializer.createRoot(rootSchema);
+        this.modelState.updateRoot(newRoot);
+    }
+}

package/src/common/command/undo-redo-action-handler.ts

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * Copyright (c) 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 { Action, MaybePromise, RedoAction, UndoAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../actions/action-handler';
+import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
+import { CommandStack } from './command-stack';
+
+@injectable()
+export class UndoRedoActionHandler implements ActionHandler {
+    @inject(CommandStack)
+    protected commandStack: CommandStack;
+
+    @inject(ModelSubmissionHandler)
+    protected modelSubmissionHandler: ModelSubmissionHandler;
+
+    readonly actionKinds = [UndoAction.KIND, RedoAction.KIND];
+
+    execute(action: Action): MaybePromise<Action[]> {
+        if (UndoAction.is(action)) {
+            return this.undo();
+        } else if (RedoAction.is(action)) {
+            return this.redo();
+        }
+        return [];
+    }
+
+    protected async undo(): Promise<Action[]> {
+        if (this.commandStack.canUndo()) {
+            await this.commandStack.undo();
+            return this.modelSubmissionHandler.submitModel('undo');
+        }
+        return [];
+    }
+
+    protected async redo(): Promise<Action[]> {
+        if (this.commandStack.canRedo()) {
+            await this.commandStack.redo();
+            return this.modelSubmissionHandler.submitModel('redo');
+        }
+        return [];
+    }
+}

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

@@ -48,6 +48,8 @@ import { ActionDispatcher, DefaultActionDispatcher } from '../actions/action-dis
 import { ActionHandlerConstructor, ActionHandlerFactory } from '../actions/action-handler';
 import { ActionHandlerRegistry, ActionHandlerRegistryInitializer } from '../actions/action-handler-registry';
 import { ClientActionHandler } from '../actions/client-action-handler';
+import { CommandStack, DefaultCommandStack } from '../command/command-stack';
+import { UndoRedoActionHandler } from '../command/undo-redo-action-handler';
 import { DiagramConfiguration } from '../diagram/diagram-configuration';
 import { RequestTypeHintsActionHandler } from '../diagram/request-type-hints-action-handler';
 import { CommandPaletteActionProvider } from '../features/contextactions/command-palette-action-provider';
@@ -63,7 +65,9 @@ import {
 } from '../features/directediting/context-edit-validator-registry';
 import { LabelEditValidator } from '../features/directediting/label-edit-validator';
 import { RequestEditValidationHandler } from '../features/directediting/request-edit-validation-handler';
+import { ComputedBoundsActionHandler } from '../features/layout/computed-bounds-action-handler';
 import { LayoutEngine } from '../features/layout/layout-engine';
+import { LayoutOperationHandler } from '../features/layout/layout-operation-handler';
 import { GModelFactory } from '../features/model/gmodel-factory';
 import { GModelIndex } from '../features/model/gmodel-index';
 import { DefaultGModelSerializer, GModelSerializer } from '../features/model/gmodel-serializer';
@@ -137,6 +141,7 @@ import {
  * - {@link OperationHandlerFactory}
  * - {@link OperationHandlerRegistry}
  * - {@link Operations}
+ * - {@link CommandStack}
  * - {@link NavigationTargetResolver} as optional binding
  *   {@link NavigationTargetProvider} as {@link ClassMultiBinding<NavigationTargetProvider>} (empty)
  * - {@link NavigationTargetProviderRegistry}
@@ -193,6 +198,7 @@ export abstract class DiagramModule extends GLSPModule {
         applyBindingTarget(context, OperationHandlerRegistry, this.bindOperationHandlerRegistry()).inSingletonScope();
         applyBindingTarget(context, OperationHandlerFactory, this.bindOperationHandlerFactory());
         applyBindingTarget(context, Operations, this.bindOperations()).inSingletonScope();
+        applyBindingTarget(context, CommandStack, this.bindCommandStack()).inSingletonScope();
 
         // Navigation
         applyOptionalBindingTarget(context, NavigationTargetResolver, this.bindNavigationTargetResolver());
@@ -232,6 +238,8 @@ export abstract class DiagramModule extends GLSPModule {
         binding.add(RequestNavigationTargetsActionHandler);
         binding.add(ResolveNavigationTargetsActionHandler);
         binding.add(SaveModelActionHandler);
+        binding.add(UndoRedoActionHandler);
+        binding.add(ComputedBoundsActionHandler);
     }
 
     protected bindDiagramType(): BindingTarget<string> {
@@ -291,8 +299,13 @@ export abstract class DiagramModule extends GLSPModule {
         };
     }
 
+    protected bindCommandStack(): BindingTarget<CommandStack> {
+        return DefaultCommandStack;
+    }
+
     protected configureOperationHandlers(binding: InstanceMultiBinding<OperationHandlerConstructor>): void {
         binding.add(CompoundOperationHandler);
+        binding.add(LayoutOperationHandler);
     }
 
     protected configureContextActionProviders(binding: MultiBinding<ContextActionsProvider>): void {

package/src/common/features/contextactions/tool-palette-item-provider.ts

@@ -63,10 +63,8 @@ export class DefaultToolPaletteItemProvider extends ToolPaletteItemProvider {
     @inject(OperationHandlerRegistry) operationHandlerRegistry: OperationHandlerRegistry;
     protected counter: number;
 
-    getItems(args?: Args): PaletteItem[] {
-        const handlers = this.operationHandlerRegistry
-            .getAll()
-            .filter(handler => handler instanceof CreateOperationHandler) as CreateOperationHandler[];
+    getItems(_args?: Args): PaletteItem[] {
+        const handlers = this.operationHandlerRegistry.getAll().filter(CreateOperationHandler.is) as CreateOperationHandler[];
         this.counter = 0;
         const nodes = this.createPaletteItem(handlers, CreateNodeOperation.KIND);
         const edges = this.createPaletteItem(handlers, CreateEdgeOperation.KIND);

package/src/common/{gmodel → features/layout}/computed-bounds-action-handler.ts

@@ -16,11 +16,16 @@
 import { GModelRoot } from '@eclipse-glsp/graph';
 import { Action, ComputedBoundsAction, MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { ActionHandler } from '../actions/action-handler';
-import { ModelState } from '../features/model/model-state';
-import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
-import { applyAlignment, applyBounds, applyRoute } from '../utils/layout-util';
+import { ActionHandler } from '../../actions/action-handler';
+import { applyAlignment, applyBounds, applyRoute } from '../../utils/layout-util';
+import { ModelState } from '../model/model-state';
+import { ModelSubmissionHandler } from '../model/model-submission-handler';
 
+/**
+ * Syncs the bounds computed by the client (i.e. the actual bounds after applying CSS styles) back to the `GModel`.
+ * In this default implementation the updated bounds are stored transient. This means they are applied to the graphical model but
+ * are not persisted to the source model.
+ */
 @injectable()
 export class ComputedBoundsActionHandler implements ActionHandler {
     @inject(ModelSubmissionHandler)

package/src/common/features/layout/layout-operation-handler.ts

@@ -13,15 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { LayoutOperation, Operation } from '@eclipse-glsp/protocol';
+import { LayoutOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
+import { Command } from '../../command/command';
+import { GModelRecordingCommand } from '../../command/recording-command';
 import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
 import { OperationHandler } from '../../operations/operation-handler';
 import { Logger } from '../../utils/logger';
+import { GModelSerializer } from '../model/gmodel-serializer';
 import { LayoutEngine } from './layout-engine';
 
+/**
+ * The default handler for `{@link LayoutOperation}s. Does invoke the (optional) layout engine
+ * if the server is configured for manual layouting. Changes are stored transient in the graphical model and are not
+ * persisted in the source model.
+ */
 @injectable()
-export class LayoutOperationHandler implements OperationHandler {
+export class LayoutOperationHandler extends OperationHandler {
     @inject(Logger)
     protected logger: Logger;
 
@@ -32,16 +40,23 @@ export class LayoutOperationHandler implements OperationHandler {
     @inject(DiagramConfiguration)
     protected diagramConfiguration: DiagramConfiguration;
 
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
     readonly operationType = LayoutOperation.KIND;
-    async execute(operation: Operation): Promise<void> {
-        if (operation.kind === LayoutOperation.KIND) {
-            if (this.diagramConfiguration.layoutKind === ServerLayoutKind.MANUAL) {
-                if (this.layoutEngine) {
-                    await this.layoutEngine.layout();
-                    return;
-                }
-                this.logger.warn('Could not execute layout operation. No `LayoutEngine` is bound!');
-            }
+
+    createCommand(operation: LayoutOperation): MaybePromise<Command | undefined> {
+        if (this.diagramConfiguration.layoutKind !== ServerLayoutKind.MANUAL) {
+            return undefined;
+        }
+        if (!this.layoutEngine) {
+            this.logger.warn('Could not execute layout operation. No `LayoutEngine` is bound!');
+            return undefined;
         }
+        return new GModelRecordingCommand(this.modelState, this.serializer, () => this.executeOperation(operation));
+    }
+
+    protected async executeOperation(_operation: Operation): Promise<void> {
+        await this.layoutEngine?.layout();
     }
 }

package/src/common/features/model/model-state.ts

@@ -30,7 +30,6 @@ export interface ModelState {
     readonly root: GModelRoot;
     updateRoot(newRoot: GModelRoot): void;
     editMode: string;
-    isDirty: boolean;
     sourceUri?: string;
     clientId: string;
     readonly isReadonly: boolean;
@@ -56,8 +55,6 @@ export class DefaultModelState implements ModelState {
 
     editMode = EditMode.EDITABLE;
 
-    isDirty = false;
-
     set<P>(key: string, property: P): void {
         this.properties.set(key, property);
     }

package/src/common/features/model/model-submission-handler.ts

@@ -24,6 +24,7 @@ import {
     UpdateModelAction
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
+import { CommandStack } from '../../command/command-stack';
 import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
 import { LayoutEngine } from '../layout/layout-engine';
 import { GModelFactory } from './gmodel-factory';
@@ -48,6 +49,9 @@ export class ModelSubmissionHandler {
     @optional()
     protected layoutEngine: LayoutEngine;
 
+    @inject(CommandStack)
+    protected commandStack: CommandStack;
+
     /**
      * Returns a list of actions to update the client-side model, based on the specified <code>modelState</code>.
      *
@@ -63,7 +67,7 @@ export class ModelSubmissionHandler {
         const root = this.serializeGModel();
 
         if (this.diagramConfiguration.needsClientLayout) {
-            return [RequestBoundsAction.create(root), SetDirtyStateAction.create(this.modelState.isDirty, { reason })];
+            return [RequestBoundsAction.create(root), SetDirtyStateAction.create(this.commandStack.isDirty, { reason })];
         }
         return [SetModelAction.create(root)];
     }
@@ -95,7 +99,7 @@ export class ModelSubmissionHandler {
                 : UpdateModelAction.create(root, { animate: this.diagramConfiguration.animatedUpdate })
         );
         if (!this.diagramConfiguration.needsClientLayout) {
-            result.push(SetDirtyStateAction.create(this.modelState.isDirty, { reason }));
+            result.push(SetDirtyStateAction.create(this.commandStack.isDirty, { reason }));
         }
         return result;
     }

package/src/common/features/model/save-model-action-handler.ts

@@ -16,23 +16,22 @@
 import { Action, SaveModelAction, SetDirtyStateAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../../actions/action-handler';
-import { ModelState } from './model-state';
+import { CommandStack } from '../../command/command-stack';
 import { SourceModelStorage } from './source-model-storage';
 
 @injectable()
 export class SaveModelActionHandler implements ActionHandler {
     actionKinds = [SaveModelAction.KIND];
 
-    @inject(ModelState)
-    protected modelState: ModelState;
+    @inject(CommandStack)
+    protected commandStack: CommandStack;
 
     @inject(SourceModelStorage)
     protected sourceModelStorage: SourceModelStorage;
 
     async execute(action: SaveModelAction): Promise<Action[]> {
         await this.sourceModelStorage.saveSourceModel(action);
-        this.modelState.isDirty = false; // TODO: call save is done when available
-
-        return [SetDirtyStateAction.create(this.modelState.isDirty, { reason: 'save' })];
+        this.commandStack.saveIsDone();
+        return [SetDirtyStateAction.create(this.commandStack.isDirty, { reason: 'save' })];
     }
 }

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

@@ -15,24 +15,22 @@
  ********************************************************************************/
 import { GLabel } from '@eclipse-glsp/graph';
 import { ApplyLabelEditOperation, MaybePromise } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { OperationHandler } from '../operations/operation-handler';
-import { GLSPServerError } from '../utils/glsp-server-error';
+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 ApplyLabelEditOperationHandler implements OperationHandler {
+export class GModelApplyLabelEditOperationHandler extends GModelOperationHandler {
     readonly operationType = ApplyLabelEditOperation.KIND;
 
-    @inject(ModelState)
-    protected readonly modelState: ModelState;
-
-    execute(operation: ApplyLabelEditOperation): MaybePromise<void> {
-        const element = this.modelState.index.findByClass(operation.labelId, GLabel);
-        if (element) {
-            element.text = operation.text;
-        } else {
-            throw new GLSPServerError('Element with provided ID cannot be found or is not a GLabel');
-        }
+    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;
     }
 }