@eclipse-glsp/server 1.1.0-next.3d7585d.42 → 1.1.0-next.42963d6.55

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(await this.getJsonObject());
+        await this.doExecute();
+        const afterState = await 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(): MaybePromise<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[]): MaybePromise<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);
+    }
+
+    async undo(): Promise<void> {
+        if (this.undoPatch) {
+            return this.applyPatch(await this.getJsonObject(), this.undoPatch);
+        }
+    }
+
+    async redo(): Promise<void> {
+        if (this.redoPatch) {
+            return this.applyPatch(await 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(): MaybePromise<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(): MaybePromise<GModelRootSchema> {
+        return this.serializer.createSchema(this.modelState.root);
+    }
+
+    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): MaybePromise<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/client-session-module.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import { ClientId } from './service-identifiers';
 
 export function createClientSessionModule(clientId: string, glspClient: GLSPClientProxy): ContainerModule {

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/di/glsp-module.ts

@@ -13,12 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { BindingContext } from '@eclipse-glsp/protocol';
 import { ContainerModule, injectable, interfaces } from 'inversify';
 import { AbstractMultiBinding } from './multi-binding';
 
 /**
  * A wrapper interface to get access to the binding related functions
  * for a inversify container.
+ * @deprecated Use `BindingContext` from `@eclipse-glsp/protocol` instead
  */
 export interface ModuleContext {
     bind: interfaces.Bind;
@@ -34,7 +36,7 @@ export interface ModuleContext {
 export abstract class GLSPModule extends ContainerModule {
     public static CLIENT_ACTIONS = 'ClientActions';
 
-    protected context: ModuleContext;
+    protected context: BindingContext;
 
     constructor() {
         super((bind, unbind, isBound, rebind) => {

package/src/common/di/multi-binding.ts

@@ -13,9 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { distinctAdd, flatPush, MaybeArray, remove } from '@eclipse-glsp/protocol';
+import { BindingContext, distinctAdd, flatPush, MaybeArray, remove } from '@eclipse-glsp/protocol';
 import { applyBindingTarget, BindingTarget } from './binding-target';
-import { ModuleContext } from './glsp-module';
 
 /**
  * A helper class used in `GLSPModules` to ease the configuration of multi-injected service identifiers.
@@ -29,7 +28,7 @@ export abstract class AbstractMultiBinding<T> {
 
     constructor(readonly identifier: string | symbol) {}
 
-    abstract applyBindings(context: ModuleContext): void;
+    abstract applyBindings(context: BindingContext): void;
 
     add(newBinding: T): void {
         distinctAdd(this.bindings, newBinding);
@@ -71,7 +70,7 @@ export abstract class AbstractMultiBinding<T> {
  * @typeparam T the base type of {@link BindingTarget}.
  */
 export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
-    applyBindings(context: ModuleContext): void {
+    applyBindings(context: BindingContext): void {
         this.bindings.forEach(binding => applyBindingTarget(context, this.identifier, binding));
     }
 }
@@ -83,7 +82,7 @@ export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
  * * @typeparam T the type of the instances
  */
 export class InstanceMultiBinding<T> extends AbstractMultiBinding<T> {
-    applyBindings(context: ModuleContext): void {
+    applyBindings(context: BindingContext): void {
         context.bind(this.identifier).toConstantValue(this.bindings);
     }
 }

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

@@ -13,14 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPServer, GLSPServerListener } from '@eclipse-glsp/protocol';
 import { ContainerModule, interfaces } from 'inversify';
 import { DefaultGlobalActionProvider, GlobalActionProvider } from '../actions/global-action-provider';
-import { DefaultGLSPClientProxy, GLSPClientProxy, JsonRpcGLSPClientProxy } from '../protocol/glsp-client-proxy';
-import { DefaultGLSPServer, GLSPServer, JsonRpcGLSPServer } from '../protocol/glsp-server';
-import { GLSPServerListener } from '../protocol/glsp-server-listener';
+import { DefaultGLSPServer } from '../protocol/glsp-server';
 import { ClientSessionFactory, DefaultClientSessionFactory } from '../session/client-session-factory';
 import { ClientSessionManager, DefaultClientSessionManager } from '../session/client-session-manager';
-import { applyBindingTarget, BindingTarget } from './binding-target';
+import { BindingTarget, applyBindingTarget } from './binding-target';
 import { DiagramModule } from './diagram-module';
 import { GLSPModule } from './glsp-module';
 import { MultiBinding } from './multi-binding';
@@ -74,7 +73,6 @@ export class ServerModule extends GLSPModule {
         applyBindingTarget(context, DiagramModules, this.bindDiagramModules());
 
         applyBindingTarget(context, GLSPServer, this.bindGLSPServer()).inSingletonScope();
-        applyBindingTarget(context, JsonRpcGLSPServer, this.bindJsonRpcGLSPServer());
         applyBindingTarget(context, ClientSessionFactory, this.bindClientSessionFactory()).inSingletonScope();
         applyBindingTarget(context, ClientSessionManager, this.bindClientSessionManager()).inSingletonScope();
         this.configureMultiBinding(new MultiBinding<GLSPServerListener>(GLSPServerListener), binding =>
@@ -83,10 +81,9 @@ export class ServerModule extends GLSPModule {
 
         applyBindingTarget(context, GlobalActionProvider, this.bindGlobalActionProvider()).inSingletonScope();
 
-        applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
-
-        applyBindingTarget(context, GLSPClientProxy, this.bindGLSPClientProxy()).inSingletonScope();
-        applyBindingTarget(context, JsonRpcGLSPClientProxy, this.bindJsonRpcGLSPClientProxy());
+        if (!isBound(InjectionContainer)) {
+            applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
+        }
     }
 
     protected bindDiagramModules(): BindingTarget<Map<string, ContainerModule[]>> {
@@ -97,10 +94,6 @@ export class ServerModule extends GLSPModule {
         return DefaultGLSPServer;
     }
 
-    protected bindJsonRpcGLSPServer(): BindingTarget<JsonRpcGLSPServer> {
-        return { service: GLSPServer };
-    }
-
     protected bindClientSessionFactory(): BindingTarget<ClientSessionFactory> {
         return DefaultClientSessionFactory;
     }
@@ -117,14 +110,6 @@ export class ServerModule extends GLSPModule {
         return { dynamicValue: context => context.container };
     }
 
-    protected bindGLSPClientProxy(): BindingTarget<GLSPClientProxy> {
-        return DefaultGLSPClientProxy;
-    }
-
-    protected bindJsonRpcGLSPClientProxy(): BindingTarget<JsonRpcGLSPClientProxy> {
-        return { service: GLSPClientProxy };
-    }
-
     protected configureGLSPServerListeners(binding: MultiBinding<GLSPServerListener>): void {
         binding.add({ service: ClientSessionManager });
     }

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, applyElementAndBounds, 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)
@@ -42,7 +47,7 @@ export class ComputedBoundsActionHandler implements ActionHandler {
 
     protected applyBounds(root: GModelRoot, action: ComputedBoundsAction): void {
         const index = this.modelState.index;
-        action.bounds.forEach(bounds => applyBounds(bounds, index));
+        action.bounds.forEach(bounds => applyElementAndBounds(bounds, index));
         (action.alignments ?? []).forEach(alignment => applyAlignment(alignment, index));
         (action.routes ?? []).forEach(route => applyRoute(route, index));
     }

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' })];
     }
 }