@eclipse-glsp/server 1.1.0-RC07 → 1.1.0-RC09

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/server",
-  "version": "1.1.0-RC07",
+  "version": "1.1.0-RC09",
   "description": "A js server framework for Eclipse GLSP",
   "keywords": [
     "eclipse",
@@ -59,8 +59,8 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/graph": "1.1.0-RC07",
-    "@eclipse-glsp/protocol": "1.1.0-RC07",
+    "@eclipse-glsp/graph": "1.1.0-RC09",
+    "@eclipse-glsp/protocol": "1.1.0-RC09",
     "@types/uuid": "8.3.1",
     "commander": "^8.3.0",
     "fast-json-patch": "^3.1.0",
@@ -75,5 +75,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "074b8edd43a5120649136c779d854d63c7134f69"
+  "gitHead": "edffbe7d7a2b9e117d7f235b8d629dfde0c1ffe7"
 }

package/src/browser/di/app-module.ts

@@ -14,42 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { ContainerModule, interfaces } from 'inversify';
-import { InjectionContainer, Logger, LoggerFactory, LogLevel, ModuleContext, NullLogger } from '../../common/index';
-import { ConsoleLogger } from './console-logger';
+import { ContainerModule } from 'inversify';
+import { InjectionContainer, LogLevel, LoggerConfigOptions, configureConsoleLogger } from '../../common/';
 
-export interface LaunchOptions {
-    consoleLog?: boolean;
-    logLevel?: LogLevel;
-}
-export function createAppModule(options: LaunchOptions = {}): ContainerModule {
-    const resolvedOptions: LaunchOptions = { consoleLog: true, logLevel: LogLevel.info, ...options };
+export function createAppModule(options: LoggerConfigOptions = {}): ContainerModule {
+    const resolvedOptions: LoggerConfigOptions = { consoleLog: true, logLevel: LogLevel.info, ...options };
     return new ContainerModule((bind, unbind, isBound, rebind) => {
         bind(InjectionContainer).toDynamicValue(dynamicContext => dynamicContext.container);
         const context = { bind, unbind, isBound, rebind };
         configureConsoleLogger(context, resolvedOptions);
     });
 }
-
-export function configureConsoleLogger<T extends LaunchOptions>(context: ModuleContext, 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;
-    });
-}
-
-function getRequestParentName(context: interfaces.Context): string | undefined {
-    if (context.currentRequest.parentRequest) {
-        const bindings = context.currentRequest.parentRequest.bindings;
-        if (bindings.length > 0) {
-            return bindings[0].implementationType?.name;
-        }
-    }
-    return undefined;
-}

package/src/browser/index.ts

@@ -15,5 +15,4 @@
  ********************************************************************************/
 export * from '../common/index';
 export * from './di/app-module';
-export * from './di/console-logger';
 export * from './launch/worker-server-launcher';

package/src/browser/launch/worker-server-launcher.ts

@@ -14,9 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Container, injectable } from 'inversify';
+import { injectable } from 'inversify';
 import * as jsonrpc from 'vscode-jsonrpc/browser';
-import { GLSPServer, GLSPServerLauncher, JsonRpcGLSPServer, MaybePromise } from '../../common/index';
+import { MaybePromise } from '../../common/index';
+import { JsonRpcGLSPServerLauncher, JsonRpcServerInstance } from '../../common/launch/jsonrpc-server-launcher';
 export interface WorkerLaunchOptions {
     context?: Worker;
 }
@@ -24,22 +25,16 @@ export interface WorkerLaunchOptions {
 export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed.';
 
 @injectable()
-export class WorkerServerLauncher extends GLSPServerLauncher<WorkerLaunchOptions> {
+export class WorkerServerLauncher extends JsonRpcGLSPServerLauncher<WorkerLaunchOptions> {
     protected connection?: jsonrpc.MessageConnection;
 
     protected run(options: WorkerLaunchOptions): MaybePromise<void> {
         if (this.connection) {
             throw new Error('Error during launch. Server already has an active client connection');
         }
-        const container = this.createContainer();
         this.connection = this.createConnection(options);
-        const glspServer = container.get<JsonRpcGLSPServer>(JsonRpcGLSPServer);
-        glspServer.connect(this.connection);
-        this.connection.onDispose(() => this.disposeClientConnection(container, glspServer));
-
+        this.createServerInstance(this.connection);
         this.logger.info('GLSP server worker connection established');
-        this.connection.listen();
-        this.toDispose.push(this.connection);
         postMessage(START_UP_COMPLETE_MSG);
         return new Promise((resolve, rejects) => {
             this.connection?.onClose(() => resolve(undefined));
@@ -47,9 +42,8 @@ export class WorkerServerLauncher extends GLSPServerLauncher<WorkerLaunchOptions
         });
     }
 
-    protected disposeClientConnection(container: Container, glspServer: GLSPServer): void {
-        glspServer.shutdown();
-        container.unbindAll();
+    protected override disposeServerInstance(instance: JsonRpcServerInstance): void {
+        super.disposeServerInstance(instance);
         this.connection = undefined;
     }
 

package/src/common/actions/client-action-handler.ts

@@ -13,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ActionMessage } from '@eclipse-glsp/protocol';
+import { Action, ActionMessage, GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import { ClientActionKinds, ClientId } from '../di/service-identifiers';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 
 /**
  * The client action handler is responsible of handling action kinds that are intended for the

package/src/common/command/command-stack.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { MaybePromise } from '..';
 import { Logger } from '../utils/logger';
 import { Command } from './command';
 

package/src/common/di/client-session-module.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import { ClientId } from './service-identifiers';
 
 export function createClientSessionModule(clientId: string, glspClient: GLSPClientProxy): ContainerModule {

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

@@ -13,12 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { BindingContext } from '@eclipse-glsp/protocol';
 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.
+ * @deprecated Use `BindingContext` from `@eclipse-glsp/protocol` instead
  */
 export interface ModuleContext {
     bind: interfaces.Bind;
@@ -34,7 +36,7 @@ export interface ModuleContext {
 export abstract class GLSPModule extends ContainerModule {
     public static CLIENT_ACTIONS = 'ClientActions';
 
-    protected context: ModuleContext;
+    protected context: BindingContext;
 
     constructor() {
         super((bind, unbind, isBound, rebind) => {

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

@@ -13,9 +13,8 @@
  *
  * 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 { BindingContext, 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.
@@ -29,7 +28,7 @@ export abstract class AbstractMultiBinding<T> {
 
     constructor(readonly identifier: string | symbol) {}
 
-    abstract applyBindings(context: ModuleContext): void;
+    abstract applyBindings(context: BindingContext): void;
 
     add(newBinding: T): void {
         distinctAdd(this.bindings, newBinding);
@@ -71,7 +70,7 @@ export abstract class AbstractMultiBinding<T> {
  * @typeparam T the base type of {@link BindingTarget}.
  */
 export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
-    applyBindings(context: ModuleContext): void {
+    applyBindings(context: BindingContext): void {
         this.bindings.forEach(binding => applyBindingTarget(context, this.identifier, binding));
     }
 }
@@ -83,7 +82,7 @@ export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
  * * @typeparam T the type of the instances
  */
 export class InstanceMultiBinding<T> extends AbstractMultiBinding<T> {
-    applyBindings(context: ModuleContext): void {
+    applyBindings(context: BindingContext): void {
         context.bind(this.identifier).toConstantValue(this.bindings);
     }
 }

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

@@ -13,14 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPServer, GLSPServerListener } from '@eclipse-glsp/protocol';
 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 { DefaultGLSPServer } from '../protocol/glsp-server';
 import { ClientSessionFactory, DefaultClientSessionFactory } from '../session/client-session-factory';
 import { ClientSessionManager, DefaultClientSessionManager } from '../session/client-session-manager';
-import { applyBindingTarget, BindingTarget } from './binding-target';
+import { BindingTarget, applyBindingTarget } from './binding-target';
 import { DiagramModule } from './diagram-module';
 import { GLSPModule } from './glsp-module';
 import { MultiBinding } from './multi-binding';
@@ -74,7 +73,6 @@ export class ServerModule extends GLSPModule {
         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 =>
@@ -83,10 +81,9 @@ export class ServerModule extends GLSPModule {
 
         applyBindingTarget(context, GlobalActionProvider, this.bindGlobalActionProvider()).inSingletonScope();
 
-        applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
-
-        applyBindingTarget(context, GLSPClientProxy, this.bindGLSPClientProxy()).inSingletonScope();
-        applyBindingTarget(context, JsonRpcGLSPClientProxy, this.bindJsonRpcGLSPClientProxy());
+        if (!isBound(InjectionContainer)) {
+            applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
+        }
     }
 
     protected bindDiagramModules(): BindingTarget<Map<string, ContainerModule[]>> {
@@ -97,10 +94,6 @@ export class ServerModule extends GLSPModule {
         return DefaultGLSPServer;
     }
 
-    protected bindJsonRpcGLSPServer(): BindingTarget<JsonRpcGLSPServer> {
-        return { service: GLSPServer };
-    }
-
     protected bindClientSessionFactory(): BindingTarget<ClientSessionFactory> {
         return DefaultClientSessionFactory;
     }
@@ -117,14 +110,6 @@ export class ServerModule extends GLSPModule {
         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/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;
     }