fix(lint): enable @typescript-eslint/no-misused-promises: error (#1250)

oXtxNt9U · web-flow · commit a62cb2cd5cd5 · 2026-03-17T11:39:09.000+01:00
* enable no-misused-promise

* fix @mainsail/test-runner

* fix @mainsail/p2p

* fix @mainsail/kernel

* fix @mainsail/consensus

* fix @mainsail/api-sync

* revert p2p

* add setTimeoutAsync util

* use new helper
diff --git a/eslint.config.js b/eslint.config.js
@@ -57,7 +57,7 @@ export default [
 			"@typescript-eslint/no-empty-object": "off",
 			"@typescript-eslint/no-explicit-any": "error",
 			"@typescript-eslint/no-floating-promises": "error",
-			"@typescript-eslint/no-misused-promises": "warn",
+			"@typescript-eslint/no-misused-promises": "error",
 			"@typescript-eslint/no-non-null-asserted-optional-chain": "off",
 			"@typescript-eslint/no-non-null-assertion": "warn",
 			"@typescript-eslint/no-redundant-type-constituents": "warn",
diff --git a/packages/api-sync/source/listeners/abstract-listener.ts b/packages/api-sync/source/listeners/abstract-listener.ts
@@ -7,6 +7,7 @@ import { Identifiers } from "@mainsail/constants";
 import { inject, injectable, tagged } from "@mainsail/container";
 import type { Contracts } from "@mainsail/contracts";
 import { NotImplemented } from "@mainsail/exceptions";
+import { setTimeoutAsync } from "@mainsail/utils";
 
 import { EventListener } from "../contracts.js";
 
@@ -60,7 +61,7 @@ export abstract class AbstractListener<TEventData, TEntity extends object> imple
 			} catch (ex) {
 				this.logger.error(`#syncToDatabaseTransaction failed: ${ex}`);
 			} finally {
-				this.#syncTimeout = setTimeout(run, syncInterval);
+				this.#syncTimeout = setTimeoutAsync(run, syncInterval);
 			}
 		};
 
diff --git a/packages/api-sync/source/tokens/whitelist.ts b/packages/api-sync/source/tokens/whitelist.ts
@@ -31,38 +31,32 @@ export class TokenWhitelist {
 	@inject(Identifiers.Cryptography.Identity.Address.Factory)
 	private readonly addressFactory!: Contracts.Crypto.AddressFactory;
 
-	#syncInterval?: NodeJS.Timeout;
+	#syncTimeout?: NodeJS.Timeout;
 
 	public async bootstrap(): Promise<void> {
 		const syncInterval = this.#getTokenWhitelistRefreshIntervalMs();
 
-		let running = false;
-
 		this.logger.info(`Starting TokenWhitelist using remote: ${this.#getTokenWhitelistRemoteUrl()}`);
 
-		this.#syncWhitelist()
-			.catch((error) => this.logger.error(`#syncWhitelist failed: ${error}`))
-			.finally(() => {
-				this.#syncInterval = setInterval(async () => {
-					if (running) {
-						return;
-					}
-
-					running = true;
-
-					try {
-						await this.#syncWhitelist();
-					} catch (ex) {
-						this.logger.error(`#syncWhitelist failed: ${ex}`);
-					} finally {
-						running = false;
-					}
+		const run = async () => {
+			try {
+				await this.#syncWhitelist();
+			} catch (ex) {
+				this.logger.error(`#syncWhitelist failed: ${ex}`);
+			} finally {
+				this.#syncTimeout = setTimeout(() => {
+					void run();
 				}, syncInterval);
-			});
+			}
+		};
+
+		void run();
 	}
 
 	public async dispose(): Promise<void> {
-		clearInterval(this.#syncInterval);
+		if (this.#syncTimeout) {
+			clearTimeout(this.#syncTimeout);
+		}
 	}
 
 	async #syncWhitelist(): Promise<void> {
diff --git a/packages/consensus/source/scheduler.ts b/packages/consensus/source/scheduler.ts
@@ -1,6 +1,7 @@
 import { Identifiers } from "@mainsail/constants";
 import { inject, injectable } from "@mainsail/container";
 import type { Contracts } from "@mainsail/contracts";
+import { setTimeoutAsync } from "@mainsail/utils";
 import dayjs from "dayjs";
 
 @injectable()
@@ -33,7 +34,7 @@ export class Scheduler implements Contracts.Consensus.Scheduler {
 
 		const timeout = Math.max(0, timestamp - dayjs().valueOf());
 
-		this.#timeoutStartRound = setTimeout(async () => {
+		this.#timeoutStartRound = setTimeoutAsync(async () => {
 			await this.#getConsensus().onTimeoutStartRound();
 			this.#timeoutStartRound = undefined;
 		}, timeout);
@@ -46,7 +47,7 @@ export class Scheduler implements Contracts.Consensus.Scheduler {
 			return false;
 		}
 
-		this.#timeoutPropose = setTimeout(async () => {
+		this.#timeoutPropose = setTimeoutAsync(async () => {
 			await this.#getConsensus().onTimeoutPropose(height, round);
 			this.#timeoutPropose = undefined;
 		}, this.#getTimeout(round));
@@ -59,7 +60,7 @@ export class Scheduler implements Contracts.Consensus.Scheduler {
 			return false;
 		}
 
-		this.#timeoutPrevote = setTimeout(async () => {
+		this.#timeoutPrevote = setTimeoutAsync(async () => {
 			await this.#getConsensus().onTimeoutPrevote(height, round);
 			this.#timeoutPrevote = undefined;
 		}, this.#getTimeout(round));
@@ -72,7 +73,7 @@ export class Scheduler implements Contracts.Consensus.Scheduler {
 			return false;
 		}
 
-		this.#timeoutPrecommit = setTimeout(async () => {
+		this.#timeoutPrecommit = setTimeoutAsync(async () => {
 			await this.#getConsensus().onTimeoutPrecommit(height, round);
 			this.#timeoutPrecommit = undefined;
 		}, this.#getTimeout(round));
diff --git a/packages/kernel/source/bootstrap/listen-to-shutdown-signals.ts b/packages/kernel/source/bootstrap/listen-to-shutdown-signals.ts
@@ -9,9 +9,13 @@ export class ListenToShutdownSignals implements Contracts.Kernel.Bootstrapper {
 
 	public async bootstrap(): Promise<void> {
 		for (const signal in Enums.Kernel.ShutdownSignal) {
-			process.on(signal, async (code) => {
-				await this.app.terminate(signal);
+			process.on(signal, (_) => {
+				void this.#onSignal(signal);
 			});
 		}
 	}
+
+	async #onSignal(signal: string) {
+		await this.app.terminate(signal);
+	}
 }
diff --git a/packages/kernel/source/ipc/handler.ts b/packages/kernel/source/ipc/handler.ts
@@ -11,17 +11,21 @@ export class Handler<T extends object> implements Contracts.Kernel.IPC.Handler<T
 	}
 
 	public handleRequest(): void {
-		parentPort?.on("message", async (message) => {
-			if (this.handler[message.method] === undefined) {
-				throw new Error(`Method ${message.method} is not defined on the handler`);
-			}
-
-			try {
-				const result = await this.handler[message.method](...message.args);
-				parentPort?.postMessage({ id: message.id, result });
-			} catch (error) {
-				parentPort?.postMessage({ error: error.message, id: message.id });
-			}
+		parentPort?.on("message", (message) => {
+			void this.#onMessage(message);
 		});
 	}
+
+	async #onMessage(message: { method: string; id: string; args: [] }) {
+		if (this.handler[message.method] === undefined) {
+			throw new Error(`Method ${message.method} is not defined on the handler`);
+		}
+
+		try {
+			const result = await this.handler[message.method](...message.args);
+			parentPort?.postMessage({ id: message.id, result });
+		} catch (error) {
+			parentPort?.postMessage({ error: error.message, id: message.id });
+		}
+	}
 }
diff --git a/packages/kernel/source/services/config/watcher.ts b/packages/kernel/source/services/config/watcher.ts
@@ -9,22 +9,25 @@ export class Watcher {
 	private readonly app!: Contracts.Kernel.Application;
 
 	#watcher!: nsfw.NSFW;
+	#configFiles = new Set([".env", "validators.json", "peers.json", "plugins.js", "plugins.json"]);
 
 	public async boot(): Promise<void> {
-		const configFiles = new Set([".env", "validators.json", "peers.json", "plugins.js", "plugins.json"]);
-
-		this.#watcher = await nsfw(this.app.configPath(), async (events) => {
-			for (const event of events) {
-				if (event.action === nsfw.ActionType.MODIFIED && configFiles.has(event.file)) {
-					await this.app.reboot();
-					break;
-				}
-			}
+		this.#watcher = await nsfw(this.app.configPath(), (events) => {
+			void this.#handleEvents(events);
 		});
 
 		await this.#watcher.start();
 	}
 
+	async #handleEvents(events: nsfw.FileChangeEvent[]) {
+		for (const event of events) {
+			if (event.action === nsfw.ActionType.MODIFIED && this.#configFiles.has(event.file)) {
+				await this.app.reboot();
+				break;
+			}
+		}
+	}
+
 	public async dispose(): Promise<void> {
 		return this.#watcher.stop();
 	}
diff --git a/packages/kernel/source/services/filesystem/drivers/local.ts b/packages/kernel/source/services/filesystem/drivers/local.ts
@@ -80,7 +80,7 @@ export class LocalFilesystem implements Contracts.Kernel.Filesystem {
 		return this.fs
 			.readdirSync(directory)
 			.map((item: string) => `${directory}/${item}`)
-			.filter(async (item: string) => this.fs.lstatSync(item).isFile());
+			.filter((item: string) => this.fs.lstatSync(item).isFile());
 	}
 
 	public async directories(directory: string): Promise<string[]> {
@@ -89,7 +89,7 @@ export class LocalFilesystem implements Contracts.Kernel.Filesystem {
 		return this.fs
 			.readdirSync(directory)
 			.map((item: string) => `${directory}/${item}`)
-			.filter(async (item: string) => this.fs.lstatSync(item).isDirectory());
+			.filter((item: string) => this.fs.lstatSync(item).isDirectory());
 	}
 
 	public async makeDirectory(path: string): Promise<boolean> {
diff --git a/packages/kernel/source/services/queue/drivers/memory.ts b/packages/kernel/source/services/queue/drivers/memory.ts
@@ -77,7 +77,7 @@ export class MemoryQueue extends EventEmitter implements Contracts.Kernel.Queue
 	}
 
 	public async later(delay: number, job: Contracts.Kernel.QueueJob): Promise<void> {
-		setTimeout(() => this.push(job), delay);
+		setTimeout(() => void this.push(job), delay);
 	}
 
 	public async bulk(jobs: Contracts.Kernel.QueueJob[]): Promise<void> {
diff --git a/packages/p2p/source/service.ts b/packages/p2p/source/service.ts
@@ -64,7 +64,9 @@ export class Service implements Contracts.P2P.Service {
 		await this.#checkReceivedMessages();
 
 		if (!this.#disposed) {
-			this.#mainLoopTimeout = setTimeout(() => this.mainLoop(), 2000);
+			this.#mainLoopTimeout = setTimeout(() => {
+				void this.mainLoop();
+			}, 2000);
 		}
 	}
 
@@ -108,7 +110,9 @@ export class Service implements Contracts.P2P.Service {
 
 		if (!this.#disposed) {
 			const nextTimeout = randomNumber(10, 20) * 60 * 1000;
-			this.#apiNodeCheckLoopTimeout = setTimeout(() => this.#checkApiNodes(), nextTimeout);
+			this.#apiNodeCheckLoopTimeout = setTimeout(() => {
+				void this.#checkApiNodes();
+			}, nextTimeout);
 		}
 	}
 
@@ -127,6 +131,8 @@ export class Service implements Contracts.P2P.Service {
 
 		// we use Promise.race to cut loose in case some communicator.ping() does not resolve within the delay
 		// in that case we want to keep on with our program execution while ping promises can finish in the background
+		// TODO: revisit
+		/* eslint-disable @typescript-eslint/no-misused-promises */
 		await new Promise<void>(async (resolve) => {
 			let isResolved = false;
 
@@ -150,6 +156,7 @@ export class Service implements Contracts.P2P.Service {
 
 			await delay(pingDelay).finally(resolvesFirst);
 		});
+		/* eslint-enable */
 
 		if (unresponsivePeers > 0) {
 			this.logger.debug(`Removed ${pluralize("peer", unresponsivePeers, true)}`, "p2p");
diff --git a/packages/test-runner/source/describe.ts b/packages/test-runner/source/describe.ts
@@ -17,11 +17,11 @@ type ContextFunction<T> = () => T;
 type ContextCallback<T> = (context: T) => Promise<void> | void;
 
 interface CallbackArguments<T> {
-	afterAll: (callback_: ContextCallback<T>) => void;
-	afterEach: (callback_: ContextCallback<T>) => void;
+	afterAll: (callback_: ContextCallback<T>) => Promise<void>;
+	afterEach: (callback_: ContextCallback<T>) => Promise<void>;
 	assert: typeof assert;
-	beforeAll: (callback_: ContextCallback<T>) => void;
-	beforeEach: (callback_: ContextCallback<T>) => void;
+	beforeAll: (callback_: ContextCallback<T>) => Promise<void>;
+	beforeEach: (callback_: ContextCallback<T>) => Promise<void>;
 	clock: (config?: number | Date | { now?: number | Date | undefined }) => sinon.SinonFakeTimers;
 
 	dataset: unknown;
diff --git a/packages/utils/source/index.ts b/packages/utils/source/index.ts
@@ -169,6 +169,7 @@ export * from "./reverse.js";
 export * from "./sample.js";
 export * from "./semver.js";
 export * from "./set.js";
+export * from "./set-timeout-async.js";
 export * from "./shuffle.js";
 export * from "./sleep.js";
 export * from "./snake-case.js";
diff --git a/packages/utils/source/set-timeout-async.test.ts b/packages/utils/source/set-timeout-async.test.ts
@@ -0,0 +1,22 @@
+import { describe } from "@mainsail/test-runner";
+import { setTimeoutAsync } from "./set-timeout-async";
+
+describe("setTimeoutAsync", async ({ assert, it }) => {
+	it("should be ok", async () => {
+		const events: string[] = [];
+
+		const done = new Promise<void>((resolve) => {
+			const timeout = setTimeoutAsync(async () => {
+				events.push("callback");
+				await Promise.resolve();
+				resolve();
+			}, 100);
+		});
+
+		events.push("after-call");
+
+		await done;
+
+		assert.equal(events, ["after-call", "callback"]);
+	});
+});
diff --git a/packages/utils/source/set-timeout-async.ts b/packages/utils/source/set-timeout-async.ts
@@ -0,0 +1,6 @@
+export const setTimeoutAsync = (callback: () => Promise<void>, delay: number): NodeJS.Timeout =>
+	setTimeout(() => {
+		void (async () => {
+			await callback();
+		})();
+	}, delay);

Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,13 @@ export class ListenToShutdownSignals implements Contracts.Kernel.Bootstrapper {`
`9`	`9`
`10`	`10`	`public async bootstrap(): Promise<void> {`
`11`	`11`	`for (const signal in Enums.Kernel.ShutdownSignal) {`
`12`		`- process.on(signal, async (code) => {`
`13`		`- await this.app.terminate(signal);`
	`12`	`+ process.on(signal, (_) => {`
	`13`	`+ void this.#onSignal(signal);`
`14`	`14`	`});`
`15`	`15`	`}`
`16`	`16`	`}`
	`17`	`+`
	`18`	`+ async #onSignal(signal: string) {`
	`19`	`+ await this.app.terminate(signal);`
	`20`	`+ }`
`17`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ export class MemoryQueue extends EventEmitter implements Contracts.Kernel.Queue`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public async later(delay: number, job: Contracts.Kernel.QueueJob): Promise<void> {`
`80`		`- setTimeout(() => this.push(job), delay);`
	`80`	`+ setTimeout(() => void this.push(job), delay);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public async bulk(jobs: Contracts.Kernel.QueueJob[]): Promise<void> {`