@eclipse-glsp/server 1.1.0-RC10 → 1.1.0-next.2ae7567.68

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

@@ -0,0 +1,147 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/graph';
+import {
+    AnyObject,
+    CreateEdgeOperation,
+    CreateNodeOperation,
+    MaybePromise,
+    Point,
+    TriggerEdgeCreationAction,
+    TriggerNodeCreationAction,
+    hasFunctionProp,
+    hasObjectProp
+} from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { AbstractRecordingCommand } from '../command/recording-command';
+import { ModelState } from '../features/model/model-state';
+import { getRelativeLocation } from '../utils/layout-util';
+import { CreateEdgeOperationHandler, CreateNodeOperationHandler } from './create-operation-handler';
+import { OperationHandler } from './operation-handler';
+
+/**
+ * Helper interface for {@link ModelState} implementations of diagram languages that use a (serializable) JSON-based source model.
+ * Has to be implemented in order to reuse the {@link JsonOperationHandler} API.
+ */
+export interface JsonModelState<JsonObject extends AnyObject = AnyObject> extends ModelState {
+    readonly sourceModel: JsonObject;
+    updateSourceModel(sourceModel: JsonObject): void;
+}
+
+export namespace JsonModelState {
+    export function is(modelState: ModelState): modelState is JsonModelState {
+        return hasObjectProp(modelState, 'sourceModel') && hasFunctionProp(modelState, 'updateSourceModel');
+    }
+}
+
+/**
+ * Simple base implementation of {@link AbstractRecordingCommand} that allows recording of changes made
+ * to the `sourceModel` of the given {@link JsonModelState} during the given `doExecute` function
+ */
+export class JsonRecordingCommand<JsonObject extends AnyObject = AnyObject> extends AbstractRecordingCommand<JsonObject> {
+    constructor(protected modelState: JsonModelState<JsonObject>, protected doExecute: () => MaybePromise<void>) {
+        super();
+    }
+
+    protected override getJsonObject(): MaybePromise<JsonObject> {
+        return this.modelState.sourceModel;
+    }
+
+    protected override postChange(newModel: JsonObject): MaybePromise<void> {
+        this.modelState.updateSourceModel(newModel);
+    }
+}
+
+/**
+ * Reusable {@link OperationHandler} base implementation for diagram languages that use a (serializable) JSON-based source model.
+ * To use this class (or its subclasses) the injected {@link ModelState} has to implement the {@link JsonModelState} interface.
+ *
+ */
+@injectable()
+export abstract class JsonOperationHandler extends OperationHandler {
+    protected commandOf(runnable: () => void): Command {
+        if (!JsonModelState.is(this.modelState)) {
+            throw new Error('Cannot create command. The underlying model state does not implement the `JsonModelState` interface');
+        }
+        return new JsonRecordingCommand(this.modelState, runnable);
+    }
+}
+
+/**
+ * Reusable {@link CreateNodeOperationHandler} base implementation for diagram languages that use a (serializable) JSON-based source model.
+ */
+@injectable()
+export abstract class JsonCreateNodeOperationHandler extends JsonOperationHandler implements CreateNodeOperationHandler {
+    abstract elementTypeIds: string[];
+    abstract override label: string;
+    override readonly operationType = CreateNodeOperation.KIND;
+
+    abstract override createCommand(operation: CreateNodeOperation): MaybePromise<Command | undefined>;
+
+    getTriggerActions(): TriggerNodeCreationAction[] {
+        return this.elementTypeIds.map(typeId => TriggerNodeCreationAction.create(typeId));
+    }
+
+    /**
+     * Return the GModelElement that will contain the newly created node. It is usually
+     * the target element ({@link CreateNodeOperation.containerId}), but could also
+     * be e.g. an intermediate compartment, or even a different Node.
+     *
+     * @param operation
+     * @return the GModelElement that will contain the newly created node.
+     */
+    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
+        const index = this.modelState.index;
+        return operation.containerId ? index.get(operation.containerId) : undefined;
+    }
+
+    getLocation(operation: CreateNodeOperation): Point | undefined {
+        return operation.location;
+    }
+
+    /**
+     * Retrieves the diagram absolute location and the target container from the given {@link CreateNodeOperation}
+     * and converts the absolute location to coordinates relative to the given container.
+     *  Relative coordinates can only be retrieved if the given container element is part of
+     * a hierarchy of {@link GBoundsAware} elements. This means each (recursive) parent element need to
+     * implement {@link GBoundsAware}. If that is not the case this method returns `undefined`.
+     * @param absoluteLocation The diagram absolute position.
+     * @param container The container element.
+     * @returns The relative position or `undefined`.
+     */
+    getRelativeLocation(operation: CreateNodeOperation): Point | undefined {
+        const container = this.getContainer(operation) ?? this.modelState.root;
+        const absoluteLocation = this.getLocation(operation) ?? Point.ORIGIN;
+        return getRelativeLocation(absoluteLocation, container);
+    }
+}
+
+/**
+ * Reusable {@link CreateEdgeOperationHandler} base implementation for diagram languages that use a (serializable) JSON-based source model.
+ */
+@injectable()
+export abstract class JsonCreateEdgeOperationHandler extends JsonOperationHandler implements CreateEdgeOperationHandler {
+    abstract elementTypeIds: string[];
+    abstract override label: string;
+    override readonly operationType = CreateEdgeOperation.KIND;
+
+    abstract override createCommand(operation: CreateEdgeOperation): MaybePromise<Command | undefined>;
+
+    getTriggerActions(): TriggerEdgeCreationAction[] {
+        return this.elementTypeIds.map(typeId => TriggerEdgeCreationAction.create(typeId));
+    }
+}

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

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, MaybePromise, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
+import { Action, MaybePromise, MessageAction, Operation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../actions/action-handler';
 import { Command } from '../command/command';
@@ -47,7 +47,7 @@ export class OperationActionHandler implements ActionHandler {
         }
         if (this.modelState.isReadonly) {
             return [
-                ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
+                MessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
                     severity: 'WARNING'
                 })
             ];

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

@@ -13,9 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Args, CreateOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
+import { Args, CreateOperation, Operation } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { Command } from '../command/command';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { Registry } from '../utils/registry';
 import { CreateOperationHandler } from './create-operation-handler';
@@ -35,16 +34,6 @@ export class OperationHandlerRegistry extends Registry<string, OperationHandler>
     getOperationHandler(operation: Operation): OperationHandler | undefined {
         return CreateOperation.is(operation) ? this.get(`${operation.kind}_${operation.elementTypeId}`) : this.get(operation.kind);
     }
-
-    /**
-     * Returns the matching command for the given operation.
-     *
-     * @param operation operation
-     * @return the matching command for the given operation
-     */
-    getExecutableCommand(operation: Operation): MaybePromise<Command | undefined> {
-        return this.getOperationHandler(operation)?.createCommand(operation);
-    }
 }
 
 @injectable()

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

@@ -37,7 +37,7 @@ export abstract class OperationHandler {
      *
      * @returns the operation type that can be handled.
      */
-    abstract operationType: string;
+    abstract readonly operationType: string;
 
     readonly label?: string;
 
@@ -46,7 +46,7 @@ export abstract class OperationHandler {
      * is performed on the model(s).
      *
      * @param operation The operation to process.
-     * @return The created command to be executed on the command stack or `undefined` nothing should be done.
+     * @return The created command to be executed on the command stack or `undefined` if nothing should be done.
      */
     abstract createCommand(operation: Operation): MaybePromise<Command | undefined>;
 

package/src/common/protocol/client-action.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action } from '@eclipse-glsp/protocol';
+
+/**
+ * A helper interface that allows the server to mark actions that have been received from the client.
+ */
+export interface ClientAction extends Action {
+    __receivedFromClient: true;
+}
+
+export namespace ClientAction {
+    export function is(object: unknown): object is ClientAction {
+        return Action.is(object) && '__receivedFromClient' in object && object.__receivedFromClient === true;
+    }
+
+    /**
+     * Mark the given action as {@link ClientAction} by attaching the "__receivedFromClient" property
+     * @param action The action that should be marked as client action
+     */
+    export function mark(action: Action): void {
+        (action as ClientAction).__receivedFromClient = true;
+    }
+}

package/src/common/protocol/glsp-server.spec.ts

@@ -20,6 +20,7 @@ import {
     InitializeClientSessionParameters,
     InitializeParameters
 } from '@eclipse-glsp/protocol';
+import * as assert from 'assert';
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import * as sinon from 'sinon';
@@ -28,7 +29,6 @@ import { ClientSessionManager } from '../session/client-session-manager';
 import * as mock from '../test/mock-util';
 import { Logger } from '../utils/logger';
 import { DefaultGLSPServer } from './glsp-server';
-import assert = require('assert');
 
 describe('test DefaultGLSPServer', () => {
     const container = new Container();
@@ -36,8 +36,8 @@ describe('test DefaultGLSPServer', () => {
     const diagramType = 'myDiagram';
     const applicationId = 'Test';
     const protocolVersion = '1.0.0';
-    const serverActionKinds = new Map<string, string[]>();
-    serverActionKinds.set(diagramType, ['A1', 'A2']);
+    const actionKinds = new Map<string, string[]>();
+    actionKinds.set(diagramType, ['A1', 'A2']);
     const sessionManager = new mock.StubClientSessionManager();
     const spy_sessionManager_getOrCreate = sinon.spy(sessionManager, 'getOrCreateClientSession');
     const spy_sessionManager_dispose = sinon.spy(sessionManager, 'disposeClientSession');
@@ -53,7 +53,7 @@ describe('test DefaultGLSPServer', () => {
             bind(Logger).toConstantValue(new mock.StubLogger());
             bind(GLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
             bind(ClientSessionManager).toConstantValue(sessionManager);
-            bind(GlobalActionProvider).toConstantValue({ clientActionKinds: new Map<string, string[]>(), serverActionKinds });
+            bind(GlobalActionProvider).toConstantValue(<GlobalActionProvider>{ actionKinds });
             bind(GLSPServerListener).toConstantValue(listener1);
         })
     );
@@ -70,7 +70,7 @@ describe('test DefaultGLSPServer', () => {
     });
 
     it('Test calls before server initialization (should throw errors)', async () => {
-        assert.rejects(() => glspServer.initializeClientSession({ clientSessionId: 'id', diagramType: 'type' }));
+        assert.rejects(() => glspServer.initializeClientSession({ clientSessionId: 'id', diagramType: 'type', clientActionKinds: [] }));
         assert.rejects(() => glspServer.disposeClientSession({ clientSessionId: 'id' }));
         assert.throws(() => glspServer.process({ clientId: 'id', action: { kind: 'action' } }));
     });
@@ -109,8 +109,8 @@ describe('test DefaultGLSPServer', () => {
         const initializeParameters: InitializeParameters = { applicationId, protocolVersion };
         const result = await glspServer.initialize(initializeParameters);
         expect(result.protocolVersion).to.be.equal(protocolVersion);
-        expect(result.serverActions[diagramType]).to.be.equal(serverActionKinds.get(diagramType));
-        expect(result.serverActions[diagramType]).to.be.equal(serverActionKinds.get(diagramType));
+        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
+        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
         expect(spy_listener1_initialize.calledWith(glspServer));
         expect(spy_listener2_initialize.notCalled);
     });
@@ -119,8 +119,8 @@ describe('test DefaultGLSPServer', () => {
         const initializeParameters: InitializeParameters = { applicationId, protocolVersion };
         const result = await glspServer.initialize(initializeParameters);
         expect(result.protocolVersion).to.be.equal(protocolVersion);
-        expect(result.serverActions[diagramType]).to.be.equal(serverActionKinds.get(diagramType));
-        expect(result.serverActions[diagramType]).to.be.equal(serverActionKinds.get(diagramType));
+        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
+        expect(result.serverActions[diagramType]).to.be.equal(actionKinds.get(diagramType));
     });
 
     it('initialize -  subsequent call with other parameters', async () => {
@@ -131,7 +131,8 @@ describe('test DefaultGLSPServer', () => {
     it('initialize client session', async () => {
         const initializeClientSessionParameters: InitializeClientSessionParameters = {
             clientSessionId,
-            diagramType
+            diagramType,
+            clientActionKinds: []
         };
         await glspServer.initializeClientSession(initializeClientSessionParameters);
         expect(spy_sessionManager_getOrCreate.calledWith(initializeClientSessionParameters));

package/src/common/protocol/glsp-server.ts

@@ -17,7 +17,6 @@ import {
     ActionMessage,
     Args,
     DisposeClientSessionParameters,
-    distinctAdd,
     GLSPClientProxy,
     GLSPServer,
     GLSPServerListener,
@@ -25,9 +24,10 @@ import {
     InitializeParameters,
     InitializeResult,
     MaybePromise,
-    remove,
+    MessageAction,
     ServerActions,
-    ServerMessageAction
+    distinctAdd,
+    remove
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional } from 'inversify';
 import { GlobalActionProvider } from '../actions/global-action-provider';
@@ -35,6 +35,7 @@ import { ClientSession } from '../session/client-session';
 import { ClientSessionManager } from '../session/client-session-manager';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { Logger } from '../utils/logger';
+import { ClientAction } from './client-action';
 
 @injectable()
 export class DefaultGLSPServer implements GLSPServer {
@@ -50,8 +51,7 @@ export class DefaultGLSPServer implements GLSPServer {
     protected actionProvider: GlobalActionProvider;
 
     @inject(GLSPClientProxy)
-    @optional()
-    protected glspClientProxy?: GLSPClientProxy;
+    protected glspClientProxy: GLSPClientProxy;
 
     protected initializeResult?: InitializeResult;
 
@@ -97,7 +97,7 @@ export class DefaultGLSPServer implements GLSPServer {
         this.applicationId = params.applicationId;
         const serverActions: ServerActions = {};
 
-        this.actionProvider.serverActionKinds.forEach((kinds, diagramType) => (serverActions[diagramType] = kinds));
+        this.actionProvider.actionKinds.forEach((kinds, diagramType) => (serverActions[diagramType] = kinds));
 
         let result = { protocolVersion: DefaultGLSPServer.PROTOCOL_VERSION, serverActions };
 
@@ -149,8 +149,9 @@ export class DefaultGLSPServer implements GLSPServer {
         if (!clientSession) {
             throw new Error(`No client session has been initialized for client id: ${clientSessionId}`);
         }
-
-        clientSession.actionDispatcher.dispatch(message.action).catch(error => this.handleProcessError(message, error));
+        const action = message.action;
+        ClientAction.mark(action);
+        clientSession.actionDispatcher.dispatch(action).catch(error => this.handleProcessError(message, error));
     }
 
     protected handleProcessError(message: ActionMessage, reason: any): void | PromiseLike<void> {
@@ -162,16 +163,12 @@ export class DefaultGLSPServer implements GLSPServer {
             details = reason.cause?.toString?.();
             errorMsg = reason.message;
         }
-        const errorAction = ServerMessageAction.create(errorMsg, { severity: 'ERROR', details });
+        const errorAction = MessageAction.create(errorMsg, { severity: 'ERROR', details });
         this.sendToClient({ clientId: message.clientId, action: errorAction });
     }
 
     protected sendToClient(message: ActionMessage): void {
-        if (this.glspClientProxy) {
-            this.glspClientProxy.process(message);
-            return;
-        }
-        throw new Error("Could not send message to client. No 'GLSPClientProxy' is connected");
+        this.glspClientProxy.process(message);
     }
 
     getClientSession(sessionId: string): ClientSession | undefined {

package/src/common/session/client-session-factory.spec.ts

@@ -47,7 +47,7 @@ describe('test DefaultClientSessionFactory', () => {
     const factory = container.resolve(DefaultClientSessionFactory);
 
     it('create - new client session', () => {
-        const session = factory.create({ clientSessionId, diagramType });
+        const session = factory.create({ clientSessionId, diagramType, clientActionKinds: [] });
         expect(session.id).to.be.equal(clientSessionId);
         expect(session.diagramType).to.be.equal(diagramType);
         expect(session.container.parent).to.be.equal(container);
@@ -55,6 +55,6 @@ describe('test DefaultClientSessionFactory', () => {
     });
 
     it('create - unknown diagram type', () => {
-        expect(() => factory.create({ clientSessionId, diagramType: 'unknown-type' })).to.throw(GLSPServerError);
+        expect(() => factory.create({ clientSessionId, diagramType: 'unknown-type', clientActionKinds: [] })).to.throw(GLSPServerError);
     });
 });

package/src/common/session/client-session-factory.ts

@@ -52,18 +52,18 @@ export class DefaultClientSessionFactory implements ClientSessionFactory {
     protected glspClient: GLSPClientProxy;
 
     create(params: InitializeClientSessionParameters): ClientSession {
-        const { clientSessionId: id, diagramType, args } = params;
+        const { clientSessionId: clientId, diagramType, clientActionKinds, args } = params;
         const diagramModules = this.diagramModules.get(diagramType);
         if (!diagramModules || diagramModules.length === 0) {
             throw new GLSPServerError(`Could not retrieve diagram module configuration for diagram type: '${diagramType}''`);
         }
 
-        const sessionModule = createClientSessionModule(id, this.glspClient);
+        const sessionModule = createClientSessionModule({ clientId, glspClient: this.glspClient, clientActionKinds });
         const sessionContainer = this.serverContainer.createChild();
         sessionContainer.load(...diagramModules, sessionModule);
         const initializers = sessionContainer.getAll<ClientSessionInitializer>(ClientSessionInitializer);
         initializers.forEach(service => service.initialize(args));
         const actionDispatcher = sessionContainer.get<ActionDispatcher>(ActionDispatcher);
-        return new DefaultClientSession(id, diagramType, actionDispatcher, sessionContainer);
+        return new DefaultClientSession(clientId, diagramType, actionDispatcher, sessionContainer);
     }
 }

package/src/common/session/client-session-manager.spec.ts

@@ -13,13 +13,13 @@
  *
  * 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 * as sinon from 'sinon';
 import * as mock from '../test/mock-util';
 import { Logger } from '../utils/logger';
 import { ClientSessionFactory } from './client-session-factory';
 import { DefaultClientSessionManager } from './client-session-manager';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
 
 describe('test DefaultClientSessionManager', () => {
     const testSession = mock.createClientSession('myId', 'myDiagram');
@@ -47,7 +47,8 @@ describe('test DefaultClientSessionManager', () => {
         // Test execution
         const createdSession = sessionManager.getOrCreateClientSession({
             clientSessionId: testSession.id,
-            diagramType: testSession.diagramType
+            diagramType: testSession.diagramType,
+            clientActionKinds: []
         });
         expect(createdSession).to.not.be.undefined;
         expect(createdSession.id).to.be.equal(testSession.id);

package/src/common/utils/client-options-util.ts

@@ -13,10 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Args } from '@eclipse-glsp/protocol';
+import { ArgsUtil } from './args-util';
+
 export class ClientOptionsUtil {
     private static FILE_PREFIX = 'file://';
+    public static IS_RECONNECTING = 'isReconnecting';
 
     public static adaptUri(uri: string): string {
         return uri.replace(this.FILE_PREFIX, '');
     }
+
+    public static isReconnecting(options?: Args): boolean {
+        return ArgsUtil.getBoolean(options, ClientOptionsUtil.IS_RECONNECTING);
+    }
 }

package/src/common/utils/promise-queue.ts

@@ -62,14 +62,13 @@ export class PromiseQueue<T = void> {
             return false;
         }
 
-        try {
-            this.busy = true;
-            this.resolveQueuedPromise(element);
-        } catch (error) {
+        this.busy = true;
+        this.resolveQueuedPromise(element).catch(error => {
             element.reject(error);
             this.busy = false;
             this.dequeue();
-        }
+        });
+
         return true;
     }
 

package/src/common/utils/registry.spec.ts

@@ -13,14 +13,16 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { MultiRegistry, Registry } from './registry';
 import { expect } from 'chai';
+import { NullLogger } from './logger';
+import { MultiRegistry, Registry } from './registry';
 
 describe('Test Registry', () => {
     let registry: Registry<string, string>;
 
     beforeEach(() => {
         registry = new Registry();
+        registry['logger'] = new NullLogger();
     });
 
     it('register - with new key-value pair', () => {

package/src/common/utils/registry.ts

@@ -14,7 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { remove } from '@eclipse-glsp/protocol/lib/utils/array-util';
-import { injectable } from 'inversify';
+import { inject, injectable } from 'inversify';
+import { Logger } from './logger';
 
 /**
  * A registry manages a set of key-value pairs and provides query functionality. In GLSP this is typically used to
@@ -27,6 +28,9 @@ import { injectable } from 'inversify';
 
 @injectable()
 export class Registry<K, V> {
+    @inject(Logger)
+    protected logger: Logger;
+
     protected elements: Map<K, V> = new Map();
     /**
      * Registers a new key-value pair.
@@ -36,11 +40,12 @@ export class Registry<K, V> {
      * @returns `true` if the pair was registered successfully, `false` if another pair with the same key is already
      *         registered.
      */
-    register(key: K, instance: V): boolean {
+    register(key: K, value: V): boolean {
         if (!this.hasKey(key)) {
-            this.elements.set(key, instance);
+            this.elements.set(key, value);
             return true;
         }
+        this.logger.warn('Could not register key-value pair. Key is already registered', { key, value });
         return false;
     }
 

package/src/node/abstract-json-model-storage.ts

@@ -14,8 +14,9 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { MaybePromise, RequestModelAction, SaveModelAction, TypeGuard } from '@eclipse-glsp/protocol';
-import * as fs from 'fs-extra';
+import * as fs from 'fs';
 import { inject, injectable } from 'inversify';
+import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { ModelState, SOURCE_URI_ARG } from '../common/features/model/model-state';
 import { SourceModelStorage } from '../common/features/model/source-model-storage';
@@ -91,7 +92,12 @@ export abstract class AbstractJsonModelStorage implements SourceModelStorage {
     }
 
     protected toPath(sourceUri: string): string {
-        return sourceUri.startsWith('file://') ? fileURLToPath(sourceUri) : sourceUri;
+        let path = sourceUri.startsWith('file://') ? fileURLToPath(sourceUri) : sourceUri;
+        if (os.platform() === 'win32') {
+            // Remove the leading slash if it exists (Windows paths don't have it)
+            path = path.replace(/^\//, '');
+        }
+        return path;
     }
 
     protected getFileUri(action: SaveModelAction): string {

package/src/node/gmodel/gmodel-storage.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GGraph, GModelElementSchema } from '@eclipse-glsp/graph';
-import { MaybePromise, RequestModelAction, SaveModelAction } from '@eclipse-glsp/protocol';
+import { GGraph } from '@eclipse-glsp/graph';
+import { MaybePromise, RequestModelAction, SaveModelAction, isGModelElementSchema } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { GModelSerializer } from '../../common/features/model/gmodel-serializer';
 import { ModelState } from '../../common/features/model/model-state';
@@ -40,7 +40,7 @@ export class GModelStorage extends AbstractJsonModelStorage {
 
     loadSourceModel(action: RequestModelAction): MaybePromise<void> {
         const sourceUri = this.getSourceUri(action);
-        const rootSchema = this.loadFromFile(sourceUri, GModelElementSchema.is);
+        const rootSchema = this.loadFromFile(sourceUri, isGModelElementSchema);
         const root = this.modelSerializer.createRoot(rootSchema);
         this.modelState.updateRoot(root);
     }

package/src/node/launch/cli-parser.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import * as cmd from 'commander';
-import * as fs from 'fs-extra';
+import * as fs from 'fs';
 import * as path from 'path';
 import { LogLevel, LoggerConfigOptions, asLogLevel } from '../../common/utils/logger';
 

package/lib/common/diagram/request-type-hints-action-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request-type-hints-action-handler.d.ts","sourceRoot":"","sources":["../../../src/common/diagram/request-type-hints-action-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;kFAckF;AAClF,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,sBAAsB,EAAsB,MAAM,wBAAwB,CAAC;AAE1G,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/D,qBACa,6BAA8B,YAAW,aAAa;IACjC,SAAS,CAAC,oBAAoB,EAAE,oBAAoB,CAAC;IACnF,MAAM,CAAC,KAAK,WAAiC;IAE7C,OAAO,CAAC,MAAM,EAAE,sBAAsB,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC;IAS/D,QAAQ,CAAC,WAAW,WAAiC;CACxD"}

package/lib/common/diagram/request-type-hints-action-handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"request-type-hints-action-handler.js","sourceRoot":"","sources":["../../../src/common/diagram/request-type-hints-action-handler.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA;;;;;;;;;;;;;;kFAckF;AAClF,qDAA0G;AAC1G,yCAA+C;AAE/C,mEAA+D;AAGxD,IAAM,6BAA6B,2CAAnC,MAAM,6BAA6B;IAAnC;QAaM,gBAAW,GAAG,CAAC,iCAAsB,CAAC,IAAI,CAAC,CAAC;IACzD,CAAC;IAVG,OAAO,CAAC,MAA8B;QAClC,OAAO;YACH,6BAAkB,CAAC,MAAM,CAAC;gBACtB,UAAU,EAAE,IAAI,CAAC,oBAAoB,CAAC,cAAc;gBACpD,SAAS,EAAE,IAAI,CAAC,oBAAoB,CAAC,aAAa;aACrD,CAAC;SACL,CAAC;IACN,CAAC;;AATM,mCAAK,GAAG,CAAC,iCAAsB,CAAC,IAAI,CAAC,AAAhC,CAAiC;AADL;IAAvC,IAAA,kBAAM,EAAC,4CAAoB,CAAC;;2EAAsD;wCAD1E,6BAA6B;IADzC,IAAA,sBAAU,GAAE;GACA,6BAA6B,CAczC"}