Add quoted message IDs to DB (#571)

holzmaster · web-flow · commit 21e799a32e44 · 2026-01-31T16:35:12.000+01:00
diff --git a/src/handler/reaction/quoteHandler.ts b/src/handler/reaction/quoteHandler.ts
@@ -3,23 +3,24 @@ import {
     type Message,
     type MessageReaction,
     type User,
-    type TextBasedChannel,
-    type GuildEmoji,
-    type ReactionEmoji,
     ChannelType,
     type Channel,
     type Snowflake,
     type GuildTextBasedChannel,
-    type ApplicationEmoji,
+    hyperlink,
 } from "discord.js";
 import { Temporal } from "@js-temporal/polyfill";
 
 import type { BotContext, QuoteConfig } from "#context.ts";
 import type { ReactionHandler } from "../ReactionHandler.ts";
 import log from "#log";
 
+import * as quoteService from "#service/quote.ts";
+
 const quoteMessage = "Ihr quoted echt jeden Scheiß, oder?";
 
+// TODO: Move some of these functions to the service
+
 const isChannelAnonymous = async (context: BotContext, channel: Channel) => {
     const anonChannels = context.commandConfig.quote.anonymousChannelIds;
 
@@ -37,13 +38,6 @@ const isChannelAnonymous = async (context: BotContext, channel: Channel) => {
     return false;
 };
 
-const isQuoteEmoji = (
-    quoteConfig: QuoteConfig,
-    emoji: GuildEmoji | ReactionEmoji | ApplicationEmoji,
-) => {
-    return emoji.name === quoteConfig.emojiName;
-};
-
 const getMessageQuoter = async (
     quoteConfig: QuoteConfig,
     message: Message,
@@ -53,8 +47,8 @@ const getMessageQuoter = async (
         throw new Error("Guild is null");
     }
     const fetchedMessage = await message.fetch(true);
-    const messageReaction = fetchedMessage.reactions.cache.find(r =>
-        isQuoteEmoji(quoteConfig, r.emoji),
+    const messageReaction = fetchedMessage.reactions.cache.find(
+        r => r.emoji.name === quoteConfig.emojiName,
     );
 
     if (messageReaction === undefined) {
@@ -67,13 +61,6 @@ const getMessageQuoter = async (
         .filter((member): member is GuildMember => member !== null);
 };
 
-const isMessageAlreadyQuoted = (
-    messageQuoter: readonly GuildMember[],
-    context: BotContext,
-): boolean => {
-    return messageQuoter.some(u => u.id === context.client.user.id);
-};
-
 const hasMessageEnoughQuotes = (
     context: BotContext,
     messageQuoter: readonly GuildMember[],
@@ -192,78 +179,72 @@ export default {
             return;
         }
 
+        if (invoker.id === context.client.user.id) {
+            return;
+        }
+
         const quoteConfig = context.commandConfig.quote;
+        if (event.emoji.name !== quoteConfig.emojiName) {
+            return;
+        }
 
-        if (
-            !isQuoteEmoji(quoteConfig, event.emoji) ||
-            event.message.guildId === null ||
-            invoker.id === context.client.user.id
-        ) {
+        const message = await event.message.fetch(true);
+        if (!message.inGuild()) {
+            return;
+        }
+
+        const quotedMember = message.member;
+        if (!quotedMember) {
+            log.error(
+                "`quotedMember` is null or undefined. Should not happen. Good luck finding the issue.",
+            );
+            return;
+        }
+
+        const quoter = await context.guild.members.fetch(invoker.id);
+        if (!quoter) {
+            log.error(
+                "`quoter` is null or undefined. Should not happen. Good luck finding the issue.",
+            );
             return;
         }
 
-        const quoter = context.guild.members.cache.get(invoker.id);
+        // We could use a proper transaction for that
+        // But nobody's got time for that
+        const alreadyQuoted = await quoteService.isMessageAlreadyQuoted(message);
+        if (alreadyQuoted) {
+            return;
+        }
 
-        const sourceChannel = event.message.channel as TextBasedChannel;
-        const quotedMessage = await sourceChannel.messages.fetch(event.message.id);
-        const messageReference = quotedMessage.reference;
-        const messageReferenceId = messageReference?.messageId;
+        const messageReferenceId = message.reference?.messageId ?? undefined;
         const referencedMessage = messageReferenceId
-            ? await sourceChannel.messages.fetch(messageReferenceId)
+            ? await message.channel.messages.fetch(messageReferenceId)
             : undefined;
 
-        const quotedUser = quotedMessage.member;
         const referencedUser = referencedMessage?.member;
-        const quotingMembers = await getMessageQuoter(quoteConfig, quotedMessage);
+        const quotingMembers = await getMessageQuoter(quoteConfig, message);
 
         const quotingMembersAllowed = quotingMembers.filter(context.roleGuard.isNerd);
 
-        if (!quotedUser || !quoter) {
-            log.error(
-                "Something bad happened, there is something missing that shouldn't be missing",
-            );
-            return;
-        }
-
         log.debug(
-            `[Quote] User tried to ${quoter.displayName} (${quoter.id}) quote user ${quotedUser.displayName} (${quotedUser.id}) on message ${quotedMessage.id}`,
+            `[Quote] User tried to ${quoter.displayName} (${quoter.id}) quote user ${quotedMember.displayName} (${quotedMember.id}) on message ${message.id}`,
         );
 
         if (
             !context.roleGuard.isNerd(quoter) ||
-            quoteConfig.blacklistedChannelIds.has(quotedMessage.channelId) ||
-            isMessageAlreadyQuoted(quotingMembers, context)
+            quoteConfig.blacklistedChannelIds.has(message.channelId)
         ) {
             await event.users.remove(quoter);
             return;
         }
 
-        if (
-            quotedMessage.author.id === context.client.user.id &&
-            isQuoterQuotingQuoteMessage(quotedMessage)
-        ) {
+        if (message.author.id === context.client.user.id && isQuoterQuotingQuoteMessage(message)) {
             await event.users.remove(quoter);
             return;
         }
 
-        if (isQuoterQuotingHimself(quoter, quotedUser)) {
-            await context.textChannels.hauptchat.send({
-                embeds: [
-                    {
-                        color: 0xe83e41,
-                        author: {
-                            name: quoter.displayName,
-                            icon_url: quoter.avatarURL({ forceStatic: true }) ?? undefined,
-                        },
-                        title: `${quoter.displayName} der Lellek hat gerade versucht sich, selbst zu quoten. Was für ein Opfer!`,
-                        description: `${quotedMessage.cleanContent}\n\n([link](${quotedMessage.url}))`,
-                    },
-                ],
-                allowedMentions: {
-                    users: [quoter.id],
-                },
-            });
-
+        if (isQuoterQuotingHimself(quoter, quotedMember)) {
+            await context.textChannels.hauptchat.send(createSelfQuoteReply(quoter, message));
             await event.users.remove(quoter);
             return;
         }
@@ -274,14 +255,14 @@ export default {
 
         const { quote, reference } = await createQuote(
             context,
-            quotedUser,
+            quotedMember,
             quotingMembersAllowed.map(member => member.user),
             referencedUser,
-            quotedMessage,
+            message,
             referencedMessage,
         );
         const { id: targetChannelId, channel: targetChannel } = getTargetChannel(
-            quotedMessage.channelId,
+            message.channelId,
             context,
         );
 
@@ -305,9 +286,9 @@ export default {
         // another quote event could sneak in and performing a quote itself.
         // Therefore we're checking again whether the message is already quoted BEFORE
         // sending the quote.
-        // This is a really dirty fix - not even a fix at all - but I'm to lazy to
-        // introduce some proper synchronization. Should work good enough for us.
-        if (isMessageAlreadyQuoted(quotingMembers, context)) {
+        const wasAdded = await quoteService.addQuoteIfNotPresent(message);
+        if (!wasAdded) {
+            // caught race condition
             return;
         }
 
@@ -318,12 +299,29 @@ export default {
             await targetChannel.send(quote);
         }
 
-        await quotedMessage.react(event.emoji);
-        if (
-            quotedMessage.channel.isTextBased() &&
-            quotedMessage.channel.type === ChannelType.GuildText
-        ) {
-            await quotedMessage.reply(quoteMessage);
+        await message.react(event.emoji);
+
+        if (message.channel.isTextBased() && message.channel.type === ChannelType.GuildText) {
+            await message.reply(quoteMessage);
         }
     },
 } satisfies ReactionHandler;
+
+function createSelfQuoteReply(quoter: GuildMember, message: Message<true>) {
+    return {
+        embeds: [
+            {
+                color: 0xe83e41,
+                author: {
+                    name: quoter.displayName,
+                    icon_url: quoter.avatarURL({ forceStatic: true }) ?? undefined,
+                },
+                title: `${quoter.displayName} der Lellek hat gerade versucht sich, selbst zu quoten. Was für ein Opfer!`,
+                description: `${message.cleanContent}\n\n(${hyperlink("link", message.url)})`,
+            },
+        ],
+        allowedMentions: {
+            users: [quoter.id],
+        },
+    };
+}
diff --git a/src/service/quote.ts b/src/service/quote.ts
@@ -0,0 +1,16 @@
+import type { Message } from "discord.js";
+
+import * as quoteStorage from "#storage/quote.ts";
+
+export async function addQuoteIfNotPresent(message: Message<true>): Promise<boolean> {
+    return await quoteStorage.addQuoteIfNotPresent({
+        guildId: message.guildId,
+        channelId: message.channelId,
+        messageId: message.id,
+        authorId: message.author.id,
+    });
+}
+
+export async function isMessageAlreadyQuoted(message: Message<true>): Promise<boolean> {
+    return await quoteStorage.isMessageAlreadyQuoted(message.id);
+}
diff --git a/src/storage/db/model.ts b/src/storage/db/model.ts
@@ -40,6 +40,7 @@ export interface Database {
     polls: PollsTable;
     pollOptions: PollOptionsTable;
     pollAnswers: PollAnswersTable;
+    quotedMessages: QuotedMessagesTable;
 }
 
 export type OneBasedMonth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
@@ -449,3 +450,14 @@ export interface PollAnswersTable extends AuditedTable {
     optionId: PollOptionId;
     userId: Snowflake;
 }
+
+export type QuotedMessagesId = number;
+export type QuotedMessage = Selectable<QuotedMessagesTable>;
+export interface QuotedMessagesTable extends AuditedTable {
+    id: GeneratedAlways<QuotedMessagesId>;
+
+    guildId: Snowflake;
+    channelId: Snowflake;
+    messageId: Snowflake;
+    authorId: Snowflake;
+}
diff --git a/src/storage/migrations/24-quotes-in-db.ts b/src/storage/migrations/24-quotes-in-db.ts
@@ -0,0 +1,41 @@
+import { sql, type Kysely } from "kysely";
+
+export async function up(db: Kysely<any>) {
+    await db.schema
+        .createTable("quotedMessages")
+        .addColumn("id", "integer", c => c.primaryKey().autoIncrement())
+        .addColumn("guildId", "text", c => c.notNull())
+        .addColumn("channelId", "text", c => c.notNull())
+        .addColumn("messageId", "text", c => c.notNull())
+        .addColumn("authorId", "text", c => c.notNull())
+        .addColumn("createdAt", "timestamp", c => c.notNull().defaultTo(sql`current_timestamp`))
+        .addColumn("updatedAt", "timestamp", c => c.notNull().defaultTo(sql`current_timestamp`))
+        .execute();
+
+    await db.schema
+        .createIndex("quotedMessages_messageId")
+        .on("quotedMessages")
+        .column("messageId")
+        .unique()
+        .execute();
+
+    await createUpdatedAtTrigger(db, "quotedMessages");
+}
+
+function createUpdatedAtTrigger(db: Kysely<any>, tableName: string) {
+    return sql
+        .raw(`
+    create trigger ${tableName}_updatedAt
+    after update on ${tableName} for each row
+    begin
+        update ${tableName}
+        set updatedAt = current_timestamp
+        where id = old.id;
+    end;
+    `)
+        .execute(db);
+}
+
+export async function down(_db: Kysely<any>) {
+    throw new Error("Not supported lol");
+}
diff --git a/src/storage/quote.ts b/src/storage/quote.ts
@@ -0,0 +1,31 @@
+import type { Snowflake } from "discord.js";
+import { sql, type Insertable } from "kysely";
+
+import type { QuotedMessagesTable } from "#storage/db/model.ts";
+
+import db from "#db";
+
+/**
+ * @returns `true` if it was added. `false` if it was already present.
+ */
+export async function addQuoteIfNotPresent(
+    message: Insertable<QuotedMessagesTable>,
+    ctx = db(),
+): Promise<boolean> {
+    const res = await ctx
+        .insertInto("quotedMessages")
+        .values(message)
+        .onConflict(c => c.column("messageId").doNothing())
+        .returning(sql`1`.as("inserted"))
+        .executeTakeFirst();
+    return !!res?.inserted;
+}
+
+export async function isMessageAlreadyQuoted(messageId: Snowflake, ctx = db()): Promise<boolean> {
+    const message = await ctx
+        .selectFrom("quotedMessages")
+        .where("messageId", "=", messageId)
+        .select("id")
+        .executeTakeFirst();
+    return !!message?.id;
+}
