Revert plugins rework

Not very nice to work with...

Author: TheKodeToad

.vscode/settings.json

@@ -20,6 +20,5 @@
 	"javascript.format.semicolons": "insert",
 	"typescript.format.semicolons": "insert",
 	"typescript.preferences.importModuleSpecifier": "non-relative",
-	"javascript.preferences.importModuleSpecifier": "non-relative",
-	"typescript.preferences.autoImportSpecifierExcludeRegexes": ["^zod(/(v3|v4-mini))?$"],
+	"javascript.preferences.importModuleSpecifier": "non-relative"
 }

backend/package.json

@@ -6,32 +6,33 @@
 	},
 	"scripts": {
 		"lint": "eslint && tsc",
-		"bot": "pnpm run _node src/interface/discord/main.ts",
-		"http": "pnpm run _node src/interface/http/main.ts",
-		"migration": "pnpm run _node src/interface/migration/main.ts",
+		"bot": "pnpm run _node src/bot/main.ts",
+		"http": "pnpm run _node src/http/main.ts",
+		"migrate": "pnpm run _node src/db/main.ts migrate --",
+		"check-migrations": "pnpm run _node src/db/main.ts check --",
 		"test": "node --import=./registerSWC.js --test src/**/*.test.ts",
 		"_node": "node --env-file=.env --disable-proto=throw --disallow-code-generation-from-strings --experimental-transform-types"
 	},
 	"dependencies": {
 		"@hono/node-server": "^1.14.4",
-		"@hono/zod-validator": "^0.7.0",
+		"@hono/valibot-validator": "^0.5.2",
 		"async-lock": "^1.4.1",
-		"hono": "^4.8.2",
+		"hono": "^4.7.11",
 		"oceanic-component-helper": "^1.0.1",
 		"oceanic.js": "~1.12.0",
-		"pg": "^8.16.3",
+		"pg": "^8.16.0",
 		"smol-toml": "^1.3.4",
-		"zod": "^3.25.76"
+		"valibot": "^1.1.0"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.30.1",
+		"@eslint/js": "^9.27.0",
 		"@swc-node/register": "^1.10.10",
 		"@types/async-lock": "^1.4.2",
-		"@types/node": "^24.0.3",
+		"@types/node": "^24.0.1",
 		"@types/pg": "^8.15.2",
-		"eslint": "^9.29.0",
+		"eslint": "^9.27.0",
 		"globals": "^16.2.0",
 		"typescript": "^5.8.3",
-		"typescript-eslint": "^8.36.0"
+		"typescript-eslint": "^8.33.1"
 	}
 }

backend/src/bot/common/discord/cachedRequest.ts

@@ -0,0 +1,118 @@
+import { isTextableGuildChannel, isThreadChannel } from "#bot/common/discord/general.ts";
+import { bot } from "#bot/index.ts";
+import { type AnyTextableGuildChannel, type AnyThreadChannel, DiscordRESTError, Guild, Member, PrivateChannel, type RequestGuildMembersOptions, type Uncached, User } from "oceanic.js";
+
+export async function fetchUserCached(userID: string): Promise<User> {
+	return bot.users.get(userID) ?? await bot.rest.users.get(userID);
+}
+
+export async function fetchUserCachedSupressed(userID: string): Promise<User | Uncached> {
+	try {
+		return await fetchUserCached(userID);
+	} catch (error) {
+		if (!(error instanceof DiscordRESTError))
+			throw error;
+
+		return { id: userID };
+	}
+}
+
+export async function fetchMemberCached(guild: Guild, userID: string): Promise<Member> {
+	return guild.members.get(userID) ?? await bot.rest.guilds.getMember(guild.id, userID);
+}
+
+export function fetchBotUserCached(guild: Guild): Promise<Member> {
+	return fetchMemberCached(guild, bot.user.id);
+}
+
+export async function createDMCached(userID: string): Promise<PrivateChannel> {
+	return bot.privateChannels.find(channel => channel.recipient.id === userID) ?? await bot.rest.users.createDM(userID);
+}
+
+export async function fetchThreadCached(guild: Guild, threadID: string): Promise<AnyThreadChannel | null> {
+	const cached = guild.threads.get(threadID);
+
+	if (cached !== undefined)
+		return cached;
+
+	if (bot.getChannel(threadID) !== undefined)
+		return null;
+
+	const fetched = await bot.rest.channels.get(threadID);
+
+	if (!isThreadChannel(fetched))
+		return null;
+
+	if (fetched.guildID !== guild.id)
+		return null;
+
+	return fetched;
+}
+
+export async function fetchTextableGuildChannelCached(guild: Guild, channelID: string): Promise<AnyTextableGuildChannel | null> {
+	const cachedRegularChannel = guild.channels.get(channelID);
+
+	if (cachedRegularChannel !== undefined) {
+		if (isTextableGuildChannel(cachedRegularChannel))
+			return cachedRegularChannel;
+		else
+			return null;
+	}
+
+	const cachedThreadChannel = guild.threads.get(channelID);
+
+	if (cachedThreadChannel !== undefined)
+		return cachedThreadChannel;
+
+	// must belong to another guild
+	if (bot.getChannel(channelID))
+		return null;
+
+	const fetched = await bot.rest.channels.get(channelID);
+
+	if (!isTextableGuildChannel(fetched))
+		return null;
+
+	if (fetched.guildID !== guild.id)
+		return null;
+
+	return fetched;
+}
+
+export async function fetchMembersCached(
+	guild: Guild,
+	userIDs: readonly string[],
+	options?: Pick<RequestGuildMembersOptions, "presences" | "timeout">
+): Promise<Map<string, Member>> {
+	const result: Map<string, Member> = new Map;
+	const queue: string[] = [];
+	const promises: Promise<unknown>[] = [];
+
+	const request = (): void => {
+		promises.push(
+			guild.shard.requestGuildMembers(guild.id, {
+				userIDs: queue,
+				...options,
+			}).then(members => members.forEach(member => result.set(member.id, member)))
+		);
+		queue.length = 0;
+	};
+
+	for (const id of userIDs) {
+		const member = guild.members.get(id);
+		if (member !== undefined)
+			result.set(id, member);
+		else {
+			queue.push(id);
+			if (queue.length === 100)
+				request();
+		}
+	}
+
+	if (queue.length > 0)
+		request();
+
+	await Promise.all(promises);
+	return result;
+}
+

backend/src/bot/common/discord/colors.ts

@@ -0,0 +1,9 @@
+const blurple = 0x5865F2;
+const green = 0x57F287;
+const yellow = 0xFEE75C;
+const fuchsia = 0xEB459E;
+const red = 0xED4245;
+const white = 0xFFFFFF;
+const black = 0x000000;
+
+export const colors = Object.freeze({ blurple, green, yellow, fuchsia, red, white, black, __proto__: null });

backend/src/bot/common/discord/debugFormat.ts

@@ -0,0 +1,32 @@
+import { bot } from "#bot/index.ts";
+import type { AnyChannel, Guild, Member, Uncached, User } from "oceanic.js";
+
+export function debugFormatUser(user: User): string {
+	return `@${user.tag}[${user.id}]`;
+}
+
+export function debugFormatChannel(channel: AnyChannel): string {
+	let name = "<unnamed>";
+
+	if ("name" in channel)
+		name = channel.name ?? name;
+
+	return `#${name}[${channel.id}]`;
+}
+
+export function debugFormatGuildByID(id: string): string {
+	return debugFormatGuild(bot.guilds.get(id) ?? { id });
+}
+
+export function debugFormatGuild(guild: Guild | Uncached): string {
+	let name = "<unknown>";
+
+	if ("name" in guild)
+		name = guild.name;
+
+	return `*${name}[${guild.id}]`;
+}
+
+export function debugFormatPermissionContext(member: Member, channel: AnyChannel): string {
+	return `${debugFormatUser(member.user)} in ${debugFormatChannel(channel)}, ${debugFormatGuild(member.guild)}`;
+}

backend/src/bot/common/discord/format.ts

@@ -0,0 +1,63 @@
+import { fetchUserCachedSupressed } from "#bot/common/discord/cachedRequest.ts";
+import { escapeMarkdown } from "#bot/common/discord/markdown.ts";
+import { DiscordRESTError, Member, User, UserFlags, type Uncached } from "oceanic.js";
+
+export function formatRESTError(restError: DiscordRESTError): string {
+	if (restError.resBody !== null
+		&& typeof restError.resBody.message === "string") {
+		return `API Error ${restError.code}: ${escapeMarkdown(restError.resBody.message)}`;
+	}
+
+	return `HTTP Error ${restError.status}: ${escapeMarkdown(restError.statusText)}`;
+}
+
+export async function formatUserTagByID(id: string): Promise<string> {
+	return formatUserTag(await fetchUserCachedSupressed(id));
+}
+
+export async function formatUserByID(id: string): Promise<string> {
+	return formatUser(await fetchUserCachedSupressed(id));
+}
+
+export async function formatUserBoldByID(id: string): Promise<string> {
+	return formatUserBold(await fetchUserCachedSupressed(id));
+}
+
+type UserLike = { id: string; tag: string; } | Uncached;
+
+export function formatUser(user: UserLike): string {
+	return `${formatUserTag(user)} (<@${user.id}>)`;
+}
+
+export function formatUserBold(user: UserLike): string {
+	return `**${formatUserTag(user)}** (<@${user.id}>)`;
+}
+
+export function formatUserTag(user: UserLike): string {
+	if ("tag" in user)
+		return escapeMarkdown(user.tag);
+	else
+		return "\\<unknown\\>";
+}
+
+/** This should be used in user lookup commands to nicely present information next to the name which otherwise would be displayed elsewhere. */
+export function formatUserTagRich(user: User | Member): string {
+	if ("user" in user)
+		user = user.user;
+
+	let result = escapeMarkdown(user.tag || user.globalName || "<unknown>");
+
+	if (user.clan !== null)
+		result += " \\[" + escapeMarkdown(user.clan.tag) + "\\]";
+
+	if (user.system)
+		result += " \\[SYSTEM\\]";
+	else if (user.bot) {
+		if (user.publicFlags & UserFlags.VERIFIED_BOT)
+			result += " \\[✔\u8201APP]\\";
+		else
+			result += " \\[APP\\]";
+	}
+
+	return result;
+}

backend/src/bot/common/discord/general.ts

@@ -0,0 +1,29 @@
+import { Channel, ChannelTypes, MessageTypes, TextableChannelTypes, TextableGuildChannelTypes, ThreadChannelTypes, UndeletableMessageTypes, type AnyTextableChannel, type AnyTextableGuildChannel, type AnyThreadChannel, type TextableChannels, type TextableGuildChannels, type ThreadChannels } from "oceanic.js";
+
+export function isThreadChannel(channel: Channel): channel is AnyThreadChannel {
+	return isThreadChannelType(channel.type);
+}
+
+export function isThreadChannelType(type: ChannelTypes): type is ThreadChannels {
+	return ThreadChannelTypes.includes(type as ThreadChannels);
+}
+
+export function isTextableChannel(channel: Channel): channel is AnyTextableChannel {
+	return isTextableChannelType(channel.type);
+}
+
+export function isTextableChannelType(type: ChannelTypes): type is TextableChannels {
+	return TextableChannelTypes.includes(type as TextableChannels);
+}
+
+export function isTextableGuildChannel(channel: Channel): channel is AnyTextableGuildChannel {
+	return isTextableGuildChannelType(channel.type);
+}
+
+export function isTextableGuildChannelType(type: ChannelTypes): type is TextableGuildChannels {
+	return TextableGuildChannelTypes.includes(type as TextableGuildChannels);
+}
+
+export function isUndeletableMessageType(type: MessageTypes): type is typeof UndeletableMessageTypes[number] {
+	return UndeletableMessageTypes.includes(type as typeof UndeletableMessageTypes[number]);
+}

backend/src/bot/common/discord/markdown.ts

@@ -0,0 +1,30 @@
+// everything where an escape is valid and the character sometimes affects formatting
+// (all punctuation seems to be possible to escape?)
+// perhaps this is not the best way to do this but it should work everywhere apart from inside codeblocks
+const FORMATTING_REGEX = /[\\/*_\-`#@<>.~|:[\]()]/g;
+const ZWSP = "\u200B";
+
+/**
+ * Escape all characters used for markdown formatting.
+ * Mainly used whenever a username is being displayed.
+ * Make sure that the field supports formatting - a common mistake is to use in embed titles which do not have foramtting applied!
+ * !! Do not use as a replacement for allowedMentions or SUPRESS_EMBEDS !!
+ */
+export function escapeMarkdown(input: string): string {
+	return input.replace(FORMATTING_REGEX, "\\$&");
+}
+
+export function makeMarkdownInlineCodeblock(input: string): string {
+	if (input.length === 0)
+		return "`" + ZWSP + "`";
+
+	return "``" + input.replaceAll("`", ZWSP + "`" + ZWSP) + "``";
+}
+
+export function makeMarkdownMultilineCodeblock(input: string): string {
+	return "```\n" + input.replaceAll("`", ZWSP + "`" + ZWSP) + "\n```";
+}
+
+export function makeMarkdownQuote(input: string): string {
+	return "> " + input.replaceAll("\n", "\n> ");
+}