@eclipse-glsp/server 1.1.0-RC05

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

@@ -0,0 +1,66 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { ContainerModule, injectable, interfaces } from 'inversify';
+import { AbstractMultiBinding } from './multi-binding';
+
+/**
+ * A wrapper interface to get access to the binding related functions
+ * for a inversify container.
+ */
+export interface ModuleContext {
+    bind: interfaces.Bind;
+    unbind: interfaces.Unbind;
+    isBound: interfaces.IsBound;
+    rebind: interfaces.Rebind;
+}
+
+/**
+ * Common super class for GLSP {@link ContainerModule}s.
+ */
+@injectable()
+export abstract class GLSPModule extends ContainerModule {
+    public static CLIENT_ACTIONS = 'ClientActions';
+
+    protected context: ModuleContext;
+
+    constructor() {
+        super((bind, unbind, isBound, rebind) => {
+            this.context = { bind, unbind, isBound, rebind };
+            this.configure(bind, unbind, isBound, rebind);
+        });
+    }
+
+    protected abstract configure(
+        bind: interfaces.Bind,
+        unbind: interfaces.Unbind,
+        isBound: interfaces.IsBound,
+        rebind: interfaces.Rebind
+    ): void;
+
+    /**
+     * Configuration method for multibound values. The passed configurator is typically a submethod of this module. This
+     * means
+     * that subclasses can customize the {@link MultiBinding} object before the actual {@link MultiBinding} is created.
+     *
+     * @param <T>          Type of the {@link MultiBinding}
+     * @param binding      The multi binding configuration object
+     * @param configurator The consumer that should be used to configure the given {@link MultiBinding}
+     */
+    protected configureMultiBinding<T>(binding: AbstractMultiBinding<T>, configurator: (binding: AbstractMultiBinding<T>) => void): void {
+        configurator(binding);
+        binding.applyBindings(this.context);
+    }
+}

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

@@ -0,0 +1,89 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { distinctAdd, flatPush, MaybeArray, remove } from '@eclipse-glsp/protocol';
+import { applyBindingTarget, BindingTarget } from './binding-target';
+import { ModuleContext } from './glsp-module';
+
+/**
+ * A helper class used in `GLSPModules` to ease the configuration of multi-injected service identifiers.
+ * Instead of directly binding to the service identifier a new multi binding object can be created. This object
+ * should then be passed to a overridable configuration-function (i.e. configure(binding:V)=>void). This gives subclasses of the
+ * `GLSPModule` the chance to manipulate the binding configuration using the provided manipulation methods (e.g. add,remove, rebind).
+ * Once the configuration is finished the binding can be finalized using the {@link AbstractMultiBinding.applyBindings} method.
+ */
+export abstract class AbstractMultiBinding<T> {
+    protected bindings: T[] = [];
+
+    constructor(readonly identifier: string | symbol) {}
+
+    abstract applyBindings(context: ModuleContext): void;
+
+    add(newBinding: T): void {
+        distinctAdd(this.bindings, newBinding);
+    }
+
+    addAll(newBindings: T[]): void;
+    addAll(...newBindings: T[]): void;
+    addAll(...newBindings: MaybeArray<T>[]): void {
+        const result: T[] = [];
+        flatPush(result, newBindings);
+        result.forEach(newBinding => this.add(newBinding));
+    }
+
+    remove(toRemove: T): void {
+        remove(this.bindings, toRemove);
+    }
+
+    removeAll(toRemove: T[]): void {
+        return toRemove.forEach(binding => this.remove(binding));
+    }
+
+    rebind(oldBinding: T, newBinding: T): void {
+        this.remove(oldBinding);
+        this.add(newBinding);
+    }
+
+    contains(binding: T): boolean {
+        return this.bindings.includes(binding);
+    }
+
+    getAll(): T[] {
+        return this.bindings;
+    }
+}
+
+/**
+ * Implementation of {@link AbstractMultiBinding} for multi-injected values that using an arbitrary {@link BindingTarget}.
+ *
+ * @typeparam T the base type of {@link BindingTarget}.
+ */
+export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
+    applyBindings(context: ModuleContext): void {
+        this.bindings.forEach(binding => applyBindingTarget(context, this.identifier, binding));
+    }
+}
+
+/**
+ * Implementation of {@link AbstractMultiBinding} for multi-injected values that should be bound to concrete instance using the
+ * `bind(serviceIdentifier).toConstantValue(MyCustomBinding) syntax.
+ *
+ * * @typeparam T the type of the instances
+ */
+export class InstanceMultiBinding<T> extends AbstractMultiBinding<T> {
+    applyBindings(context: ModuleContext): void {
+        context.bind(this.identifier).toConstantValue(this.bindings);
+    }
+}

package/src/common/di/multi-bindings.spec.ts

@@ -0,0 +1,133 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { expect } from 'chai';
+import { Container, ContainerModule, injectable } from 'inversify';
+import { InstanceMultiBinding, MultiBinding } from './multi-binding';
+
+@injectable()
+class TestClass {}
+
+@injectable()
+class TestClass1 extends TestClass {}
+
+@injectable()
+class TestClass2 extends TestClass {}
+
+@injectable()
+class TestClass3 extends TestClass {}
+
+describe('test implementations of MultiBinding', () => {
+    describe('test basic functionaly (ClassMultiBinding) ', () => {
+        const binding = new MultiBinding('TestClass');
+        it('add - new binding', () => {
+            binding.add(TestClass1);
+            expect(binding.contains(TestClass1)).true;
+
+            const result = binding.getAll();
+            expect(result.length).to.be.equal(1);
+            expect(result[0]).to.be.equal(TestClass1);
+        });
+
+        it('add - existing binding', () => {
+            binding.add(TestClass1);
+            expect(binding.getAll().length).to.be.equal(1);
+            expect(binding.getAll()[0]).to.be.equal(TestClass1);
+        });
+
+        it('remove - existing binding', () => {
+            expect(binding.contains(TestClass1)).true;
+            binding.remove(TestClass1);
+            expect(binding.contains(TestClass1)).false;
+            expect(binding.getAll()).to.have.length(0);
+        });
+
+        it('remove - non-existing binding', () => {
+            const previousSize = binding.getAll().length;
+            binding.remove(TestClass2);
+            expect(binding.getAll()).to.have.length(previousSize);
+        });
+
+        it('addAll - TestClass1 & TestClass2', () => {
+            binding.addAll([TestClass1, TestClass2]);
+
+            const result = binding.getAll();
+            expect(result.length).to.be.equal(2);
+            expect(result.includes(TestClass1)).true;
+            expect(result.includes(TestClass2)).true;
+        });
+
+        it('rebind- TestClass2 to TestClass3', () => {
+            binding.rebind(TestClass2, TestClass3);
+            const result = binding.getAll();
+            expect(result.length).to.be.equal(2);
+            expect(result.includes(TestClass1)).true;
+            expect(result.includes(TestClass3)).true;
+        });
+
+        it('rebind- TestClass2 to TestClass3- should fail', () => {
+            binding.rebind(TestClass2, TestClass3);
+            const result = binding.getAll();
+            expect(result.length).to.be.equal(2);
+            expect(result.includes(TestClass1)).true;
+            expect(result.includes(TestClass3)).true;
+        });
+
+        it('removeAll- TestClass1 & TestClass3', () => {
+            binding.removeAll([TestClass1, TestClass3]);
+            const result = binding.getAll();
+            expect(result).to.have.length(0);
+        });
+    });
+
+    describe('test applyBinding', () => {
+        it('apply binding of ClassMultiBinding', () => {
+            const testContainer = new Container();
+            const testModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+                const context = { bind, unbind, isBound, rebind };
+                const binding = new MultiBinding('TestClass');
+                binding.addAll([TestClass1, TestClass2, TestClass3]);
+                binding.applyBindings(context);
+            });
+            testContainer.load(testModule);
+            const result = testContainer.getAll('TestClass');
+            expect(result).to.have.length(3);
+            expect(result.find(instance => instance instanceof TestClass1)).to.not.be.undefined;
+            expect(result.find(instance => instance instanceof TestClass2)).to.not.be.undefined;
+            expect(result.find(instance => instance instanceof TestClass3)).to.not.be.undefined;
+        });
+
+        it('apply binding of InstanceMultiBinding', () => {
+            const t1 = 't1';
+            const t2 = 't2';
+            const t3 = 't3';
+            const identifier = 'myStrings';
+
+            const testContainer = new Container();
+            const testModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+                const context = { bind, unbind, isBound, rebind };
+                const binding = new InstanceMultiBinding<string>(identifier);
+                binding.addAll([t1, t2, t3]);
+                binding.applyBindings(context);
+            });
+            testContainer.load(testModule);
+            const result = testContainer.get<string[]>(identifier);
+            expect(result).to.have.length(3);
+            expect(result.includes(t1)).true;
+            expect(result.includes(t2)).true;
+            expect(result.includes(t3)).true;
+        });
+    });
+});

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

@@ -0,0 +1,131 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { ContainerModule, interfaces } from 'inversify';
+import { DefaultGlobalActionProvider, GlobalActionProvider } from '../actions/global-action-provider';
+import { DefaultGLSPClientProxy, GLSPClientProxy, JsonRpcGLSPClientProxy } from '../protocol/glsp-client-proxy';
+import { DefaultGLSPServer, GLSPServer, JsonRpcGLSPServer } from '../protocol/glsp-server';
+import { GLSPServerListener } from '../protocol/glsp-server-listener';
+import { ClientSessionFactory, DefaultClientSessionFactory } from '../session/client-session-factory';
+import { ClientSessionManager, DefaultClientSessionManager } from '../session/client-session-manager';
+import { applyBindingTarget, BindingTarget } from './binding-target';
+import { DiagramModule } from './diagram-module';
+import { GLSPModule } from './glsp-module';
+import { MultiBinding } from './multi-binding';
+import { DiagramModules, InjectionContainer } from './service-identifiers';
+
+/**
+ * The server module is the central configuration artifact for configuring the server container (i.e. main container). For
+ * each application connecting to the server process a new server container is created. The server module provides the
+ * base bindings necessary for setting up the base {@link GLSPServer} infrastructure. In addition, it is used to
+ * configure the set of {@link DiagramModule}s. Diagram modules are used to create the diagram-session-specific child
+ * container when the
+ * {@link GLSPServer.initializeClientSession()}
+ * method is called.
+ *
+ * The following bindings are provided:
+ *
+ * * {@link Map<String, Module>} annotated with `@named("Diagram_Modules")`
+ * * {@link GLSPServer}
+ * * {@link ClientSessionFactory}
+ * * {@link ClientSessionManager}
+ * * {@link GlobalActionProvider}
+ * * {@link GLSPClientProxy}
+ *
+ */
+export class ServerModule extends GLSPModule {
+    public static DIAGRAM_MODULES = 'Diagram_Modules';
+    protected readonly diagramModules: Map<string, ContainerModule[]> = new Map();
+
+    /**
+     * Configure a new {@link DiagramModule} for this server. A diagram module represents the base configuration artifact
+     * for configuring a diagram-language-specific client session container. The diagram type provided
+     * {@link DiagramModule.diagramType} is used to retrieve the correct diagram module when the {@link GLSPServer}
+     * initializes a new client session.
+     *
+     * @param diagramModule The base diagram module
+     * @param additionalModules Additional modules
+     * @returns The server module itself. This enables a builder-pattern like chaining of multiple diagram configuration
+     *         calls.
+     */
+    configureDiagramModule(diagramModule: DiagramModule, ...additionalModules: ContainerModule[]): ServerModule {
+        const diagramType = diagramModule.diagramType;
+        if (this.diagramModules.has(diagramType)) {
+            throw new Error(`A module configuration is already present for diagram type: '${diagramType}'`);
+        }
+        this.diagramModules.set(diagramType, [diagramModule, ...additionalModules]);
+        return this;
+    }
+
+    configure(bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void {
+        const context = this.context;
+        applyBindingTarget(context, DiagramModules, this.bindDiagramModules());
+
+        applyBindingTarget(context, GLSPServer, this.bindGLSPServer()).inSingletonScope();
+        applyBindingTarget(context, JsonRpcGLSPServer, this.bindJsonRpcGLSPServer());
+        applyBindingTarget(context, ClientSessionFactory, this.bindClientSessionFactory()).inSingletonScope();
+        applyBindingTarget(context, ClientSessionManager, this.bindClientSessionManager()).inSingletonScope();
+        this.configureMultiBinding(new MultiBinding<GLSPServerListener>(GLSPServerListener), binding =>
+            this.configureGLSPServerListeners(binding)
+        );
+
+        applyBindingTarget(context, GlobalActionProvider, this.bindGlobalActionProvider()).inSingletonScope();
+
+        applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
+
+        applyBindingTarget(context, GLSPClientProxy, this.bindGLSPClientProxy()).inSingletonScope();
+        applyBindingTarget(context, JsonRpcGLSPClientProxy, this.bindJsonRpcGLSPClientProxy());
+    }
+
+    protected bindDiagramModules(): BindingTarget<Map<string, ContainerModule[]>> {
+        return { constantValue: this.diagramModules };
+    }
+
+    protected bindGLSPServer(): BindingTarget<GLSPServer> {
+        return DefaultGLSPServer;
+    }
+
+    protected bindJsonRpcGLSPServer(): BindingTarget<JsonRpcGLSPServer> {
+        return { service: GLSPServer };
+    }
+
+    protected bindClientSessionFactory(): BindingTarget<ClientSessionFactory> {
+        return DefaultClientSessionFactory;
+    }
+
+    protected bindClientSessionManager(): BindingTarget<ClientSessionManager> {
+        return DefaultClientSessionManager;
+    }
+
+    protected bindGlobalActionProvider(): BindingTarget<GlobalActionProvider> {
+        return DefaultGlobalActionProvider;
+    }
+
+    protected bindInjectionContainer(): BindingTarget<interfaces.Container> {
+        return { dynamicValue: context => context.container };
+    }
+
+    protected bindGLSPClientProxy(): BindingTarget<GLSPClientProxy> {
+        return DefaultGLSPClientProxy;
+    }
+
+    protected bindJsonRpcGLSPClientProxy(): BindingTarget<JsonRpcGLSPClientProxy> {
+        return { service: GLSPClientProxy };
+    }
+
+    protected configureGLSPServerListeners(binding: MultiBinding<GLSPServerListener>): void {
+        binding.add({ service: ClientSessionManager });
+    }
+}

package/src/common/di/service-identifiers.ts

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { ValidateLabelEditAdapter } from '../features/directediting/context-edit-validator';
+import { LabelEditValidator } from '../features/directediting/label-edit-validator';
+
+export const DiagramType = Symbol('DiagramType');
+
+export const ClientId = Symbol('ClientId');
+
+export const DiagramModules = Symbol('DiagramModules');
+
+export const InjectionContainer = Symbol('InjectionContainer');
+
+export const ClientActionKinds = Symbol('ClientActionKinds');
+
+export const ContextActionsProviders = Symbol('ContextActionsProviders');
+
+export const ContextEditValidators = Symbol('ContextEditValidators');
+
+export const ValidateLabelEditAdapterFactory = Symbol('ValidateLabelEditAdapterFactory');
+
+export const NavigationTargetProviders = Symbol('NavigationTargetProviders');
+
+export type ValidateLabelEditAdapterFactory = (validator: LabelEditValidator) => ValidateLabelEditAdapter;
+
+export const Operations = Symbol('Operations');

package/src/common/diagram/diagram-configuration.ts

@@ -0,0 +1,97 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { GModelElementConstructor } from '@eclipse-glsp/graph';
+import { EdgeTypeHint, ShapeTypeHint } from '@eclipse-glsp/protocol';
+
+/**
+ * Used to configure whether and when a diagram server should auto-layout the graphical model.
+ *
+ * The layout is computed with the layout engine configured, so a value other
+ * than <code>NONE</code> here makes sense only if such an engine is available.
+ */
+export enum ServerLayoutKind {
+    /**
+     * The server re-layouts the diagram on all changes automatically. Layout
+     * information stored in the model will be overwritten.
+     */
+    AUTOMATIC,
+
+    /**
+     * The server re-layouts the diagram only if manually triggered by a
+     * <code>LayoutAction</code>. The layout information must be stored in the model
+     * and will be overwritten on layout.
+     */
+    MANUAL,
+
+    /**
+     * The server never layouts the diagram. This requires that the layout
+     * information is stored in the model.
+     */
+    NONE
+}
+
+export const DiagramConfiguration = Symbol('DiagramConfiguration');
+/**
+ * Provides configuration constants for a specific diagram implementation (i.e. diagram language),
+ * The corresponding configuration for a diagram implementation is identified via its diagram type.
+ */
+export interface DiagramConfiguration {
+    /**
+     * Returns the shape type hints for the diagram implementation. Shape type hints are sent to the client and used to
+     * validate whether certain operations for shapes/nodes are allowed without having to query the server again.
+     *
+     * @returns List of all shape type hints for the diagram implementation.
+     */
+    readonly shapeTypeHints: ShapeTypeHint[];
+
+    /**
+     * Returns the edge type hints for the diagram implementation. Edge type hints are sent to the client and used to
+     * validate whether certain operations for edges are allowed without having to query the server again.
+     *
+     * @returns List of all edge type hints for the diagram implementation.
+     */
+    readonly edgeTypeHints: EdgeTypeHint[];
+
+    /**
+     * Returns the supported layout kind for this diagram implementation.
+     *
+     * @returns The layout kind.
+     */
+    readonly layoutKind: ServerLayoutKind;
+
+    /**
+     * Boolean flag to specific whether the diagram implementation expects the client to provide layout information for
+     * certain diagram element. Default is 'true'.
+     *
+     * @returns Boolean flag to indicate whether the client needs to be involved in the layout process.
+     */
+    readonly needsClientLayout: boolean;
+
+    /**
+     * Boolean flag to tell the client whether changed caused by an update should be animated or not.
+     *
+     * @returns Boolean flag to indicate whether the client should animate update changes.
+     */
+    readonly animatedUpdate: boolean;
+
+    /**
+     * Returns the type mappings for the diagram implementation. Type mappings are used by GSON to construct the correct
+     * {@link EClass} based on the "type" property of the JSON object.
+     *
+     * @returns A complete map of all type mappings for the diagram implementation.
+     */
+    readonly typeMapping: Map<string, GModelElementConstructor>;
+}

package/src/common/diagram/request-type-hints-action-handler.spec.ts

@@ -0,0 +1,59 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { EdgeTypeHint, RequestTypeHintsAction, SetTypeHintsAction, ShapeTypeHint } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import * as mock from '../test/mock-util';
+import { DiagramConfiguration } from './diagram-configuration';
+import { RequestTypeHintsActionHandler } from './request-type-hints-action-handler';
+
+describe('test RequestTypeHintsActionHandler', () => {
+    const container = new Container();
+    const diagramConfiguration = new mock.StubDiagramConfiguration();
+    const shapeTypeHint: ShapeTypeHint = {
+        elementTypeId: 'test',
+        deletable: true,
+        resizable: true,
+        repositionable: true,
+        reparentable: true
+    };
+    const edgeTypeHint: EdgeTypeHint = {
+        elementTypeId: 'test',
+        deletable: true,
+        repositionable: true,
+        routable: true,
+        sourceElementTypeIds: [],
+        targetElementTypeIds: []
+    };
+    diagramConfiguration.shapeTypeHints = [shapeTypeHint];
+    diagramConfiguration.edgeTypeHints = [edgeTypeHint];
+    container.load(
+        new ContainerModule(bind => {
+            bind(DiagramConfiguration).toConstantValue(diagramConfiguration);
+        })
+    );
+    const handler = container.resolve(RequestTypeHintsActionHandler);
+
+    it('execute with correct action', async () => {
+        const result = await handler.execute(RequestTypeHintsAction.create());
+
+        expect(result).to.have.length(1);
+        expect(SetTypeHintsAction.is(result[0])).true;
+        expect(result).to.be.deep.equal([
+            { edgeHints: [edgeTypeHint], kind: 'setTypeHints', shapeHints: [shapeTypeHint], responseId: '' } as SetTypeHintsAction
+        ]);
+    });
+});

package/src/common/diagram/request-type-hints-action-handler.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Action, MaybePromise, RequestTypeHintsAction, SetTypeHintsAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../actions/action-handler';
+import { DiagramConfiguration } from './diagram-configuration';
+
+@injectable()
+export class RequestTypeHintsActionHandler implements ActionHandler {
+    @inject(DiagramConfiguration) protected diagramConfiguration: DiagramConfiguration;
+    static KINDS = [RequestTypeHintsAction.KIND];
+
+    execute(action: RequestTypeHintsAction): MaybePromise<Action[]> {
+        return [
+            SetTypeHintsAction.create({
+                shapeHints: this.diagramConfiguration.shapeTypeHints,
+                edgeHints: this.diagramConfiguration.edgeTypeHints
+            })
+        ];
+    }
+
+    readonly actionKinds = [RequestTypeHintsAction.KIND];
+}