@eclipse-glsp/server 1.1.0-next.146ae06.49 → 1.1.0-next.342c713.66

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,41 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    CenterAction,
-    DeleteMarkersAction,
-    ExportSvgAction,
-    FitToScreenAction,
-    NavigateToExternalTargetAction,
-    NavigateToTargetAction,
-    RequestBoundsAction,
-    SelectAction,
-    SelectAllAction,
-    ServerMessageAction,
-    ServerStatusAction,
-    SetBoundsAction,
-    SetClipboardDataAction,
-    SetContextActions,
-    SetDirtyStateAction,
-    SetEditModeAction,
-    SetEditValidationResultAction,
-    SetMarkersAction,
-    SetModelAction,
-    SetNavigationTargetsAction,
-    SetPopupModelAction,
-    SetResolvedNavigationTargetAction,
-    SetTypeHintsAction,
-    SetViewportAction,
-    SourceModelChangedAction,
-    TriggerEdgeCreationAction,
-    TriggerNodeCreationAction,
-    UpdateModelAction
-} 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';
@@ -86,6 +56,7 @@ import { RequestNavigationTargetsActionHandler } from '../features/navigation/re
 import { ResolveNavigationTargetsActionHandler } from '../features/navigation/resolve-navigation-targets-action-handler';
 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 { ModelValidator } from '../features/validation/model-validator';
 import { RequestMarkersHandler } from '../features/validation/request-markers-handler';
 import { CompoundOperationHandler } from '../operations/compound-operation-handler';
@@ -93,11 +64,10 @@ import { OperationActionHandler } from '../operations/operation-action-handler';
 import { OperationHandlerConstructor, OperationHandlerFactory } from '../operations/operation-handler';
 import { OperationHandlerRegistry, OperationHandlerRegistryInitializer } from '../operations/operation-handler-registry';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
-import { applyBindingTarget, applyOptionalBindingTarget, BindingTarget } from './binding-target';
+import { BindingTarget, applyBindingTarget, applyOptionalBindingTarget } from './binding-target';
 import { GLSPModule } from './glsp-module';
 import { InstanceMultiBinding, MultiBinding } from './multi-binding';
 import {
-    ClientActionKinds,
     ClientId,
     ContextActionsProviders,
     ContextEditValidators,
@@ -133,6 +103,7 @@ import {
  * - {@link ContextActionsProviders} as {@link ClassMultiBinding<ContextActionsProvider>} (empty)
  * - {@link ContextActionsProviderRegistry}
  * - {@link ActionDispatcher}
+ * - {@link ProgressService}
  * - {@link ClientActionKinds} as {@link InstanceMultiBinding<string>}
  * - {@link ActionHandler} as {@link InstanceMultiBinding<ActionHandlerConstructor>}
  * - {@link ActionHandlerFactory}
@@ -162,6 +133,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();
@@ -186,7 +158,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)
         );
@@ -217,6 +188,7 @@ export abstract class DiagramModule extends GLSPModule {
         this.configureMultiBinding(new MultiBinding<ClientSessionInitializer>(ClientSessionInitializer), binding =>
             this.configureClientSessionInitializers(binding)
         );
+        applyBindingTarget(context, ProgressService, this.bindProgressService()).inSingletonScope();
         applyOptionalBindingTarget(context, PopupModelFactory, this.bindPopupModelFactory());
         applyOptionalBindingTarget(context, LayoutEngine, this.bindLayoutEngine?.());
     }
@@ -227,7 +199,6 @@ export abstract class DiagramModule extends GLSPModule {
     }
 
     protected configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
-        binding.add(ClientActionHandler);
         binding.add(RequestModelActionHandler);
         binding.add(RequestContextActionsHandler);
         binding.add(RequestTypeHintsActionHandler);
@@ -254,6 +225,10 @@ export abstract class DiagramModule extends GLSPModule {
         return DefaultGModelSerializer;
     }
 
+    protected bindClientActionForwarder(): BindingTarget<ClientActionForwarder> {
+        return ClientActionForwarder;
+    }
+
     protected bindGModelIndex(): BindingTarget<GModelIndex> {
         return GModelIndex;
     }
@@ -308,6 +283,10 @@ export abstract class DiagramModule extends GLSPModule {
         binding.add(LayoutOperationHandler);
     }
 
+    protected bindProgressService(): BindingTarget<ProgressService> {
+        return DefaultProgressService;
+    }
+
     protected configureContextActionProviders(binding: MultiBinding<ContextActionsProvider>): void {
         // empty as default
     }
@@ -320,37 +299,6 @@ export abstract class DiagramModule extends GLSPModule {
         // empty as default
     }
 
-    protected configureClientActions(binding: InstanceMultiBinding<string>): void {
-        binding.add(CenterAction.KIND);
-        binding.add(ExportSvgAction.KIND);
-        binding.add(DeleteMarkersAction.KIND);
-        binding.add(FitToScreenAction.KIND);
-        binding.add(SourceModelChangedAction.KIND);
-        binding.add(NavigateToTargetAction.KIND);
-        binding.add(NavigateToExternalTargetAction.KIND);
-        binding.add(RequestBoundsAction.KIND);
-        binding.add(SelectAction.KIND);
-        binding.add(SelectAllAction.KIND);
-        binding.add(ServerMessageAction.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(ServerStatusAction.KIND);
-        binding.add(TriggerNodeCreationAction.KIND);
-        binding.add(TriggerEdgeCreationAction.KIND);
-        binding.add(UpdateModelAction.KIND);
-    }
-
     protected bindContextActionsProviderRegistry(): BindingTarget<ContextActionsProviderRegistry> {
         return ContextActionsProviderRegistry;
     }

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/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);
     }

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

@@ -20,6 +20,7 @@ import {
     MarkersReason,
     MaybePromise,
     RequestBoundsAction,
+    RequestModelAction,
     SetDirtyStateAction,
     SetMarkersAction,
     SetModelAction,
@@ -35,6 +36,15 @@ import { GModelFactory } from './gmodel-factory';
 import { GModelSerializer } from './gmodel-serializer';
 import { ModelState } from './model-state';
 
+/**
+ * Helper class that provides utility methods to handle model updates i.e.
+ * submit a new model to the client. In addition, to the core model update action this class
+ * also takes care of related behavior like dirty state handling, validation and client/server side layouting.
+ * Note that the submissions handler is only responsible for deriving the set of actions that comprise a model update
+ * but does not actually dispatch them. The returned actions should be either manually dispatched
+ * to the `ActionDispatcher`, or simply returned as the result of an
+ * `ActionHandler.execute` method.
+ */
 @injectable()
 export class ModelSubmissionHandler {
     @inject(DiagramConfiguration)
@@ -60,8 +70,34 @@ export class ModelSubmissionHandler {
     @optional()
     protected validator?: ModelValidator;
 
+    protected requestModelAction?: RequestModelAction;
+
+    /**
+     * Returns a list of actions to submit the initial revision of the client-side model, based on the injected
+     * {@link GModelState}. Typically this method is invoked by the {@link RequestModelActionHandler} when the diagram
+     * is (re)loaded.
+     * <p>
+     * These actions are not processed by this {@link ModelSubmissionHandler}, but should be either manually dispatched
+     * to the {@link ActionDispatcher}, or simply returned as the result of an
+     * {@link ActionHandler#execute(Action)} method.
+     * </p>
+     *
+     * @param requestAction The {@link RequestModelAction} that triggere the initial model update
+     * @return A list of actions to be processed in order to submit the intial model.
+     *
+     */
+    submitInitialModel(requestAction: RequestModelAction): MaybePromise<Action[]> {
+        /*
+         * In the default update action flow a `RequestModelAction` does not directly trigger a `SetModelAction` response
+         * (RequestModelAction (C) -> RequestBoundsAction (S) -> ComputedBoundsAction (C) -> SetModelACtion (S)
+         * Therefore we temporarily store the action later retrival
+         */
+        this.requestModelAction = requestAction;
+        return this.submitModel();
+    }
+
     /**
-     * Returns a list of actions to update the client-side model, based on the specified <code>modelState</code>.
+     * Returns a list of actions to update the client-side model, based on the injected {@link ModelState}
      *
      * These actions are not processed by this {@link ModelSubmissionHandler}, but should be either manually dispatched
      * to the `ActionDispatcher`, or simply returned as the result of an `ActionHandler.execute()` method.
@@ -71,13 +107,15 @@ export class ModelSubmissionHandler {
      */
     submitModel(reason?: DirtyStateChangeReason): MaybePromise<Action[]> {
         this.modelFactory.createModel();
-        this.modelState.root.revision = (this.modelState.root.revision ?? 0) + 1;
-        const root = this.serializeGModel();
+
+        const revision = this.requestModelAction ? 0 : this.modelState.root.revision! + 1;
+        this.modelState.root.revision = revision;
 
         if (this.diagramConfiguration.needsClientLayout) {
+            const root = this.serializeGModel();
             return [RequestBoundsAction.create(root), SetDirtyStateAction.create(this.commandStack.isDirty, { reason })];
         }
-        return [SetModelAction.create(root)];
+        return this.submitModelDirectly(reason);
     }
 
     /**
@@ -102,8 +140,8 @@ export class ModelSubmissionHandler {
         }
         const result: Action[] = [];
         result.push(
-            root.revision === 0
-                ? SetModelAction.create(root)
+            this.requestModelAction
+                ? this.createSetModeAction(root)
                 : UpdateModelAction.create(root, { animate: this.diagramConfiguration.animatedUpdate })
         );
         if (!this.diagramConfiguration.needsClientLayout) {
@@ -116,6 +154,13 @@ export class ModelSubmissionHandler {
         return result;
     }
 
+    protected createSetModeAction(newRoot: GModelRootSchema): SetModelAction {
+        const responseId = this.requestModelAction?.requestId ?? '';
+        const response = SetModelAction.create(newRoot, { responseId });
+        this.requestModelAction = undefined;
+        return response;
+    }
+
     protected serializeGModel(): GModelRootSchema {
         return this.serializer.createSchema(this.modelState.root);
     }

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

@@ -13,11 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, RequestModelAction, ServerMessageAction, ServerStatusAction } from '@eclipse-glsp/protocol';
+import { Action, RequestModelAction, StatusAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionDispatcher } from '../../actions/action-dispatcher';
 import { ActionHandler } from '../../actions/action-handler';
+import { ClientOptionsUtil } from '../../utils/client-options-util';
 import { Logger } from '../../utils/logger';
+import { ProgressMonitor, ProgressService } from '../progress/progress-service';
 import { ModelState } from './model-state';
 import { ModelSubmissionHandler } from './model-submission-handler';
 import { SourceModelStorage } from './source-model-storage';
@@ -41,27 +43,45 @@ export class RequestModelActionHandler implements ActionHandler {
     @inject(ModelSubmissionHandler)
     protected submissionHandler: ModelSubmissionHandler;
 
+    @inject(ProgressService)
+    protected progressService: ProgressService;
+
     async execute(action: RequestModelAction): Promise<Action[]> {
         this.logger.debug('Execute RequestModelAction:', action);
         this.modelState.setAll(action.options ?? {});
 
-        this.notifyClient('Model loading in progress');
-        await this.sourceModelStorage.loadSourceModel(action);
-        // Clear the previous notification.
-        this.notifyClient();
-        return this.submissionHandler.submitModel();
+        const isReconnecting = ClientOptionsUtil.isReconnecting(action.options);
+
+        const progress = this.reportModelLoading('Model loading in progress');
+
+        if (isReconnecting) {
+            await this.handleReconnect(action);
+        } else {
+            await this.sourceModelStorage.loadSourceModel(action);
+        }
+        this.reportModelLoadingFinished(progress);
+
+        return this.submissionHandler.submitInitialModel(action);
+    }
+
+    protected async handleReconnect(action: RequestModelAction): Promise<void> {
+        const oldModelRoot = this.modelState.root;
+        if (oldModelRoot) {
+            // decrease revision by one, as each submit will increase it by one;
+            // the next save would produce warning that source model was changed otherwise
+            this.modelState.root.revision = (this.modelState.root.revision ?? 0) - 1;
+        } else {
+            await this.sourceModelStorage.loadSourceModel(action);
+        }
+    }
+
+    protected reportModelLoading(message: string): ProgressMonitor {
+        this.actionDispatcher.dispatch(StatusAction.create(message, { severity: 'INFO' }));
+        return this.progressService.start(message);
     }
 
-    /**
-     * Send a message and status notification with the given message to the client.
-     * An empty message is an indication for the client to clear previously received notifications.
-     * @param message The message that should be sent to the client
-     */
-    protected notifyClient(message = ''): void {
-        const severity = message.length > 0 ? 'INFO' : 'NONE';
-        this.actionDispatcher.dispatchAll(
-            ServerMessageAction.create(message, { severity }),
-            ServerStatusAction.create(message, { severity })
-        );
+    protected reportModelLoadingFinished(monitor: ProgressMonitor): void {
+        this.actionDispatcher.dispatch(StatusAction.create('', { severity: 'NONE' }));
+        monitor.end();
     }
 }

package/src/common/features/progress/progress-service.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 { EndProgressAction, StartProgressAction, UpdateProgressAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import * as uuid from 'uuid';
+import { ActionDispatcher } from '../../actions/action-dispatcher';
+
+export const ProgressService = Symbol('ProgressService');
+
+/**
+ * Service for starting and monitoring progress reporting to the client.
+ */
+export interface ProgressService {
+    /**
+     * Start a progress reporting.
+     * @param title The title shown in the UI for the progress reporting.
+     * @param options Additional optional options for the progress reporting.
+     * @returns a monitor to update and end the progress reporting later.
+     */
+    start(title: string, options?: ProgressOptions): ProgressMonitor;
+}
+
+/**
+ * Optional progress reporting options.
+ */
+export interface ProgressOptions {
+    /** A message shown in the UI. */
+    message?: string;
+    /* The percentage (value range: 0 to 100) to show in the progress reporting. */
+    percentage?: number;
+}
+
+/**
+ * The monitor of a progress reporting, which can be used to update and end the reporting.
+ */
+export interface ProgressMonitor {
+    /**
+     * Updates an ongoing progress reporting.
+     * @param options Updated message and/or percentage (value range: 0 to 100).
+     */
+    update(options: { message?: string; percentage?: number }): void;
+    /**
+     * Ends an ongoing progress reporting.
+     */
+    end(): void;
+}
+
+@injectable()
+export class DefaultProgressService implements ProgressService {
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    start(title: string, options?: ProgressOptions): ProgressMonitor {
+        const progressId = uuid.v4();
+        this.actionDispatcher.dispatch(StartProgressAction.create({ progressId, title, ...options }));
+        return {
+            update: updateOptions => this.actionDispatcher.dispatch(UpdateProgressAction.create(progressId, updateOptions)),
+            end: () => this.actionDispatcher.dispatch(EndProgressAction.create(progressId))
+        };
+    }
+}

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

@@ -19,7 +19,7 @@ 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 { CreateEdgeOperationHandler } from '../operations/create-operation-handler';
 import { GModelOperationHandler } from './gmodel-operation-handler';
 
 /**
@@ -28,8 +28,8 @@ import { GModelOperationHandler } from './gmodel-operation-handler';
  * (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;
+export abstract class GModelCreateEdgeOperationHandler extends GModelOperationHandler implements CreateEdgeOperationHandler {
+    override readonly operationType = CreateEdgeOperation.KIND;
     abstract override label: string;
     abstract elementTypeIds: string[];
 

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

@@ -19,7 +19,7 @@ import { CreateNodeOperation, MaybePromise, Point, SelectAction, TriggerNodeCrea
 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 { CreateNodeOperationHandler } from '../operations/create-operation-handler';
 import { getRelativeLocation } from '../utils/layout-util';
 import { GModelOperationHandler } from './gmodel-operation-handler';
 
@@ -29,7 +29,7 @@ import { GModelOperationHandler } from './gmodel-operation-handler';
  * (i.e. all operation handlers directly modify the graphical model).
  */
 @injectable()
-export abstract class GModelCreateNodeOperationHandler extends GModelOperationHandler implements CreateOperationHandler {
+export abstract class GModelCreateNodeOperationHandler extends GModelOperationHandler implements CreateNodeOperationHandler {
     @inject(ActionDispatcher)
     protected actionDispatcher: ActionDispatcher;
 
@@ -37,7 +37,7 @@ export abstract class GModelCreateNodeOperationHandler extends GModelOperationHa
 
     abstract override label: string;
 
-    override operationType: CreateOperationKind = CreateNodeOperation.KIND;
+    override readonly operationType = CreateNodeOperation.KIND;
 
     override createCommand(operation: CreateNodeOperation): MaybePromise<Command | undefined> {
         return this.commandOf(() => this.executeCreation(operation));

package/src/common/index.ts

@@ -71,6 +71,7 @@ export * from './gmodel/index';
 export * from './launch/glsp-server-launcher';
 export * from './operations/compound-operation-handler';
 export * from './operations/create-operation-handler';
+export * from './operations/json-operation-handler';
 export * from './operations/operation-action-handler';
 export * from './operations/operation-handler';
 export * from './operations/operation-handler-registry';

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

@@ -19,6 +19,11 @@ import { Command, CompoundCommand } from '../command/command';
 import { OperationHandler } from './operation-handler';
 import { OperationHandlerRegistry } from './operation-handler-registry';
 
+/**
+ * Generic {@link OperationHandler} from {@link CompoundOperations}.
+ * Retrieves the corresponding execution commands for the list of (sub) operations
+ * and constructs a {@link CompoundCommand} for them.
+ */
 @injectable()
 export class CompoundOperationHandler extends OperationHandler {
     @inject(OperationHandlerRegistry)
@@ -27,7 +32,7 @@ export class CompoundOperationHandler extends OperationHandler {
     operationType = CompoundOperation.KIND;
 
     async createCommand(operation: CompoundOperation): Promise<Command | undefined> {
-        const maybeCommands = operation.operationList.map(op => this.operationHandlerRegistry.getExecutableCommand(op));
+        const maybeCommands = operation.operationList.map(op => this.operationHandlerRegistry.getOperationHandler(op)?.execute(op));
         const commands: Command[] = [];
 
         for await (const command of maybeCommands) {

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

@@ -19,21 +19,37 @@ import {
     hasArrayProp,
     hasFunctionProp,
     hasStringProp,
+    MaybePromise,
     TriggerEdgeCreationAction,
     TriggerNodeCreationAction
 } from '@eclipse-glsp/protocol';
+import { Command } from '../command/command';
 import { OperationHandler } from './operation-handler';
 
 /**
- * A special {@link OperationHandler} that is responsible for the handling of {@link CreateOperation}s. Depending on its
+ * A special {@link OperationHandler} that is responsible for the handling of (a subset of) {@link CreateEdgeOperation}s. Depending on its
  * operation type the triggered actions are {@link TriggerNodeCreationAction} or {@link TriggerEdgeCreationAction}s.
  */
-export interface CreateOperationHandler extends OperationHandler {
+export interface CreateEdgeOperationHandler extends OperationHandler {
+    label: string;
+    elementTypeIds: string[];
+    operationType: typeof CreateEdgeOperation.KIND;
+    getTriggerActions(): TriggerEdgeCreationAction[];
+    createCommand(operation: CreateEdgeOperation): MaybePromise<Command | undefined>;
+}
+
+export interface CreateNodeOperationHandler extends OperationHandler {
     readonly label: string;
     elementTypeIds: string[];
-    operationType: CreateOperationKind;
-    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[];
+    operationType: typeof CreateNodeOperation.KIND;
+    getTriggerActions(): TriggerNodeCreationAction[];
+    createCommand(operation: CreateNodeOperation): MaybePromise<Command | undefined>;
 }
+/**
+ * A special {@link OperationHandler} that is responsible for the handling of a node or edge creation operation. Depending on its
+ * operation type the triggered actions are {@link TriggerNodeCreationAction} or {@link TriggerEdgeCreationAction}s.
+ */
+export type CreateOperationHandler = CreateNodeOperationHandler | CreateEdgeOperationHandler;
 
 export type CreateOperationKind = typeof CreateNodeOperation.KIND | typeof CreateEdgeOperation.KIND;
 
@@ -41,9 +57,10 @@ export namespace CreateOperationHandler {
     export function is(object: unknown): object is CreateOperationHandler {
         return (
             object instanceof OperationHandler &&
+            hasStringProp(object, 'operationType') &&
             hasStringProp(object, 'label') &&
             hasArrayProp(object, 'elementTypeIds') &&
-            hasFunctionProp(object, 'getTriggerActions')
+            hasFunctionProp(object, 'getTriggerActions', true)
         );
     }
 }