@eclipse-glsp/server 1.1.0-next.f692ea4.55 → 2.1.0-next.70

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

@@ -13,45 +13,14 @@
  *
  * 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';
-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';
@@ -86,6 +55,10 @@ 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 { 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';
@@ -93,11 +66,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 +105,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}
@@ -150,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 {
@@ -162,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();
@@ -186,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)
         );
@@ -201,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)
         );
@@ -217,8 +191,10 @@ export abstract class DiagramModule extends GLSPModule {
         this.configureMultiBinding(new MultiBinding<ClientSessionInitializer>(ClientSessionInitializer), binding =>
             this.configureClientSessionInitializers(binding)
         );
-        applyOptionalBindingTarget(context, PopupModelFactory, this.bindPopupModelFactory());
-        applyOptionalBindingTarget(context, LayoutEngine, this.bindLayoutEngine?.());
+        applyBindingTarget(context, ProgressService, this.bindProgressService()).inSingletonScope();
+        applyOptionalBindingTarget(context, PopupModelFactory, this.bindPopupModelFactory())?.inSingletonScope();
+        applyOptionalBindingTarget(context, LayoutEngine, this.bindLayoutEngine())?.inSingletonScope();
+        applyOptionalBindingTarget(context, EdgeCreationChecker, this.bindEdgeCreationChecker())?.inSingletonScope();
     }
 
     configureClientSessionInitializers(binding: MultiBinding<ClientSessionInitializer>): void {
@@ -227,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);
@@ -254,6 +230,10 @@ export abstract class DiagramModule extends GLSPModule {
         return DefaultGModelSerializer;
     }
 
+    protected bindClientActionForwarder(): BindingTarget<ClientActionForwarder> {
+        return ClientActionForwarder;
+    }
+
     protected bindGModelIndex(): BindingTarget<GModelIndex> {
         return GModelIndex;
     }
@@ -308,6 +288,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 +304,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;
     }
@@ -383,6 +336,7 @@ export abstract class DiagramModule extends GLSPModule {
     protected bindModelValidator(): BindingTarget<ModelValidator> | undefined {
         return undefined;
     }
+
     protected bindLabelEditValidator(): BindingTarget<LabelEditValidator> | undefined {
         return undefined;
     }
@@ -390,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;
     }
@@ -404,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);
     }

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

@@ -13,24 +13,38 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelRootSchema } from '@eclipse-glsp/graph';
 import {
     Action,
     DirtyStateChangeReason,
+    GModelRootSchema,
+    MarkersReason,
     MaybePromise,
     RequestBoundsAction,
+    RequestModelAction,
     SetDirtyStateAction,
+    SetMarkersAction,
     SetModelAction,
     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 { ModelValidator } from '../validation/model-validator';
 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)
@@ -52,8 +66,38 @@ export class ModelSubmissionHandler {
     @inject(CommandStack)
     protected commandStack: CommandStack;
 
+    @inject(ModelValidator)
+    @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.
@@ -63,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);
     }
 
     /**
@@ -94,16 +140,27 @@ 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) {
             result.push(SetDirtyStateAction.create(this.commandStack.isDirty, { reason }));
         }
+        if (this.validator) {
+            const markers = await this.validator.validate([this.modelState.root], MarkersReason.LIVE);
+            result.push(SetMarkersAction.create(markers, { reason: MarkersReason.LIVE }));
+        }
         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))
+        };
+    }
+}