@eclipse-glsp/server 1.1.0-next.44bd1e0.43 → 1.1.0-next.d47240f.50

package/src/common/command/command.spec.ts

@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { expect } from 'chai';
 import * as sinon from 'sinon';
-import { StubCommand } from '../test/mock-util';
+import { expectToThrowAsync, StubCommand } from '../test/mock-util';
 import { CompoundCommand } from './command';
 
 describe('CompoundCommand', () => {
@@ -32,18 +32,18 @@ describe('CompoundCommand', () => {
     });
 
     describe('execute', () => {
-        it('Should execute the subcommands in order', () => {
-            compoundCommand.execute();
+        it('Should execute the subcommands in order', async () => {
+            await compoundCommand.execute();
             expect(command1.execute.calledOnce).to.be.true;
             expect(command2.execute.calledOnce).to.be.true;
             expect(command3.execute.calledOnce).to.be.true;
             expect(command1.execute.calledBefore(command2.execute)).to.be.true;
             expect(command2.execute.calledBefore(command3.execute)).to.be.true;
         });
-        it('Should undo partially executed subcommands in  case of an error', () => {
+        it('Should undo partially executed subcommands in  case of an error', async () => {
             command3.execute.throwsException();
 
-            expect(() => compoundCommand.execute()).to.throw();
+            await expectToThrowAsync(() => compoundCommand.execute());
 
             expect(command1.execute.calledOnce).to.be.true;
             expect(command2.execute.calledOnce).to.be.true;
@@ -54,8 +54,8 @@ describe('CompoundCommand', () => {
     });
 
     describe('undo', () => {
-        it('Should undo the subcommands in reverse order', () => {
-            compoundCommand.undo();
+        it('Should undo the subcommands in reverse order', async () => {
+            await compoundCommand.undo();
             expect(command1.undo.calledOnce).to.be.true;
             expect(command2.undo.calledOnce).to.be.true;
             expect(command3.undo.calledOnce).to.be.true;
@@ -63,10 +63,9 @@ describe('CompoundCommand', () => {
             expect(command2.undo.calledAfter(command3.undo)).to.be.true;
         });
 
-        it('Should redo partially undone subcommands in  case of an error', () => {
+        it('Should redo partially undone subcommands in  case of an error', async () => {
             command1.undo.throwsException();
-
-            expect(() => compoundCommand.undo()).to.throw();
+            await expectToThrowAsync(() => compoundCommand.undo());
 
             expect(command1.undo.calledOnce).to.be.true;
             expect(command2.undo.calledOnce).to.be.true;

package/src/common/command/command.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { flatPush, MaybeArray } from '@eclipse-glsp/protocol';
+import { flatPush, MaybeArray, MaybePromise } from '@eclipse-glsp/protocol';
 
 /**
  * A command implements a specific modification of the source model, which can be applied by invoking `execute()`.
@@ -30,19 +30,19 @@ export interface Command {
     /**
      * Performs the command activity required for the effect (e.g. source model change).
      */
-    execute(): void;
+    execute(): MaybePromise<void>;
 
     /**
      * Performs the command activity required to `undo` the effects of a preceding `execute` (or `redo`).
      * The effect, if any, of calling `undo` before `execute` or `redo` have been called, is undefined.
      */
-    undo(): void;
+    undo(): MaybePromise<void>;
 
     /**
      * Performs the command activity required to `redo` the effect after undoing the effect.
      * The effect, if any, of calling `redo` before `undo` is called is undefined.
      */
-    redo(): void;
+    redo(): MaybePromise<void>;
 
     /**
      * Returns whether the command can be undone.
@@ -71,18 +71,18 @@ export class CompoundCommand implements Command {
         flatPush(this.commands, commands);
     }
 
-    execute(): void {
+    async execute(): Promise<void> {
         const alreadyExecuted: Command[] = [];
 
         try {
-            this.commands.forEach(command => {
-                command.execute();
+            for (const command of this.commands) {
+                await command.execute();
                 alreadyExecuted.unshift(command);
-            });
+            }
         } catch (err) {
             for (const command of alreadyExecuted) {
                 if (Command.canUndo(command)) {
-                    command.undo();
+                    await command.undo();
                 } else {
                     break;
                 }
@@ -91,29 +91,33 @@ export class CompoundCommand implements Command {
         }
     }
 
-    undo(): void {
+    async undo(): Promise<void> {
         const alreadyUndone: Command[] = [];
         try {
-            [...this.commands].reverse().forEach(command => {
-                command.undo();
+            for (const command of [...this.commands].reverse()) {
+                await command.undo();
                 alreadyUndone.unshift(command);
-            });
+            }
         } catch (err) {
-            alreadyUndone.forEach(command => command.redo());
+            for (const command of alreadyUndone) {
+                await command.redo();
+            }
             throw err;
         }
     }
 
-    redo(): void {
+    async redo(): Promise<void> {
         const alreadyRedone: Command[] = [];
 
         try {
-            this.commands.forEach(command => {
-                command.redo();
+            for (const command of this.commands) {
+                await command.redo();
                 alreadyRedone.unshift(command);
-            });
+            }
         } catch (err) {
-            alreadyRedone.forEach(command => command.undo());
+            for (const command of alreadyRedone) {
+                await command.undo();
+            }
             throw err;
         }
     }

package/src/common/command/recording-command.spec.ts

@@ -39,36 +39,36 @@ describe('RecordingCommand', () => {
         beforeState = JSON.parse(JSON.stringify(jsonObject));
     });
 
-    it('should be undoable after execution', () => {
+    it('should be undoable after execution', async () => {
         // eslint-disable-next-line @typescript-eslint/no-empty-function
         const command = new RecordingCommand(jsonObject, () => {});
         expect(command.canUndo()).to.be.false;
-        command.execute();
+        await command.execute();
         expect(command.canUndo()).to.be.true;
     });
 
-    it('should restore the pre execution state when undo is called', () => {
+    it('should restore the pre execution state when undo is called', async () => {
         const command = new RecordingCommand(jsonObject, () => {
             jsonObject.string = 'bar';
             jsonObject.flag = false;
             jsonObject.maybe = { hello: 'world' };
         });
-        command.execute();
+        await command.execute();
         expect(jsonObject).to.not.be.deep.equals(beforeState);
-        command.undo();
+        await command.undo();
         expect(jsonObject).to.be.deep.equals(beforeState);
     });
 
-    it('should restore the post execution state when redo is called', () => {
+    it('should restore the post execution state when redo is called', async () => {
         const command = new RecordingCommand(jsonObject, () => {
             jsonObject.string = 'bar';
             jsonObject.flag = false;
             jsonObject.maybe = { hello: 'world' };
         });
-        command.execute();
+        await command.execute();
         const afterState = JSON.parse(JSON.stringify(jsonObject));
         jsonObject = JSON.parse(JSON.stringify(afterState));
-        command.redo();
+        await command.redo();
         expect(jsonObject).to.be.deep.equals(afterState);
     });
 });

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

@@ -15,7 +15,7 @@
  ********************************************************************************/
 
 import { GModelRootSchema } from '@eclipse-glsp/graph';
-import { AnyObject } from '@eclipse-glsp/protocol';
+import { AnyObject, MaybePromise } from '@eclipse-glsp/protocol';
 import * as jsonPatch from 'fast-json-patch';
 import { GModelSerializer } from '../features/model/gmodel-serializer';
 import { ModelState } from '../features/model/model-state';
@@ -28,10 +28,10 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
     protected undoPatch?: jsonPatch.Operation[];
     protected redoPatch?: jsonPatch.Operation[];
 
-    execute(): void {
-        const beforeState = this.deepClone(this.getJsonObject());
-        this.doExecute();
-        const afterState = this.getJsonObject();
+    async execute(): Promise<void> {
+        const beforeState = this.deepClone(await this.getJsonObject());
+        await this.doExecute();
+        const afterState = await this.getJsonObject();
         this.undoPatch = jsonPatch.compare(afterState, beforeState);
         this.redoPatch = jsonPatch.compare(beforeState, afterState);
     }
@@ -41,14 +41,14 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
      * right after {@link AbstractRecordingCommand.doExecute} to derive the undo & redo patches.
      * @returns The current state of the JSON object
      */
-    protected abstract getJsonObject(): JsonObject;
+    protected abstract getJsonObject(): MaybePromise<JsonObject>;
 
     /**
      * The actual execution i.e. series of changes applied to the JSOn object that should be captured.
      */
-    protected abstract doExecute(): void;
+    protected abstract doExecute(): MaybePromise<void>;
 
-    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): void {
+    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): MaybePromise<void> {
         jsonPatch.applyPatch(object, patch, false, true);
     }
 
@@ -62,15 +62,15 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
         return jsonPatch.deepClone(object);
     }
 
-    undo(): void {
+    async undo(): Promise<void> {
         if (this.undoPatch) {
-            this.applyPatch(this.getJsonObject(), this.undoPatch);
+            return this.applyPatch(await this.getJsonObject(), this.undoPatch);
         }
     }
 
-    redo(): void {
+    async redo(): Promise<void> {
         if (this.redoPatch) {
-            this.applyPatch(this.getJsonObject(), this.redoPatch);
+            return this.applyPatch(await this.getJsonObject(), this.redoPatch);
         }
     }
 
@@ -84,11 +84,11 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
  * the the given `doExecute` function.
  */
 export class RecordingCommand<JsonObject extends AnyObject = AnyObject> extends AbstractRecordingCommand<JsonObject> {
-    constructor(protected jsonObject: JsonObject, protected doExecute: () => void) {
+    constructor(protected jsonObject: JsonObject, protected doExecute: () => MaybePromise<void>) {
         super();
     }
 
-    protected getJsonObject(): JsonObject {
+    protected getJsonObject(): MaybePromise<JsonObject> {
         return this.jsonObject;
     }
 }
@@ -98,20 +98,20 @@ export class RecordingCommand<JsonObject extends AnyObject = AnyObject> extends
  * to the `GModelRoot` ({@link ModelState.root}) during the given `doExecute` function
  */
 export class GModelRecordingCommand extends AbstractRecordingCommand<GModelRootSchema> {
-    constructor(protected modelState: ModelState, protected serializer: GModelSerializer, protected doExecute: () => void) {
+    constructor(protected modelState: ModelState, protected serializer: GModelSerializer, protected doExecute: () => MaybePromise<void>) {
         super();
     }
 
-    override execute(): void {
-        super.execute();
+    override async execute(): Promise<void> {
+        await super.execute();
         this.modelState.index.indexRoot(this.modelState.root);
     }
 
-    protected getJsonObject(): GModelRootSchema {
+    protected getJsonObject(): MaybePromise<GModelRootSchema> {
         return this.serializer.createSchema(this.modelState.root);
     }
 
-    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): void {
+    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): MaybePromise<void> {
         super.applyPatch(rootSchema, patch);
         const newRoot = this.serializer.createRoot(rootSchema);
         this.modelState.updateRoot(newRoot);

package/src/common/command/undo-redo-action-handler.ts

@@ -39,17 +39,17 @@ export class UndoRedoActionHandler implements ActionHandler {
         return [];
     }
 
-    protected undo(): MaybePromise<Action[]> {
+    protected async undo(): Promise<Action[]> {
         if (this.commandStack.canUndo()) {
-            this.commandStack.undo();
+            await this.commandStack.undo();
             return this.modelSubmissionHandler.submitModel('undo');
         }
         return [];
     }
 
-    protected redo(): MaybePromise<Action[]> {
+    protected async redo(): Promise<Action[]> {
         if (this.commandStack.canRedo()) {
-            this.commandStack.redo();
+            await this.commandStack.redo();
             return this.modelSubmissionHandler.submitModel('redo');
         }
         return [];

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/features/layout/computed-bounds-action-handler.ts

@@ -17,7 +17,7 @@ import { GModelRoot } from '@eclipse-glsp/graph';
 import { Action, ComputedBoundsAction, MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../../actions/action-handler';
-import { applyAlignment, applyBounds, applyRoute } from '../../utils/layout-util';
+import { applyAlignment, applyElementAndBounds, applyRoute } from '../../utils/layout-util';
 import { ModelState } from '../model/model-state';
 import { ModelSubmissionHandler } from '../model/model-submission-handler';
 
@@ -47,7 +47,7 @@ export class ComputedBoundsActionHandler implements ActionHandler {
 
     protected applyBounds(root: GModelRoot, action: ComputedBoundsAction): void {
         const index = this.modelState.index;
-        action.bounds.forEach(bounds => applyBounds(bounds, index));
+        action.bounds.forEach(bounds => applyElementAndBounds(bounds, index));
         (action.alignments ?? []).forEach(alignment => applyAlignment(alignment, index));
         (action.routes ?? []).forEach(route => applyRoute(route, index));
     }

package/src/common/index.ts

@@ -23,6 +23,8 @@ export * from './actions/client-action-handler';
 export * from './actions/global-action-provider';
 export * from './command/command';
 export * from './command/command-stack';
+export * from './command/recording-command';
+export * from './command/undo-redo-action-handler';
 export * from './di/binding-target';
 export * from './di/client-session-module';
 export * from './di/diagram-module';
@@ -65,7 +67,6 @@ export * from './features/popup/popup-model-factory';
 export * from './features/popup/request-popup-model-action-handler';
 export * from './features/validation/model-validator';
 export * from './features/validation/request-markers-handler';
-export * from './gmodel/cut-operation-handler';
 export * from './gmodel/index';
 export * from './launch/glsp-server-launcher';
 export * from './operations/compound-operation-handler';
@@ -73,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';
@@ -83,7 +82,9 @@ 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';
 export * from './utils/promise-queue';
 export * from './utils/registry';

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

@@ -13,20 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { MaybePromise } from '@eclipse-glsp/protocol';
+import { Disposable, DisposableCollection, MaybePromise } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable, optional } from 'inversify';
 import { ServerModule } from '../di/server-module';
 import { InjectionContainer } from '../di/service-identifiers';
 import { Logger } from '../utils/logger';
 
-export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed';
-
 @injectable()
-export abstract class GLSPServerLauncher<T = undefined> {
+export abstract class GLSPServerLauncher<T> implements Disposable {
     @inject(Logger) protected logger: Logger;
 
     protected _modules: ContainerModule[] = [];
     protected running: boolean;
+    protected toDispose = new DisposableCollection();
 
     @inject(InjectionContainer) @optional() protected parentContainer?: Container;
 
@@ -34,13 +33,13 @@ export abstract class GLSPServerLauncher<T = undefined> {
         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;
     }
 
-    start(startParams?: T): MaybePromise<void> {
+    start(startParams: T): MaybePromise<void> {
         if (!this.running) {
             this.running = true;
             return this.run(startParams);
@@ -48,10 +47,11 @@ export abstract class GLSPServerLauncher<T = undefined> {
         this.logger.warn('Could not start launcher. Launcher is already running!');
     }
 
-    protected abstract run(startParams?: T): MaybePromise<void>;
+    protected abstract run(startParams: T): MaybePromise<void>;
 
     shutdown(): MaybePromise<void> {
         if (this.running) {
+            this.logger.info('Shutdown GLSPServerLauncher');
             const result = this.stop();
             this.running = false;
             return result;
@@ -59,7 +59,13 @@ export abstract class GLSPServerLauncher<T = undefined> {
         this.logger.warn('Could not stop launcher. Launcher is not running!');
     }
 
-    protected abstract stop(): MaybePromise<void>;
+    protected stop(): MaybePromise<void> {
+        this.dispose();
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
 
     get modules(): ContainerModule[] {
         if (!this._modules) {