refactor(kernel): remove unused methods on EventDispatcher

packages/contracts/source/contracts/kernel/events.ts

@@ -1,5 +1,5 @@
 export interface EventListener<T = unknown> {
-	handle(payload: { name: string; data: T }): void;
+	handle(payload: { name: string; data: T }): Promise<void>;
 }
 
 export interface EventDispatcher<T = unknown> {
@@ -21,13 +21,5 @@ export interface EventDispatcher<T = unknown> {
 
 	dispatch<T = unknown>(event: string, data?: T): Promise<void>;
 
-	dispatchSeq<T = unknown>(event: string, data?: T): Promise<void>;
-
-	dispatchSync<T = unknown>(event: string, data?: T): void;
-
 	dispatchMany<T = unknown>(events: Array<[string, T]>): Promise<void>;
-
-	dispatchManySeq<T = unknown>(events: Array<[string, T]>): Promise<void>;
-
-	dispatchManySync<T = unknown>(events: Array<[string, T]>): void;
 }

packages/evm-api-worker/source/worker.ts

@@ -29,8 +29,8 @@ export class Worker implements Contracts.Evm.Worker {
 		this.ipcSubprocess.registerEventHandler(event, callback);
 	}
 
-	public handle(payload: { name: string; data: unknown }): void {
-		void this.setPeerCount(this.p2pRepository.getPeers().length);
+	public async handle(payload: { name: string; data: unknown }): Promise<void> {
+		await this.setPeerCount(this.p2pRepository.getPeers().length);
 	}
 
 	public async boot(flags: Contracts.Evm.WorkerFlags): Promise<void> {

packages/kernel/source/services/events/drivers/memory.test.ts

@@ -6,8 +6,8 @@ import { MemoryEventDispatcher } from "./memory";
 class DummyClass implements Contracts.Kernel.EventListener {
 	public constructor(private readonly method?) {}
 
-	public handle(): void {
-		this.method();
+	public async handle({ name, data }: { name: string; data: any }): Promise<void> {
+		this.method(name, data);
 	}
 }
 
@@ -57,7 +57,7 @@ describe<{
 		context.emitter.listen("*", context.dummyListener);
 
 		await context.emitter.dispatch("firstEvent");
-		await context.emitter.dispatchSeq("firstEvent");
+		await context.emitter.dispatch("firstEvent");
 
 		context.dummyCallerSpy.calledTimes(2);
 	});
@@ -84,29 +84,23 @@ describe<{
 	it("should listen once", async (context) => {
 		context.emitter.listenOnce("firstEvent", context.dummyListener);
 
-		context.emitter.dispatchSync("firstEvent");
-		context.emitter.dispatchSync("firstEvent");
-		context.emitter.dispatchSync("firstEvent");
-
-		context.dummyCallerSpy.calledOnce();
-
-		context.emitter.dispatchSync("firstEvent");
-		context.emitter.dispatchSync("firstEvent");
-		context.emitter.dispatchSync("firstEvent");
+		await context.emitter.dispatch("firstEvent");
+		await context.emitter.dispatch("firstEvent");
+		await context.emitter.dispatch("firstEvent");
 
 		context.dummyCallerSpy.calledOnce();
 	});
 
-	it("should remove an event listener", (context) => {
+	it("should remove an event listener", async (context) => {
 		context.emitter.listen("firstEvent", context.dummyListener);
 
-		context.emitter.dispatchSync("firstEvent");
+		await context.emitter.dispatch("firstEvent");
 
 		context.dummyCallerSpy.calledOnce();
 
 		context.emitter.forget("firstEvent", context.dummyListener);
 
-		context.emitter.dispatchSync("firstEvent");
+		await context.emitter.dispatch("firstEvent");
 
 		context.dummyCallerSpy.calledOnce();
 	});
@@ -134,63 +128,19 @@ describe<{
 	it("should not execute an event listener without await", async (context) => {
 		context.emitter.listen("firstEvent", context.dummyListener);
 
-		context.emitter.dispatch("firstEvent");
+		void context.emitter.dispatch("firstEvent");
 
 		context.dummyCallerSpy.neverCalled();
 	});
 
 	it("should execute a wildcard listener with await", async (context) => {
 		context.emitter.listen("*", context.dummyListener);
 
-		await context.emitter.dispatchSeq("firstEvent");
-
-		context.dummyCallerSpy.calledOnce();
-	});
-
-	it("should not execute an event listener without await (async behaviour)", async (context) => {
-		context.emitter.listen("firstEvent", context.dummyListener);
-
-		context.emitter.dispatchSeq("firstEvent");
-
-		context.dummyCallerSpy.neverCalled();
-	});
-
-	it("should emit all events in sequence", async (context) => {
-		context.emitter.listen("firstEvent", context.dummyListener);
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-
-		await context.emitter.dispatchSeq("firstEvent");
-
-		context.dummyCallerSpy.calledTimes(3);
-	});
-
-	it("should execute an event listener without await", (context) => {
-		context.emitter.listen("firstEvent", context.dummyListener);
-
-		context.emitter.dispatchSync("firstEvent");
-
-		context.dummyCallerSpy.calledOnce();
-	});
-
-	it("should execute a wildcard listener without await", (context) => {
-		context.emitter.listen("*", context.dummyListener);
-
-		context.emitter.dispatchSync("firstEvent");
+		await context.emitter.dispatch("firstEvent");
 
 		context.dummyCallerSpy.calledOnce();
 	});
 
-	it("should emit all events in sequence", (context) => {
-		context.emitter.listen("firstEvent", context.dummyListener);
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-
-		context.emitter.dispatchSync("firstEvent");
-
-		context.dummyCallerSpy.calledTimes(3);
-	});
-
 	it("should emit all events", async (context) => {
 		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
 		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
@@ -206,40 +156,8 @@ describe<{
 		]);
 
 		context.dummyCallerSpy.calledTimes(6);
-	});
-
-	it("should emit all events", async (context) => {
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-
-		context.emitter.listen("secondEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("secondEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("secondEvent", new DummyClass(context.dummyCaller));
-
-		await context.emitter.dispatchManySeq([
-			["firstEvent", undefined],
-			["secondEvent", undefined],
-		]);
-
-		context.dummyCallerSpy.calledTimes(6);
-	});
-
-	it("should emit all events", async (context) => {
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("firstEvent", new DummyClass(context.dummyCaller));
-
-		context.emitter.listen("secondEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("secondEvent", new DummyClass(context.dummyCaller));
-		context.emitter.listen("secondEvent", new DummyClass(context.dummyCaller));
-
-		context.emitter.dispatchManySync([
-			["firstEvent", undefined],
-			["secondEvent", undefined],
-		]);
-
-		context.dummyCallerSpy.calledTimes(6);
+		context.dummyCallerSpy.calledWith("firstEvent");
+		context.dummyCallerSpy.calledWith("secondEvent");
 	});
 
 	it("should clear all listeners", async (context) => {

packages/kernel/source/services/events/drivers/memory.ts

@@ -98,36 +98,10 @@ export class MemoryEventDispatcher implements Contracts.Kernel.EventDispatcher {
 		await Promise.all(resolvers);
 	}
 
-	public async dispatchSeq<T = unknown>(event: string, data?: T): Promise<void> {
-		await Promise.resolve();
-
-		for (const listener of this.#getListenersByPattern(event)) {
-			listener.handle({ data, name: event });
-		}
-	}
-
-	public dispatchSync<T = unknown>(event: string, data?: T): void {
-		for (const listener of this.#getListenersByPattern(event)) {
-			listener.handle({ data, name: event });
-		}
-	}
-
 	public async dispatchMany<T = unknown>(events: Array<[string, T]>): Promise<void> {
 		await Promise.all(Object.values(events).map((value: [string, T]) => this.dispatch(value[0], value[1])));
 	}
 
-	public async dispatchManySeq<T = unknown>(events: Array<[string, T]>): Promise<void> {
-		for (const value of Object.values(events)) {
-			await this.dispatchSeq(value[0], value[1]);
-		}
-	}
-
-	public dispatchManySync<T = unknown>(events: Array<[string, T]>): void {
-		for (const value of Object.values(events)) {
-			this.dispatchSync(value[0], value[1]);
-		}
-	}
-
 	#getListenersByEvent(name: string): Set<Contracts.Kernel.EventListener> {
 		if (!this.#listeners.has(name)) {
 			this.#listeners.set(name, new Set<Contracts.Kernel.EventListener>());
@@ -141,7 +115,6 @@ export class MemoryEventDispatcher implements Contracts.Kernel.EventDispatcher {
 	}
 
 	#getListenersByPattern(event: string): Contracts.Kernel.EventListener[] {
-		// @ts-ignore
 		const matches: string[] = mm([...this.#listeners.keys()], event);
 
 		let eventListeners: Contracts.Kernel.EventListener[] = [];

packages/kernel/source/services/events/drivers/null.test.ts

@@ -73,18 +73,6 @@ describe("NullEventDispatcher", ({ assert, it }) => {
 		assert.is(result, undefined);
 	});
 
-	it("should return undefined", async () => {
-		const driver = new NullEventDispatcher();
-		const result = await driver.dispatchSeq("event", "data");
-		assert.is(result, undefined);
-	});
-
-	it("should return undefined", () => {
-		const driver = new NullEventDispatcher();
-		const result = driver.dispatchSync("event", "data");
-		assert.is(result, undefined);
-	});
-
 	it("should return undefined", async () => {
 		const driver = new NullEventDispatcher();
 		const result = await driver.dispatchMany([
@@ -93,13 +81,4 @@ describe("NullEventDispatcher", ({ assert, it }) => {
 		]);
 		assert.is(result, undefined);
 	});
-
-	it("should return undefined", () => {
-		const driver = new NullEventDispatcher();
-		const result = driver.dispatchManySync([
-			["event1", "data1"],
-			["event2", "data2"],
-		]);
-		assert.is(result, undefined);
-	});
 });

packages/kernel/source/services/events/drivers/null.ts

@@ -45,23 +45,7 @@ export class NullEventDispatcher implements Contracts.Kernel.EventDispatcher {
 		//
 	}
 
-	public async dispatchSeq<T = unknown>(event: string, data?: T): Promise<void> {
-		//
-	}
-
-	public dispatchSync<T = unknown>(event: string, data?: T): void {
-		//
-	}
-
 	public async dispatchMany<T = unknown>(events: Array<[string, T]>): Promise<void> {
 		//
 	}
-
-	public async dispatchManySeq<T = unknown>(events: Array<[string, T]>): Promise<void> {
-		//
-	}
-
-	public dispatchManySync<T = unknown>(events: Array<[string, T]>): void {
-		//
-	}
 }