@eclipse-glsp/server 1.1.0-next.f0fc2cf.63 → 2.0.0

package/src/common/actions/global-action-provider.spec.ts

@@ -13,21 +13,20 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
-import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import * as sinon from 'sinon';
+import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import * as mock from '../test/mock-util';
 import { Logger } from '../utils/logger';
 import { ActionHandler } from './action-handler';
 import { ActionHandlerRegistry } from './action-handler-registry';
 import { DefaultGlobalActionProvider } from './global-action-provider';
-import * as sinon from 'sinon';
-import { expect } from 'chai';
 
 describe('test DefaultGlobalActionProvider', () => {
     const container = new Container();
     const serverActions = ['A1', 'A2', 'A3'];
-    const clientActions = ['C1', 'C2'];
     const diagramType = 'myDiagramType';
 
     const handler1Actions = ['A1', 'A2'];
@@ -44,8 +43,6 @@ describe('test DefaultGlobalActionProvider', () => {
         bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler1Actions));
         bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler2Actions));
         bind(ActionHandlerRegistry).toConstantValue(handlerRegistry);
-        bind(ClientActionKinds).toConstantValue(clientActions[0]);
-        bind(ClientActionKinds).toConstantValue(clientActions[1]);
     });
 
     const diagramModules = new Map<string, ContainerModule[]>();
@@ -62,18 +59,10 @@ describe('test DefaultGlobalActionProvider', () => {
     const actionProvider = container.resolve(DefaultGlobalActionProvider);
 
     it('serverActionsKinds', () => {
-        const result = actionProvider.serverActionKinds;
+        const result = actionProvider.actionKinds;
         expect(result.size).to.be.equal(1);
         const resultServerActions = result.get(diagramType);
         expect(resultServerActions).to.not.be.undefined;
         expect(serverActions.every(action => resultServerActions!.includes(action))).true;
     });
-
-    it('clientActionKinds', () => {
-        const result = actionProvider.clientActionKinds;
-        expect(result.size).to.be.equal(1);
-        const resultClientActions = result.get(diagramType);
-        expect(resultClientActions).to.not.be.undefined;
-        expect(clientActions.every(action => resultClientActions!.includes(action))).true;
-    });
 });

package/src/common/actions/global-action-provider.ts

@@ -13,60 +13,56 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { distinctAdd } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable } from 'inversify';
-import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import { createClientSessionModule } from '../di/client-session-module';
+import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { ActionHandlerRegistry } from './action-handler-registry';
-import { ClientActionHandler } from './client-action-handler';
 
 export const GlobalActionProvider = Symbol('GlobalActionProvider');
 
+/**
+ * Provides a map of handled action kinds grouped by `diagramType`
+ */
 export interface GlobalActionProvider {
-    readonly serverActionKinds: Map<string, string[]>;
-    readonly clientActionKinds: Map<string, string[]>;
+    readonly actionKinds: Map<string, string[]>;
 }
 
 @injectable()
 export class DefaultGlobalActionProvider implements GlobalActionProvider {
-    public readonly serverActionKinds: Map<string, string[]>;
-    public readonly clientActionKinds: Map<string, string[]>;
+    public readonly actionKinds: Map<string, string[]>;
 
     constructor(
         @inject(InjectionContainer) serverContainer: Container,
         @inject(DiagramModules) diagramModules: Map<string, ContainerModule[]>
     ) {
-        this.serverActionKinds = new Map();
-        this.clientActionKinds = new Map();
+        this.actionKinds = new Map();
         diagramModules.forEach((modules, diagramType) => {
             const container = this.createDiagramContainer(serverContainer, modules);
             const initializers = container.getAll<ClientSessionInitializer>(ClientSessionInitializer);
             initializers.forEach(service => service.initialize());
-            this.loadServerActionKinds(diagramType, container);
-            this.loadClientActionKinds(diagramType, container);
+            this.loadActionKinds(diagramType, container);
             container.unbindAll();
         });
     }
 
     createDiagramContainer(serverContainer: Container, modules: ContainerModule[]): Container {
         const container = serverContainer.createChild();
-        container.load(...modules);
+        const clientSessionModule = createClientSessionModule({
+            clientId: 'tempId',
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            glspClient: { process: () => {} },
+            clientActionKinds: []
+        });
+        container.load(...modules, clientSessionModule);
         return container;
     }
 
-    loadServerActionKinds(diagramType: string, diagramContainer: Container): void {
+    loadActionKinds(diagramType: string, diagramContainer: Container): void {
         const handlerRegistry = diagramContainer.get<ActionHandlerRegistry>(ActionHandlerRegistry);
-        const diagramServerActions = this.serverActionKinds.get(diagramType) ?? [];
-        handlerRegistry
-            .getAll()
-            .filter(handler => !(handler instanceof ClientActionHandler))
-            .forEach(handler => diagramServerActions.push(...handler.actionKinds));
-        this.serverActionKinds.set(diagramType, [...new Set(diagramServerActions)]);
-    }
-
-    loadClientActionKinds(diagramType: string, diagramContainer: Container): void {
-        const clientActionKinds = diagramContainer.getAll<string>(ClientActionKinds);
-        const diagramClientActions = this.clientActionKinds.get(diagramType) ?? [];
-        diagramClientActions.push(...clientActionKinds);
-        this.clientActionKinds.set(diagramType, diagramClientActions);
+        const diagramServerActions = this.actionKinds.get(diagramType) ?? [];
+        handlerRegistry.getAll().forEach(handler => distinctAdd(diagramServerActions, ...handler.actionKinds));
+        this.actionKinds.set(diagramType, diagramServerActions);
     }
 }

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

@@ -14,9 +14,9 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { AnyObject } from '@eclipse-glsp/protocol';
+import { AnyObject, MaybePromise } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
-import { RecordingCommand } from './recording-command';
+import { AbstractRecordingCommand } from './recording-command';
 
 interface TestModel {
     string: string;
@@ -27,6 +27,16 @@ interface TestModel {
 
 let jsonObject: TestModel;
 
+class TestRecordingCommand<JsonObject extends AnyObject = AnyObject> extends AbstractRecordingCommand<JsonObject> {
+    constructor(protected jsonObject: JsonObject, protected doExecute: () => MaybePromise<void>) {
+        super();
+    }
+
+    protected getJsonObject(): MaybePromise<JsonObject> {
+        return this.jsonObject;
+    }
+}
+
 describe('RecordingCommand', () => {
     let beforeState: TestModel;
 
@@ -41,14 +51,14 @@ describe('RecordingCommand', () => {
 
     it('should be undoable after execution', async () => {
         // eslint-disable-next-line @typescript-eslint/no-empty-function
-        const command = new RecordingCommand(jsonObject, () => {});
+        const command = new TestRecordingCommand(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, () => {
+        const command = new TestRecordingCommand(jsonObject, () => {
             jsonObject.string = 'bar';
             jsonObject.flag = false;
             jsonObject.maybe = { hello: 'world' };
@@ -60,7 +70,7 @@ describe('RecordingCommand', () => {
     });
 
     it('should restore the post execution state when redo is called', async () => {
-        const command = new RecordingCommand(jsonObject, () => {
+        const command = new TestRecordingCommand(jsonObject, () => {
             jsonObject.string = 'bar';
             jsonObject.flag = false;
             jsonObject.maybe = { hello: 'world' };

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

@@ -14,8 +14,7 @@
  * 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 { AnyObject, GModelElementSchema, GModelRootSchema, 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';
@@ -34,6 +33,7 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
         const afterState = await this.getJsonObject();
         this.undoPatch = jsonPatch.compare(afterState, beforeState);
         this.redoPatch = jsonPatch.compare(beforeState, afterState);
+        this.postChange?.(afterState);
     }
 
     /**
@@ -48,8 +48,8 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
      */
     protected abstract doExecute(): MaybePromise<void>;
 
-    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): MaybePromise<void> {
-        jsonPatch.applyPatch(object, patch, false, true);
+    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): jsonPatch.PatchResult<JsonObject> {
+        return jsonPatch.applyPatch(object, patch, false, true);
     }
 
     /**
@@ -64,33 +64,28 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
 
     async undo(): Promise<void> {
         if (this.undoPatch) {
-            return this.applyPatch(await this.getJsonObject(), this.undoPatch);
+            const result = this.applyPatch(await this.getJsonObject(), this.undoPatch);
+            this.postChange?.(result.newDocument);
         }
     }
 
     async redo(): Promise<void> {
         if (this.redoPatch) {
-            return this.applyPatch(await this.getJsonObject(), this.redoPatch);
+            const result = this.applyPatch(await this.getJsonObject(), this.redoPatch);
+            this.postChange?.(result.newDocument);
         }
     }
 
     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;
-    }
+    /**
+     * Optional hook that (if implemented) will be
+     * executed after every command-driven action that changed
+     * the underlying model i.e. command execute, undo and redo.
+     */
+    protected postChange?(newModel: JsonObject): MaybePromise<void>;
 }
 
 /**
@@ -102,18 +97,12 @@ export class GModelRecordingCommand extends AbstractRecordingCommand<GModelRootS
         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);
+    protected override postChange(newModel: GModelElementSchema): MaybePromise<void> {
+        const newRoot = this.serializer.createRoot(newModel);
         this.modelState.updateRoot(newRoot);
     }
 }

package/src/common/di/client-session-module.ts

@@ -13,17 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GLSPClientProxy } from '@eclipse-glsp/protocol';
+import { GLSPClientProxy, bindOrRebind } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { ClientId } from './service-identifiers';
+import { ClientActionKinds, ClientId } from './service-identifiers';
 
-export function createClientSessionModule(clientId: string, glspClient: GLSPClientProxy): ContainerModule {
-    return new ContainerModule((bind, _unbind, isBound, rebind) => {
-        if (isBound(ClientId)) {
-            rebind(ClientId).toConstantValue(clientId);
-        } else {
-            bind(ClientId).toConstantValue(clientId);
-        }
-        bind(GLSPClientProxy).toConstantValue(glspClient);
+export interface ClientSessionModuleOptions {
+    clientId: string;
+    glspClient: GLSPClientProxy;
+    clientActionKinds: string[];
+}
+
+/**
+ * Creates the DI module that binds client session specific configuration
+ */
+export function createClientSessionModule(options: ClientSessionModuleOptions): ContainerModule {
+    return new ContainerModule((bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindOrRebind(context, ClientId).toConstantValue(options.clientId);
+        bind(GLSPClientProxy).toConstantValue(options.glspClient);
+        bind(ClientActionKinds).toConstantValue(new Set(options.clientActionKinds));
     });
 }

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

@@ -13,48 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    CenterAction,
-    DeleteMarkersAction,
-    EndProgressAction,
-    ExportSvgAction,
-    FitToScreenAction,
-    NavigateToExternalTargetAction,
-    NavigateToTargetAction,
-    RequestBoundsAction,
-    SelectAction,
-    SelectAllAction,
-    ServerMessageAction,
-    ServerStatusAction,
-    SetBoundsAction,
-    SetClipboardDataAction,
-    SetContextActions,
-    SetDirtyStateAction,
-    SetEditModeAction,
-    SetEditValidationResultAction,
-    SetMarkersAction,
-    SetModelAction,
-    SetNavigationTargetsAction,
-    SetPopupModelAction,
-    SetResolvedNavigationTargetAction,
-    SetTypeHintsAction,
-    SetViewportAction,
-    SourceModelChangedAction,
-    StartProgressAction,
-    TriggerEdgeCreationAction,
-    TriggerNodeCreationAction,
-    UpdateModelAction,
-    UpdateProgressAction
-} from '@eclipse-glsp/protocol';
 import { interfaces } from 'inversify';
 import { ActionDispatcher, DefaultActionDispatcher } from '../actions/action-dispatcher';
 import { ActionHandlerConstructor, ActionHandlerFactory } from '../actions/action-handler';
 import { ActionHandlerRegistry, ActionHandlerRegistryInitializer } from '../actions/action-handler-registry';
-import { ClientActionHandler } from '../actions/client-action-handler';
+import { ClientActionForwarder } 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';
 import { ContextActionsProvider } from '../features/contextactions/context-actions-provider';
 import { ContextActionsProviderRegistry } from '../features/contextactions/context-actions-provider-registry';
@@ -90,6 +56,9 @@ import { ResolveNavigationTargetsActionHandler } from '../features/navigation/re
 import { PopupModelFactory } from '../features/popup/popup-model-factory';
 import { RequestPopupModelActionHandler } from '../features/popup/request-popup-model-action-handler';
 import { DefaultProgressService, ProgressService } from '../features/progress/progress-service';
+import { EdgeCreationChecker } from '../features/type-hints/edge-creation-checker';
+import { RequestCheckEdgeActionHandler } from '../features/type-hints/request-check-edge-action-handler';
+import { RequestTypeHintsActionHandler } from '../features/type-hints/request-type-hints-action-handler';
 import { ModelValidator } from '../features/validation/model-validator';
 import { RequestMarkersHandler } from '../features/validation/request-markers-handler';
 import { CompoundOperationHandler } from '../operations/compound-operation-handler';
@@ -101,7 +70,6 @@ import { BindingTarget, applyBindingTarget, applyOptionalBindingTarget } from '.
 import { GLSPModule } from './glsp-module';
 import { InstanceMultiBinding, MultiBinding } from './multi-binding';
 import {
-    ClientActionKinds,
     ClientId,
     ContextActionsProviders,
     ContextEditValidators,
@@ -155,6 +123,7 @@ import {
  * - {@link ClientSessionInitializer} as {@link ClassMultiBinding<ClientSessionInitializer>}
  * - {@link PopupModelFactory}  as optional binding
  * - {@link LayoutEngine}  as optional binding
+ * - {@link EdgeCreationChecker}  as optional binding
  */
 
 export abstract class DiagramModule extends GLSPModule {
@@ -167,6 +136,7 @@ export abstract class DiagramModule extends GLSPModule {
         applyBindingTarget(context, DiagramType, this.bindDiagramType());
         applyBindingTarget(context, ClientId, this.bindClientId());
         applyBindingTarget(context, DiagramConfiguration, this.bindDiagramConfiguration()).inSingletonScope();
+        applyBindingTarget(context, ClientActionForwarder, this.bindClientActionForwarder()).inSingletonScope();
 
         // Model-related bindings
         applyBindingTarget(context, GModelSerializer, this.bindGModelSerializer()).inSingletonScope();
@@ -191,7 +161,6 @@ export abstract class DiagramModule extends GLSPModule {
 
         // Action & operation related bindings
         applyBindingTarget(context, ActionDispatcher, this.bindActionDispatcher()).inSingletonScope();
-        this.configureMultiBinding(new InstanceMultiBinding<string>(ClientActionKinds), binding => this.configureClientActions(binding));
         this.configureMultiBinding(new InstanceMultiBinding<ActionHandlerConstructor>(ActionHandlerConstructor), binding =>
             this.configureActionHandlers(binding)
         );
@@ -206,7 +175,7 @@ export abstract class DiagramModule extends GLSPModule {
         applyBindingTarget(context, CommandStack, this.bindCommandStack()).inSingletonScope();
 
         // Navigation
-        applyOptionalBindingTarget(context, NavigationTargetResolver, this.bindNavigationTargetResolver());
+        applyOptionalBindingTarget(context, NavigationTargetResolver, this.bindNavigationTargetResolver())?.inSingletonScope();
         this.configureMultiBinding(new MultiBinding<NavigationTargetProvider>(NavigationTargetProviders), binding =>
             this.configureNavigationTargetProviders(binding)
         );
@@ -223,8 +192,9 @@ export abstract class DiagramModule extends GLSPModule {
             this.configureClientSessionInitializers(binding)
         );
         applyBindingTarget(context, ProgressService, this.bindProgressService()).inSingletonScope();
-        applyOptionalBindingTarget(context, PopupModelFactory, this.bindPopupModelFactory());
-        applyOptionalBindingTarget(context, LayoutEngine, this.bindLayoutEngine?.());
+        applyOptionalBindingTarget(context, PopupModelFactory, this.bindPopupModelFactory())?.inSingletonScope();
+        applyOptionalBindingTarget(context, LayoutEngine, this.bindLayoutEngine())?.inSingletonScope();
+        applyOptionalBindingTarget(context, EdgeCreationChecker, this.bindEdgeCreationChecker())?.inSingletonScope();
     }
 
     configureClientSessionInitializers(binding: MultiBinding<ClientSessionInitializer>): void {
@@ -233,11 +203,11 @@ export abstract class DiagramModule extends GLSPModule {
     }
 
     protected configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
-        binding.add(ClientActionHandler);
         binding.add(RequestModelActionHandler);
         binding.add(RequestContextActionsHandler);
         binding.add(RequestTypeHintsActionHandler);
         binding.add(OperationActionHandler);
+        binding.add(RequestCheckEdgeActionHandler);
         binding.add(RequestMarkersHandler);
         binding.add(RequestPopupModelActionHandler);
         binding.add(RequestEditValidationHandler);
@@ -260,6 +230,10 @@ export abstract class DiagramModule extends GLSPModule {
         return DefaultGModelSerializer;
     }
 
+    protected bindClientActionForwarder(): BindingTarget<ClientActionForwarder> {
+        return ClientActionForwarder;
+    }
+
     protected bindGModelIndex(): BindingTarget<GModelIndex> {
         return GModelIndex;
     }
@@ -330,40 +304,6 @@ export abstract class DiagramModule extends GLSPModule {
         // empty as default
     }
 
-    protected configureClientActions(binding: InstanceMultiBinding<string>): void {
-        binding.add(CenterAction.KIND);
-        binding.add(DeleteMarkersAction.KIND);
-        binding.add(EndProgressAction.KIND);
-        binding.add(ExportSvgAction.KIND);
-        binding.add(FitToScreenAction.KIND);
-        binding.add(NavigateToExternalTargetAction.KIND);
-        binding.add(NavigateToTargetAction.KIND);
-        binding.add(RequestBoundsAction.KIND);
-        binding.add(SelectAction.KIND);
-        binding.add(SelectAllAction.KIND);
-        binding.add(ServerMessageAction.KIND);
-        binding.add(ServerStatusAction.KIND);
-        binding.add(SetBoundsAction.KIND);
-        binding.add(SetClipboardDataAction.KIND);
-        binding.add(SetContextActions.KIND);
-        binding.add(SetDirtyStateAction.KIND);
-        binding.add(SetEditModeAction.KIND);
-        binding.add(SetEditValidationResultAction.KIND);
-        binding.add(SetMarkersAction.KIND);
-        binding.add(SetModelAction.KIND);
-        binding.add(SetNavigationTargetsAction.KIND);
-        binding.add(SetPopupModelAction.KIND);
-        binding.add(SetResolvedNavigationTargetAction.KIND);
-        binding.add(SetTypeHintsAction.KIND);
-        binding.add(SetViewportAction.KIND);
-        binding.add(SourceModelChangedAction.KIND);
-        binding.add(StartProgressAction.KIND);
-        binding.add(TriggerEdgeCreationAction.KIND);
-        binding.add(TriggerNodeCreationAction.KIND);
-        binding.add(UpdateModelAction.KIND);
-        binding.add(UpdateProgressAction.KIND);
-    }
-
     protected bindContextActionsProviderRegistry(): BindingTarget<ContextActionsProviderRegistry> {
         return ContextActionsProviderRegistry;
     }
@@ -396,6 +336,7 @@ export abstract class DiagramModule extends GLSPModule {
     protected bindModelValidator(): BindingTarget<ModelValidator> | undefined {
         return undefined;
     }
+
     protected bindLabelEditValidator(): BindingTarget<LabelEditValidator> | undefined {
         return undefined;
     }
@@ -403,9 +344,11 @@ export abstract class DiagramModule extends GLSPModule {
     protected bindToolPaletteItemProvider(): BindingTarget<ToolPaletteItemProvider> | undefined {
         return DefaultToolPaletteItemProvider;
     }
+
     protected bindCommandPaletteActionProvider(): BindingTarget<CommandPaletteActionProvider> | undefined {
         return undefined;
     }
+
     protected bindContextMenuItemProvider(): BindingTarget<ContextMenuItemProvider> | undefined {
         return undefined;
     }
@@ -417,7 +360,12 @@ export abstract class DiagramModule extends GLSPModule {
     protected bindPopupModelFactory(): BindingTarget<PopupModelFactory> | undefined {
         return undefined;
     }
+
     protected bindLayoutEngine(): BindingTarget<LayoutEngine> | undefined {
         return undefined;
     }
+
+    protected bindEdgeCreationChecker(): BindingTarget<EdgeCreationChecker> | undefined {
+        return undefined;
+    }
 }

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

@@ -41,7 +41,6 @@ import { DiagramModules, InjectionContainer } from './service-identifiers';
  * * {@link ClientSessionFactory}
  * * {@link ClientSessionManager}
  * * {@link GlobalActionProvider}
- * * {@link GLSPClientProxy}
  *
  */
 export class ServerModule extends GLSPModule {

package/src/common/features/clipboard/request-clipboard-data-action-handler.ts

@@ -16,10 +16,10 @@
 import {
     Action,
     ClipboardData,
+    GModelElementSchema,
     MaybePromise,
     RequestClipboardDataAction,
-    SetClipboardDataAction,
-    SModelElementSchema
+    SetClipboardDataAction
 } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../../actions/action-handler';
@@ -37,7 +37,7 @@ export class RequestClipboardDataActionHandler implements ActionHandler {
     protected modelSerializer: GModelSerializer;
 
     execute(action: RequestClipboardDataAction): MaybePromise<Action[]> {
-        const schemas: SModelElementSchema[] = [];
+        const schemas: GModelElementSchema[] = [];
         const index = this.modelState.index;
         const selectedElements = index.getAll(action.editorContext.selectedElementIds);
         const clipboardData: ClipboardData = { format: 'application/json' };

package/src/common/features/model/gmodel-serializer.ts

@@ -14,8 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* Derived from sprotty (https://github.com/eclipse/sprotty/blob/master/packages/sprotty/src/base/model/smodel-factory.ts) */
-import { GModelElement, GModelElementConstructor, GModelElementSchema, GModelRoot, GModelRootSchema } from '@eclipse-glsp/graph';
-import { SModelElementSchema, SModelRootSchema } from '@eclipse-glsp/protocol';
+import { GModelElement, GModelElementConstructor, GModelRoot } from '@eclipse-glsp/graph';
+import { GModelElementSchema, GModelRootSchema } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { DiagramConfiguration } from '../../diagram/diagram-configuration';
 import { GLSPServerError } from '../../utils/glsp-server-error';
@@ -65,7 +65,7 @@ export class DefaultGModelSerializer implements GModelSerializer {
     @inject(DiagramConfiguration) protected diagramConfiguration: DiagramConfiguration;
 
     reservedKeys = ['children', 'parent', 'index', 'source', 'target'];
-    createRoot(schema: SModelElementSchema): GModelRoot {
+    createRoot(schema: GModelElementSchema): GModelRoot {
         const constructor = this.getConfiguredConstructor(schema);
         if (constructor) {
             const element = new constructor();
@@ -77,7 +77,7 @@ export class DefaultGModelSerializer implements GModelSerializer {
         throw new GLSPServerError(`No constructor is configured in DiagramConfiguration for type ${schema.type}`);
     }
 
-    getConfiguredConstructor(schema: SModelElementSchema): GModelElementConstructor | undefined {
+    getConfiguredConstructor(schema: GModelElementSchema): GModelElementConstructor | undefined {
         let key = schema.type;
         while (!this.diagramConfiguration.typeMapping.has(key)) {
             const i = key.lastIndexOf(':');
@@ -95,7 +95,7 @@ export class DefaultGModelSerializer implements GModelSerializer {
         return constructor;
     }
 
-    createElement(schema: SModelElementSchema, parent?: GModelElement): GModelElement {
+    createElement(schema: GModelElementSchema, parent?: GModelElement): GModelElement {
         const constructor = this.getConfiguredConstructor(schema);
         if (constructor) {
             const element = new constructor();
@@ -109,7 +109,7 @@ export class DefaultGModelSerializer implements GModelSerializer {
         throw new GLSPServerError(`No constructor is configured in DiagramConfiguration for type ${schema.type}`);
     }
 
-    createSchema(element: GModelElement): SModelElementSchema {
+    createSchema(element: GModelElement): GModelElementSchema {
         const schema = {};
         for (const key in element) {
             if (!this.isReserved(element, key)) {
@@ -121,15 +121,15 @@ export class DefaultGModelSerializer implements GModelSerializer {
         }
         (schema as any)['children'] = (element.children ?? []).map(child => this.createSchema(child));
 
-        return schema as SModelElementSchema;
+        return schema as GModelElementSchema;
     }
 
-    protected initializeRoot(root: GModelRoot, schema: SModelRootSchema): GModelRoot {
+    protected initializeRoot(root: GModelRoot, schema: GModelRootSchema): GModelRoot {
         this.initializeParent(root, schema);
         return root;
     }
 
-    protected initializeElement(element: GModelElement, schema: SModelElementSchema): GModelElement {
+    protected initializeElement(element: GModelElement, schema: GModelRootSchema): GModelElement {
         for (const key in schema) {
             if (!this.isReserved(element, key)) {
                 const value = (schema as any)[key];
@@ -141,7 +141,7 @@ export class DefaultGModelSerializer implements GModelSerializer {
         return element;
     }
 
-    protected initializeChild(child: GModelElement, schema: SModelElementSchema, parent?: GModelElement): GModelElement {
+    protected initializeChild(child: GModelElement, schema: GModelElementSchema, parent?: GModelElement): GModelElement {
         this.initializeParent(child, schema);
         if (parent) {
             child.parent = parent;
@@ -149,7 +149,7 @@ export class DefaultGModelSerializer implements GModelSerializer {
         return child;
     }
 
-    protected initializeParent(parent: GModelElement, schema: SModelElementSchema): GModelElement {
+    protected initializeParent(parent: GModelElement, schema: GModelElementSchema): GModelElement {
         this.initializeElement(parent, schema);
         if (schema.children) {
             parent.children = schema.children.map(childSchema => this.createElement(childSchema, parent));

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

@@ -92,6 +92,9 @@ export class DefaultModelState implements ModelState {
     }
 
     updateRoot(newRoot: GModelRoot): void {
+        if (!newRoot.revision && this.root) {
+            newRoot.revision = this.root.revision;
+        }
         this.root = newRoot;
         this.index.indexRoot(newRoot);
     }