refactor: Catch errors for all PS events

Author: PartMan7

src/ps/commands/help.tsx

@@ -1,5 +1,5 @@
 import { prefix } from '@/config/ps';
-import { LivePS } from '@/sentinel/live';
+import { LivePSStuff } from '@/sentinel/live';
 import { Perms } from '@/types/perms';
 import { ChatError } from '@/utils/chatError';
 import { Button, Username } from '@/utils/components/ps';
@@ -167,7 +167,7 @@ export const command: PSCommand = {
 		// Parse the command to try and find what we need
 		let parsed: ReturnType<typeof parse>;
 		try {
-			parsed = LivePS.commands.parse(args, [], $T);
+			parsed = LivePSStuff.commands.parse(args, [], $T);
 			if (parsed.command.flags?.noDisplay) throw new Error(); // Don't show this here!
 		} catch (e) {
 			throw new ChatError('COULD_NOT_FIND_COMMAND' as ToTranslate); // TODO

src/ps/handlers/commands/index.ts

@@ -1,6 +1,6 @@
 import { prefix } from '@/config/ps';
 import { i18n } from '@/i18n';
-import { LivePS } from '@/sentinel/live';
+import { LivePSStuff } from '@/sentinel/live';
 import { ChatError } from '@/utils/chatError';
 import { log } from '@/utils/logger';
 
@@ -31,7 +31,7 @@ export async function commandHandler(message: PSMessage, indirect: IndirectCtx |
 
 	if (!messageContent.startsWith(prefix)) return;
 
-	const { parse, permissions, spoof } = LivePS.commands;
+	const { parse, permissions, spoof } = LivePSStuff.commands;
 
 	try {
 		const usePermissions: typeof permissions = (...args) => {

src/ps/handlers/commands/permissions.ts

@@ -1,7 +1,7 @@
 import { PSRoomConfigs } from '@/cache';
 import { admins } from '@/config/ps';
 import { KNOWN_RANK_MAPPINGS, RANK_ORDER } from '@/ps/constants';
-import { LivePS } from '@/sentinel/live';
+import { LivePSStuff } from '@/sentinel/live';
 
 import type { Perms } from '@/types/perms';
 import type { AuthKey, PSMessage } from '@/types/ps';
@@ -66,7 +66,7 @@ export function permissions(perm: Perms, command: string[] | null, message: PSMe
 		if (roomConfig?.permissions?.[lookup]) return permissions(roomConfig.permissions[lookup], null, message);
 	}
 	if (typeof perm === 'symbol') {
-		const groupedPerms = LivePS.commands.GROUPED_PERMS;
+		const groupedPerms = LivePSStuff.commands.GROUPED_PERMS;
 		if (perm in groupedPerms) {
 			const symbolName = Symbol.keyFor(perm)!;
 			if (roomConfig?.permissions?.[symbolName]) return permissions(roomConfig.permissions[symbolName], null, message);

src/ps/handlers/index.ts

@@ -0,0 +1,16 @@
+import { LivePSHandlers } from '@/sentinel/live';
+import { errorLog } from '@/utils/logger';
+
+import type { Client } from 'ps-client';
+
+export function registerEvent<Event extends keyof LivePSHandlers>(client: Client, event: Event): (typeof LivePSHandlers)[Event] {
+	// @ts-expect-error -- TS doesn't like this, but it will end up being checked when calling
+	return (...args: Parameters<(typeof LivePSHandlers)[Event]>) => {
+		try {
+			// @ts-expect-error -- See above
+			return LivePSHandlers[event].apply(client, args);
+		} catch (err) {
+			if (err instanceof Error) errorLog(err);
+		}
+	};
+}

src/ps/index.ts

@@ -2,28 +2,28 @@ import { Client } from 'ps-client';
 
 import { password, rooms, username } from '@/config/ps';
 import { IS_ENABLED } from '@/enabled';
+import { registerEvent } from '@/ps/handlers';
 import { startPSCron } from '@/ps/handlers/cron';
 import { transformHTML } from '@/ps/handlers/html';
 import loadPS from '@/ps/loaders';
-import { LivePS } from '@/sentinel/live';
 import { log } from '@/utils/logger';
 
 const PS = new Client({ username, password, rooms, transformHTML });
 PS.on('login', () => log(`Connected to PS! [${username}]`));
 
 if (IS_ENABLED.PS) loadPS().then(() => PS.connect());
 
-PS.on('message', (...args) => LivePS.commands.commandHandler.call(PS, ...args));
-PS.on('message', (...args) => LivePS.interfaceHandler.call(PS, ...args));
-PS.on('message', (...args) => LivePS.autoResHandler.call(PS, ...args));
-PS.on('message', (...args) => LivePS.pageHandler.call(PS, ...args));
+PS.on('message', registerEvent(PS, 'commandHandler'));
+PS.on('message', registerEvent(PS, 'interfaceHandler'));
+PS.on('message', registerEvent(PS, 'autoResHandler'));
+PS.on('message', registerEvent(PS, 'pageHandler'));
 
-PS.on('join', (...args) => LivePS.joinHandler.call(PS, ...args));
-PS.on('name', (...args) => LivePS.nickHandler.call(PS, ...args));
-PS.on('leave', (...args) => LivePS.leaveHandler.call(PS, ...args));
-PS.on('notify', (...args) => LivePS.notifyHandler.call(PS, ...args));
-PS.on('raw', (...args) => LivePS.rawHandler.call(PS, ...args));
-PS.on('tournament', (...args) => LivePS.tourHandler.call(PS, ...args));
+PS.on('join', registerEvent(PS, 'joinHandler'));
+PS.on('name', registerEvent(PS, 'nickHandler'));
+PS.on('leave', registerEvent(PS, 'leaveHandler'));
+PS.on('notify', registerEvent(PS, 'notifyHandler'));
+PS.on('raw', registerEvent(PS, 'rawHandler'));
+PS.on('tournament', registerEvent(PS, 'tourHandler'));
 
 if (IS_ENABLED.PS) startPSCron.bind(PS)();
 

src/sentinel/live.ts

@@ -26,15 +26,9 @@ import { tourHandler } from '@/ps/handlers/tours';
 export const LiveData = {};
 
 /** @see {@link LiveData} */
-export const LivePS = {
+export const LivePSHandlers = {
 	autoResHandler,
-	commands: {
-		commandHandler,
-		parse,
-		permissions,
-		spoof,
-		GROUPED_PERMS,
-	},
+	commandHandler,
 	interfaceHandler,
 	joinHandler,
 	leaveHandler,
@@ -44,3 +38,14 @@ export const LivePS = {
 	rawHandler,
 	tourHandler,
 };
+export type LivePSHandlers = typeof LivePSHandlers;
+
+/** @see {@link LiveData} */
+export const LivePSStuff = {
+	commands: {
+		parse,
+		permissions,
+		spoof,
+		GROUPED_PERMS,
+	},
+};

src/sentinel/registers/ps.ts

@@ -2,7 +2,7 @@ import { promises as fs } from 'fs';
 
 import { Games } from '@/ps/games';
 import { reloadCommands } from '@/ps/loaders/commands';
-import { LivePS } from '@/sentinel/live';
+import { LivePSHandlers, LivePSStuff } from '@/sentinel/live';
 import { cachebust } from '@/utils/cachebust';
 import { fsPath } from '@/utils/fsPath';
 
@@ -17,7 +17,10 @@ const PS_EVENT_HANDLERS = {
 	'raw-handler': { imports: ['rawHandler'], importPath: '@/ps/handlers/raw', fileName: 'raw' },
 	'notify-handler': { imports: ['notifyHandler'], importPath: '@/ps/handlers/notifications', fileName: 'notifications' },
 	'tour-handler': { imports: ['tourHandler'], importPath: '@/ps/handlers/tours', fileName: 'tours' },
-} satisfies Record<string, { imports: (keyof typeof LivePS)[]; importPath: string; fileName: string /* TODO: remove fileName */ }>;
+} satisfies Record<
+	string,
+	{ imports: (keyof typeof LivePSHandlers)[]; importPath: string; fileName: string /* TODO: remove fileName */ }
+>;
 
 export const PS_REGISTERS: Register[] = [
 	{
@@ -66,17 +69,17 @@ export const PS_REGISTERS: Register[] = [
 					const importPath = `@/ps/handlers/commands/${file}`;
 					cachebust(importPath);
 					const hotHandler = await import(importPath);
-					LivePS.commands[file] = hotHandler[file];
+					LivePSStuff.commands[file] = hotHandler[file];
 				})
 			);
 
 			cachebust('@/ps/handlers/commands/customPerms');
 			const { GROUPED_PERMS: newGroupedPerms } = await import('@/ps/handlers/commands/customPerms');
-			LivePS.commands.GROUPED_PERMS = newGroupedPerms;
+			LivePSStuff.commands.GROUPED_PERMS = newGroupedPerms;
 
 			cachebust('@/ps/handlers/commands');
 			const { commandHandler } = await import('@/ps/handlers/commands');
-			LivePS.commands.commandHandler = commandHandler;
+			LivePSHandlers.commandHandler = commandHandler;
 		},
 	},
 
@@ -87,7 +90,7 @@ export const PS_REGISTERS: Register[] = [
 		reload: async () => {
 			cachebust(handlerData.importPath);
 			const hotHandler = await import(handlerData.importPath);
-			handlerData.imports.forEach(namedImport => (LivePS[namedImport] = hotHandler[namedImport]));
+			handlerData.imports.forEach(namedImport => (LivePSHandlers[namedImport] = hotHandler[namedImport]));
 		},
 	})),
 ];