@eclipse-glsp/server 1.1.0-next.dc6b980.47 → 1.1.0-next.de91dcd.60

package/src/common/features/validation/model-validator.ts

@@ -14,7 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { GModelElement } from '@eclipse-glsp/graph';
-import { Marker, MaybePromise } from '@eclipse-glsp/protocol';
+import { Marker, MarkersReason, MaybePromise } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
 
 export const ModelValidator = Symbol('ModelValidator');
 
@@ -28,7 +29,78 @@ export interface ModelValidator {
      * Validates the given list of {@link GModelElement}s and returns a list of {@link Marker}s.
      *
      * @param elements The list of {@link GModelElement} to validate.
-     * @returns A list of {@link Marker}s for the validated {@link GModelElement}s.
+     * @param reason The reason for a validation request, such as "batch" or "live" validation.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}s.
      */
-    validate(elements: GModelElement[]): MaybePromise<Marker[]>;
+    validate(elements: GModelElement[], reason?: string): MaybePromise<Marker[]>;
+}
+
+@injectable()
+export abstract class AbstractModelValidator implements ModelValidator {
+    validate(elements: GModelElement[], reason: string): Marker[] {
+        const markers: Marker[] = [];
+        for (const element of elements) {
+            if (MarkersReason.LIVE === reason) {
+                markers.push(...this.doLiveValidation(element));
+            } else if (MarkersReason.BATCH === reason) {
+                markers.push(...this.doBatchValidation(element));
+            } else {
+                markers.push(...this.doValidationForCustomReason(element));
+            }
+            if (element.children) {
+                markers.push(...this.validate(element.children, reason));
+            }
+        }
+        return markers;
+    }
+
+    /**
+     * Perform the live validation rules for the given <code>element</code>.
+     *
+     * This will be invoked on start and after each operation for all elements.
+     * Thus, the validation should be rather inexpensive.
+     * There is no need to traverse through the children in this method as {@link #validate(List, String)} will invoke
+     * this method for all children anyway.
+     *
+     * @param element The element to validate.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}.
+     */
+    doLiveValidation(element: GModelElement): Marker[] {
+        return [];
+    }
+
+    /**
+     * Perform the batch validation rules for the given <code>element</code>.
+     *
+     * <p>
+     * This will be invoked on demand by the client.
+     * Thus, the validation can include more expensive validation rules.
+     * There is no need to traverse through the children in this method as {@link #validate(List, String)} will invoke
+     * this method for all children anyway.
+     * </p>
+     *
+     * @param element The element to validate.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}.
+     */
+    doBatchValidation(element: GModelElement): Marker[] {
+        return [];
+    }
+
+    /**
+     * Perform a validation for a custom <code>reason</code> with the given <code>element</code>.
+     *
+     * <p>
+     * GLSP editors may add custom reasons for triggering a validation, other than <code>live</code> and
+     * <code>batch</code>.
+     * Validation requests that are not live or batch validations will be handled by this method.
+     * There is no need to traverse through the children in this method as {@link #validate(List, String)} will invoke
+     * this method for all children anyway.
+     * </p>
+     *
+     * @param element The element to validate.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}.
+     */
+    doValidationForCustomReason(element: GModelElement): Marker[] {
+        return [];
+    }
 }

package/src/common/features/validation/request-markers-handler.ts

@@ -13,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GGraph } from '@eclipse-glsp/graph';
-import { Action, Marker, RequestMarkersAction, SetMarkersAction } from '@eclipse-glsp/protocol';
+import { Action, MarkersReason, RequestMarkersAction, SetMarkersAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import { ActionHandler } from '../../actions/action-handler';
 import { GLSPServerError } from '../../utils/glsp-server-error';
@@ -38,14 +37,9 @@ export class RequestMarkersHandler implements ActionHandler {
             elementIDs = [this.modelState.root.id];
         }
 
-        let markers: Marker[] = [];
-        const currentModelIndex = this.modelState.index;
-        for (const elementID of elementIDs) {
-            const modelElement = currentModelIndex.findByClass(elementID, GGraph);
-            if (modelElement) {
-                markers = markers.concat(await this.validator.validate([modelElement]));
-            }
-        }
+        const modelElements = this.modelState.index.getAll(elementIDs);
+        const markers = await this.validator.validate(modelElements, action.reason ?? MarkersReason.BATCH);
+
         return [SetMarkersAction.create(markers)];
     }
 }

package/src/common/index.ts

@@ -74,9 +74,7 @@ export * from './operations/create-operation-handler';
 export * from './operations/operation-action-handler';
 export * from './operations/operation-handler';
 export * from './operations/operation-handler-registry';
-export * from './protocol/glsp-client-proxy';
 export * from './protocol/glsp-server';
-export * from './protocol/glsp-server-listener';
 export * from './session/client-session';
 export * from './session/client-session-factory';
 export * from './session/client-session-initializer';
@@ -84,6 +82,7 @@ export * from './session/client-session-listener';
 export * from './session/client-session-manager';
 export * from './utils/args-util';
 export * from './utils/client-options-util';
+export * from './utils/console-logger';
 export * from './utils/glsp-server-error';
 export * from './utils/layout-util';
 export * from './utils/logger';

package/src/common/launch/glsp-server-launcher.ts

@@ -33,9 +33,9 @@ export abstract class GLSPServerLauncher<T> implements Disposable {
         this._modules.push(serverModule, ...additionalModules);
     }
 
-    createContainer(): Container {
+    createContainer(...additionalModules: ContainerModule[]): Container {
         const container = this.parentContainer ? this.parentContainer.createChild() : new Container();
-        container.load(...this._modules);
+        container.load(...this._modules, ...additionalModules);
         return container;
     }
 

package/src/common/launch/jsonrpc-server-launcher.ts

@@ -0,0 +1,95 @@
+/********************************************************************************
+ * 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 {
+    Disposable,
+    GLSPClientProxy,
+    GLSPServer,
+    JsonrpcClientProxy,
+    JsonrpcGLSPClient,
+    configureClientConnection
+} from '@eclipse-glsp/protocol';
+import { Container, ContainerModule, inject, injectable } from 'inversify';
+import * as jsonrpc from 'vscode-jsonrpc';
+import { Logger } from '../utils/logger';
+import { GLSPServerLauncher } from './glsp-server-launcher';
+
+export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed. Accepting requests on port:';
+
+export interface JsonRpcServerInstance {
+    server: GLSPServer;
+    clientConnection: jsonrpc.MessageConnection;
+    container: Container;
+}
+
+@injectable()
+export abstract class JsonRpcGLSPServerLauncher<T> extends GLSPServerLauncher<T> {
+    @inject(Logger)
+    protected override logger: Logger;
+
+    protected serverInstances = new Map<jsonrpc.MessageConnection, JsonRpcServerInstance>();
+    protected startupCompleteMessage = START_UP_COMPLETE_MSG;
+
+    constructor() {
+        super();
+        this.toDispose.push(
+            Disposable.create(() => {
+                this.serverInstances.forEach(instance => this.disposeServerInstance(instance));
+            })
+        );
+    }
+
+    protected disposeServerInstance(instance: JsonRpcServerInstance): void {
+        this.serverInstances.delete(instance.clientConnection);
+        instance.server.shutdown();
+        instance.container.unbindAll();
+        instance.clientConnection.dispose();
+    }
+
+    protected createServerInstance(clientConnection: jsonrpc.MessageConnection): void {
+        const container = this.createContainer(this.createJsonRpcModule(clientConnection));
+        const server = container.get<GLSPServer>(GLSPServer);
+        const instance = { container, clientConnection, server };
+        this.serverInstances.set(clientConnection, instance);
+        this.configureClientConnection(instance);
+    }
+
+    protected createJsonRpcModule(clientConnection: jsonrpc.MessageConnection): ContainerModule {
+        return new ContainerModule(bind => {
+            bind(GLSPClientProxy).toDynamicValue(ctx => {
+                const proxy = ctx.container.resolve(JsonrpcClientProxy);
+                proxy.initialize(clientConnection);
+                return proxy;
+            });
+        });
+    }
+
+    protected configureClientConnection(serverInstance: JsonRpcServerInstance): void {
+        configureClientConnection(serverInstance.clientConnection, serverInstance.server);
+
+        serverInstance.clientConnection.onNotification(JsonrpcGLSPClient.ShutdownNotification, () =>
+            this.disposeServerInstance(serverInstance)
+        );
+
+        this.logger.info('Starting GLSP server connection');
+    }
+
+    protected createClientProxy(serverInstance: JsonRpcServerInstance): GLSPClientProxy {
+        const proxy = serverInstance.container.resolve(JsonrpcClientProxy);
+        proxy.initialize(serverInstance.clientConnection);
+        return proxy;
+    }
+}

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

@@ -13,7 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DisposeClientSessionParameters, InitializeClientSessionParameters, InitializeParameters } from '@eclipse-glsp/protocol';
+import {
+    DisposeClientSessionParameters,
+    GLSPClientProxy,
+    GLSPServerListener,
+    InitializeClientSessionParameters,
+    InitializeParameters
+} from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import * as sinon from 'sinon';
@@ -21,9 +27,7 @@ import { GlobalActionProvider } from '../actions/global-action-provider';
 import { ClientSessionManager } from '../session/client-session-manager';
 import * as mock from '../test/mock-util';
 import { Logger } from '../utils/logger';
-import { GLSPClientProxy, JsonRpcGLSPClientProxy } from './glsp-client-proxy';
 import { DefaultGLSPServer } from './glsp-server';
-import { GLSPServerListener } from './glsp-server-listener';
 import assert = require('assert');
 
 describe('test DefaultGLSPServer', () => {
@@ -48,7 +52,6 @@ describe('test DefaultGLSPServer', () => {
         new ContainerModule(bind => {
             bind(Logger).toConstantValue(new mock.StubLogger());
             bind(GLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
-            bind(JsonRpcGLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
             bind(ClientSessionManager).toConstantValue(sessionManager);
             bind(GlobalActionProvider).toConstantValue({ clientActionKinds: new Map<string, string[]>(), serverActionKinds });
             bind(GLSPServerListener).toConstantValue(listener1);

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

@@ -18,134 +18,26 @@ import {
     Args,
     DisposeClientSessionParameters,
     distinctAdd,
+    GLSPClientProxy,
+    GLSPServer,
+    GLSPServerListener,
     InitializeClientSessionParameters,
     InitializeParameters,
     InitializeResult,
-    JsonrpcGLSPClient,
     MaybePromise,
     remove,
     ServerActions,
     ServerMessageAction
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional } from 'inversify';
-import * as jsonrpc from 'vscode-jsonrpc';
-import { MessageConnection } from 'vscode-jsonrpc';
 import { GlobalActionProvider } from '../actions/global-action-provider';
 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 { JsonRpcGLSPClientProxy } from './glsp-client-proxy';
-import { GLSPServerListener } from './glsp-server-listener';
-
-export const GLSPServer = Symbol('GLSPServer');
-
-/**
- * Interface for implementations of a server component using json-rpc for client-server communication.
- * Based on the specification of the Graphical Language Server Protocol:
- * https://github.com/eclipse-glsp/glsp/blob/master/PROTOCOL.md
- */
-export interface GLSPServer {
-    /**
-     *
-     * The `initialize` request has to be the first request from the client to the server. Until the server has responded
-     * with an {@link InitializeResult} no other request or notification can be handled and is expected to throw an
-     * error. A client is uniquely identified by an `applicationId` and has to specify on which `protocolVersion` it is
-     * based on. In addition, custom arguments can be provided in the `args` map to allow for custom initialization
-     * behavior on the server.
-     *
-     * After successfully initialization all {@link GLSPServerListener}s are notified via the
-     * {@link GLSPServerListener.serverInitialized} method.
-     *
-     * @param params the {@link InitializeParameters}.
-     * @returns A promise of the {@link InitializeResult} .
-     *
-     * @throws {@link Error} Subsequent initialize requests return the {@link InitializeResult} of the initial request
-     * if the given application id and protocol version are matching, otherwise the promise rejects with an error.
-     *
-     */
-    initialize(params: InitializeParameters): Promise<InitializeResult>;
-
-    /**
-     * The `initializeClientSession` request is sent to the server whenever a new graphical representation (diagram) is
-     * created. Each individual diagram on the client side counts as one session and has to provide a unique
-     * `clientSessionId` and its `diagramType`. In addition, custom arguments can be provided in the `args` map to allow
-     * for custom initialization behavior on the server. Subsequent `initializeClientSession` requests for the same
-     * client id and diagram type are expected to resolve successfully but don't have an actual effect because the
-     * corresponding client session is  already initialized.
-     *
-     * @param params the {@link InitializeClientSessionParameters}.
-     * @returns A promise that completes when the initialization was successful.
-     */
-    initializeClientSession(params: InitializeClientSessionParameters): Promise<void>;
-
-    /**
-     * The 'DisposeClientSession' request is sent to the server when a graphical representation (diagram) is no longer
-     * needed, e.g. the tab containing the diagram widget has been closed. The session is identified by its unique
-     * `clientSessionId`. In addition, custom arguments can be provided in the `args` map to allow for custom dispose
-     * behavior on the server.
-     *
-     * @param params the {@link DisposeClientSessionParameters}.
-     * @returns A `void` promise that completes if the disposal was successful.
-     *
-     */
-    disposeClientSession(params: DisposeClientSessionParameters): Promise<void>;
-
-    /**
-     * A `process` notification is sent from the client to server when the server should handle i.e. process a specific
-     * {@link ActionMessage}. Any communication that is performed between initialization and shutdown is handled by
-     * sending action messages, either from the client to the server or from the server to the client. This is the core
-     * part of the Graphical Language Server Protocol.
-     *
-     * @param message The {@link ActionMessage} that should be processed.
-     */
-    process(message: ActionMessage): void;
-
-    /**
-     * The `shutdown` notification is sent from the client to the server if the client disconnects from the server (e.g.
-     * the client application has been closed).
-     * This gives the server a chance to clean up and dispose any resources dedicated to the client and its sessions.
-     * All {@link GLSPServerListener}s are notified via the {@link GLSPServerListener.serverShutDown} method.
-     * Afterwards the server instance is considered to be disposed and can no longer be used for handling requests.
-     *
-     */
-    shutdown(): void;
-
-    /**
-     * Register a new {@link GLSPServerListener}.
-     *
-     * @param listener The listener that should be registered.
-     * @returns `true` if the listener was registered successfully, `false` otherwise (e.g. listener is already
-     *         registered).
-     */
-    addListener(listener: GLSPServerListener): boolean;
-
-    /**
-     * Unregister a {@link GLSPServerListener}.
-     *
-     * @param listener The listener that should be removed
-     * @returns 'true' if the listener was unregistered successfully, `false` otherwise (e.g. listener is was not
-     *         registered in the first place).
-     */
-    removeListener(listener: GLSPServerListener): boolean;
-
-    /**
-     * get a {@link ClientSession}.
-     *
-     * @param sessionId The id of the session to get
-     * @returns The either the ClientSession or undefined, if no ClientSession was found for the given id.
-     */
-    getClientSession(sessionId: string): ClientSession | undefined;
-}
-
-export const JsonRpcGLSPServer = Symbol('JsonRpcGLSPServer');
-
-export interface JsonRpcGLSPServer extends GLSPServer {
-    connect(connection: jsonrpc.MessageConnection): void;
-}
 
 @injectable()
-export class DefaultGLSPServer implements JsonRpcGLSPServer {
+export class DefaultGLSPServer implements GLSPServer {
     public static readonly PROTOCOL_VERSION = '1.0.0';
 
     @inject(Logger)
@@ -157,8 +49,9 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
     @inject(GlobalActionProvider)
     protected actionProvider: GlobalActionProvider;
 
-    @inject(JsonRpcGLSPClientProxy)
-    protected glspClient: JsonRpcGLSPClientProxy;
+    @inject(GLSPClientProxy)
+    @optional()
+    protected glspClientProxy?: GLSPClientProxy;
 
     protected initializeResult?: InitializeResult;
 
@@ -172,18 +65,6 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
         serverListeners.forEach(listener => this.addListener(listener));
     }
 
-    protected setupJsonRpc(connection: MessageConnection): void {
-        connection.onRequest(JsonrpcGLSPClient.InitializeRequest.method, (params: InitializeParameters) => this.initialize(params));
-        connection.onRequest(JsonrpcGLSPClient.InitializeClientSessionRequest, (params: InitializeClientSessionParameters) =>
-            this.initializeClientSession(params)
-        );
-        connection.onRequest(JsonrpcGLSPClient.DisposeClientSessionRequest, (params: DisposeClientSessionParameters) =>
-            this.disposeClientSession(params)
-        );
-        connection.onNotification(JsonrpcGLSPClient.ActionMessageNotification, message => this.process(message));
-        connection.onNotification(JsonrpcGLSPClient.ShutdownNotification, () => this.shutdown());
-    }
-
     protected validateProtocolVersion(params: InitializeParameters): void {
         if (params.protocolVersion !== DefaultGLSPServer.PROTOCOL_VERSION) {
             throw new Error(
@@ -237,6 +118,7 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
         this.validateServerInitialized();
 
         const session = this.sessionManager.getOrCreateClientSession(params);
+
         this.clientSessions.set(params.clientSessionId, session);
         return this.handleInitializeClientSessionArgs(params.args);
     }
@@ -281,7 +163,15 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
             errorMsg = reason.message;
         }
         const errorAction = ServerMessageAction.create(errorMsg, { severity: 'ERROR', details });
-        this.glspClient.process({ clientId: message.clientId, action: errorAction });
+        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");
     }
 
     getClientSession(sessionId: string): ClientSession | undefined {
@@ -295,11 +185,6 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
         this.initializeResult = undefined;
     }
 
-    public connect(connection: jsonrpc.MessageConnection): void {
-        this.setupJsonRpc(connection);
-        this.glspClient.connect(connection);
-    }
-
     protected isInitialized(): boolean {
         return this.initializeResult !== undefined;
     }

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

@@ -13,11 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import { ActionDispatcher } from '../actions/action-dispatcher';
 import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import * as mock from '../test/mock-util';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { Logger } from '../utils/logger';

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

@@ -13,12 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { InitializeClientSessionParameters } from '@eclipse-glsp/protocol';
+import { GLSPClientProxy, InitializeClientSessionParameters } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable } from 'inversify';
 import { ActionDispatcher } from '../actions/action-dispatcher';
 import { createClientSessionModule } from '../di/client-session-module';
 import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { ClientSession, DefaultClientSession } from './client-session';
 import { ClientSessionInitializer } from './client-session-initializer';

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

@@ -13,10 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { InitializeClientSessionParameters, remove } from '@eclipse-glsp/protocol';
+import { GLSPServer, GLSPServerListener, InitializeClientSessionParameters, remove } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { GLSPServer } from '../protocol/glsp-server';
-import { GLSPServerListener } from '../protocol/glsp-server-listener';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { ClientSession } from './client-session';
 import { ClientSessionFactory } from './client-session-factory';

package/src/common/test/mock-util.ts

@@ -23,6 +23,9 @@ import {
     Args,
     CreateNodeOperation,
     EdgeTypeHint,
+    GLSPClientProxy,
+    GLSPServer,
+    GLSPServerListener,
     InitializeClientSessionParameters,
     MaybeArray,
     MaybePromise,
@@ -41,15 +44,12 @@ import { DiagramConfiguration, ServerLayoutKind } from '../diagram/diagram-confi
 import { ContextEditValidator } from '../features/directediting/context-edit-validator';
 import { LabelEditValidator } from '../features/directediting/label-edit-validator';
 import { GModelCreateEdgeOperationHandler, GModelCreateNodeOperationHandler } from '../gmodel/index';
-import { JsonRpcGLSPClientProxy } from '../protocol/glsp-client-proxy';
-import { GLSPServer } from '../protocol/glsp-server';
-import { GLSPServerListener } from '../protocol/glsp-server-listener';
 import { ClientSession } from '../session/client-session';
 import { ClientSessionFactory } from '../session/client-session-factory';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { ClientSessionListener } from '../session/client-session-listener';
 import { ClientSessionManager } from '../session/client-session-manager';
-import { Logger, LogLevel } from '../utils/logger';
+import { LogLevel, Logger } from '../utils/logger';
 
 export async function delay(ms: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -194,7 +194,7 @@ export class StubClientSessionListener implements ClientSessionListener {
     sessionDisposed(clientSession: ClientSession): void {}
 }
 
-export class StubGLSPClientProxy implements JsonRpcGLSPClientProxy {
+export class StubGLSPClientProxy implements GLSPClientProxy {
     connect(connection: MessageConnection): void {}
 
     process(message: ActionMessage<Action>): void {}

package/src/common/utils/args-util.ts

@@ -48,7 +48,7 @@ export namespace ArgsUtil {
         }
 
         return {
-            [KEY_RADIUS_TOP_RIGHT]: topLeft,
+            [KEY_RADIUS_TOP_LEFT]: topLeft,
             [KEY_RADIUS_BOTTOM_LEFT]: bottomLeft,
             [KEY_RADIUS_BOTTOM_RIGHT]: bottomRight,
             [KEY_RADIUS_TOP_RIGHT]: topRight

package/src/{browser/di → common/utils}/console-logger.ts

@@ -14,9 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+import { BindingContext } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { Logger, LogLevel } from '../../common/index';
+import { LogLevel, Logger, LoggerConfigOptions, LoggerFactory, NullLogger, getRequestParentName } from './logger';
 
+/**
+ *  Simple logger implementation that forwards logging calls to the `console` and
+ *  can be used in both the browser and node context.
+ */
 @injectable()
 export class ConsoleLogger extends Logger {
     constructor(public logLevel: LogLevel = LogLevel.none, public caller?: string) {
@@ -69,3 +74,16 @@ export class ConsoleLogger extends Logger {
         return JSON.stringify(param, undefined, 4);
     }
 }
+
+export function configureConsoleLogger<T extends LoggerConfigOptions>(context: BindingContext, options: T): void {
+    if (!options.consoleLog) {
+        context.bind(Logger).to(NullLogger).inSingletonScope();
+    } else {
+        context.bind(Logger).toDynamicValue(ctx => new ConsoleLogger(options.logLevel, getRequestParentName(ctx)));
+    }
+    context.bind(LoggerFactory).toFactory(dynamicContext => (caller: string) => {
+        const logger = dynamicContext.container.get(Logger);
+        logger.caller = caller;
+        return logger;
+    });
+}

package/src/common/utils/logger.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
+import { injectable, interfaces } from 'inversify';
 
 @injectable()
 export abstract class Logger {
@@ -70,3 +70,19 @@ export function asLogLevel(level: string | number): LogLevel | undefined {
     }
     return undefined;
 }
+
+export interface LoggerConfigOptions {
+    consoleLog?: boolean;
+    logLevel?: LogLevel;
+}
+
+export function getRequestParentName(context: interfaces.Context): string | undefined {
+    if (context.currentRequest.parentRequest) {
+        const bindings = context.currentRequest.parentRequest.bindings;
+        if (bindings.length > 0) {
+            const binding = bindings[0] as interfaces.Binding<{ name?: string }>;
+            return binding.implementationType?.name;
+        }
+    }
+    return undefined;
+}