refactor(events): improve emoji processing and error handling in message events for better maintainability and clarity

feat(events): enhance message reaction handling to support bulk reactions and improve user experience
fix(events): ensure proper handling of guild data retrieval errors and provide fallback mechanisms for missing data

Author: SethCohen

src/events/guildCreate.js

@@ -2,57 +2,58 @@ import { mediaLinks } from '../helpers/constants.js';
 import { insertGuild } from '../helpers/mongodbModel.js';
 import { EmbedBuilder, ChannelType, PermissionsBitField, Events } from 'discord.js';
 
-const postToAnyChannel = async (guild, embed) => {
+const sendEmbedToChannel = async (channel, embed) => {
   try {
-    const channels = await guild.channels.cache;
-    const foundChannel = await channels.find(
-      (channel) =>
-        channel.type === ChannelType.GuildText &&
-        channel.permissionsFor(guild.members.me).has(PermissionsBitField.Flags.SendMessages) &&
-        channel.permissionsFor(guild.members.me).has(PermissionsBitField.Flags.ViewChannel),
-    );
-    if (foundChannel) {
-      foundChannel.send({ embeds: [embed] });
-    }
-    else {
-      console.error('No channel access found. Welcome message not sent.');
+    await channel.send({ embeds: [embed] });
+  } catch (error) {
+    console.error(`Failed to send embed to ${channel.name}: ${error.message}`);
+  }
+};
+
+const findFirstAccessibleTextChannel = (guild) => {
+  return guild.channels.cache.find((channel) =>
+    channel.type === ChannelType.GuildText &&
+    channel.permissionsFor(guild.members.me)?.has([
+      PermissionsBitField.Flags.ViewChannel,
+      PermissionsBitField.Flags.SendMessages,
+    ])
+  );
+};
+
+const postWelcomeEmbed = async (guild, embed) => {
+  const publicChannel = guild.publicUpdatesChannel;
+  if (publicChannel) {
+    try {
+      await sendEmbedToChannel(publicChannel, embed);
+      return;
+    } catch (error) {
+      console.error(
+        `Can't post to public updates channel in ${guild.name}: ${error.message}\nFalling back to another channel.`
+      );
     }
   }
-  catch (e) {
-    console.error(e);
+
+  const fallbackChannel = findFirstAccessibleTextChannel(guild);
+  if (fallbackChannel) {
+    await sendEmbedToChannel(fallbackChannel, embed);
+  } else {
+    console.error(`No accessible text channels found in ${guild.name}. Welcome message not sent.`);
   }
 };
 
 export default {
   name: Events.GuildCreate,
   async execute(guild) {
-    // console.log(`guildCreate: ${guild.name}, ${guild.id}.`);
-
-    const guildsCount = guild.client.guilds.cache.size;
-    console.log(`Guild Created. Current Count: ${guildsCount}`);
+    console.log(`Guild Created (${guild.name}). Current Server Count: ${guild.client.guilds.cache.size}`);
 
-    // await createDatabase(guild.id);
     await insertGuild(guild.client.db, guild);
 
-    // Send greeting
     const embed = new EmbedBuilder()
       .setTitle('Hello! Nice to meet you!')
       .setDescription(
-        mediaLinks +
-        '\n\nThanks For Adding Me To Your Server!\nDon\'t worry, everything has been setup for you.\nJust make sure I have **View** access to all the channels otherwise I won\'t be able to track emoji usage.\nDo `/help` for a list of commands and if you have any issues or questions, feel free to join our support server.\n\nThanks again and have a nice day! 🙂',
+        `${mediaLinks}\n\nThanks For Adding Me To Your Server!\nDon't worry, everything has been setup for you.\nJust make sure I have **View** access to all the channels otherwise I won't be able to track emoji usage.\nUse \`/help\` for a list of commands. If you have any issues, feel free to join our support server.\n\nThanks again and have a nice day! 🙂`
       );
 
-    const publicUpdatesChannel = await guild.publicUpdatesChannel;
-    if (publicUpdatesChannel) {
-      publicUpdatesChannel.send({ embeds: [embed] }).catch(async (error) => {
-        console.error(
-          `Can't post to public updates channel in ${guild.name}: ${error.message}\nDefaulting to first available text channel.`,
-        );
-        await postToAnyChannel(guild, embed);
-      });
-    }
-    else {
-      await postToAnyChannel(guild, embed);
-    }
+    await postWelcomeEmbed(guild, embed);
   },
 };

src/events/interactionCreate.js

@@ -3,29 +3,33 @@ import { sendErrorFeedback } from '../helpers/utilities.js';
 
 export default {
   name: Events.InteractionCreate,
-  execute(interaction) {
-    // console.log(`${interaction.user.tag} in #${interaction.channel.name} triggered an interaction.`);
+  async execute(interaction) {
     if (!interaction.isCommand()) return;
 
     const command = interaction.client.commands.get(interaction.commandName);
-
     if (!command) return;
 
     try {
-      command.execute(interaction);
-    }
-    catch (error) {
-      switch (error.message) {
-        case 'Cannot read properties of null (reading \'1\')':
-          interaction.reply({
-            embeds: [sendErrorFeedback(interaction.commandName, 'No emoji found in `emoji`.')],
-          });
-          break;
-        default:
-          console.error(`interactionCreate error\n${interaction.commandName}\n${error}`);
-          return interaction.reply({
-            embeds: [sendErrorFeedback(interaction.commandName)],
-          });
+      await command.execute(interaction);
+    } catch (error) {
+      console.error(`Error running command "${interaction.commandName}":\n`, error);
+
+      const errorMessage = 
+        error.message === "Cannot read properties of null (reading '1')" 
+          ? 'No emoji found in `emoji`.'
+          : undefined;
+
+      // Always check if a reply was already sent
+      if (interaction.replied || interaction.deferred) {
+        await interaction.followUp({
+          embeds: [sendErrorFeedback(interaction.commandName, errorMessage)],
+          ephemeral: true,
+        });
+      } else {
+        await interaction.reply({
+          embeds: [sendErrorFeedback(interaction.commandName, errorMessage)],
+          ephemeral: true,
+        });
       }
     }
   },

src/events/messageCreate.js

@@ -1,55 +1,61 @@
 import { Events } from 'discord.js';
 import { getGuildInfo, addEmojiRecords, insertGuild } from '../helpers/mongodbModel.js';
-import {
-  createEmojiRecord,
-  extractEmojis,
-  getUserOpt,
-  shouldProcessMessage,
-} from '../helpers/utilities.js';
-
-async function processEmojis(message) {
+import { createEmojiRecord, extractEmojis, getUserOpt, shouldProcessMessage } from '../helpers/utilities.js';
+
+const processEmojis = async (message) => {
   const emojis = extractEmojis(message);
+  if (!emojis.length) return false;
+
 
-  const emojiRecords = [];
-  for (const emoji of emojis) {
-    const guildEmoji = await message.guild.emojis.fetch(emoji[3]).catch(() => null);
-    if (!guildEmoji) continue;
-    const emojiRecord = createEmojiRecord(
-      message.guildId,
-      message.id,
-      guildEmoji.id,
-      message.author.id,
-      message.createdAt,
-      'message'
-    );
-
-    emojiRecords.push(emojiRecord);
+  // Batch-fetch all server emojis once
+  const emojiCache = await message.guild.emojis.fetch().catch(() => null);
+  if (!emojiCache) {
+    console.warn(`Could not fetch emojis for guild ${message.guild?.name}.`);
+    return false;
   }
 
-  if (emojiRecords.length === 0) return false;
+  const emojiRecords = emojis
+    .map((emoji) => {
+      const emojiId = emoji[3];
+      const guildEmoji = emojiCache.get(emojiId);
+      if (!guildEmoji) return null;
+
+      return createEmojiRecord(
+        message.guildId,
+        message.id,
+        guildEmoji.id,
+        message.author.id,
+        message.createdAt,
+        'message'
+      );
+    })
+    .filter(Boolean);
+
+  if (!emojiRecords.length) return false;
 
   await addEmojiRecords(message.client.db, emojiRecords);
-}
+};
 
-async function processMessageCreate(message) {
+const processMessageCreate = async (message) => {
   const guildInfo = await getGuildInfo(message.client.db, message.guild);
   const userOpt = await getUserOpt(guildInfo, message.author.id);
 
   if (shouldProcessMessage(message, guildInfo, userOpt)) {
-    await processEmojis(message, guildInfo);
+    await processEmojis(message);
   }
-}
+};
 
 export default {
   name: Events.MessageCreate,
   async execute(message) {
     try {
       await processMessageCreate(message);
     } catch (error) {
-      if (error.message == `Cannot read properties of null (reading 'usersOpt')`) {
+      if (error.message === `Cannot read properties of null (reading 'usersOpt')`) {
+        console.warn(`Guild data missing for ${message.guild?.name} (${message.guildId}). Reinserting...`);
         await insertGuild(message.client.db, message.guild);
       } else {
-        console.error(Events.MessageCreate, error);
+        console.error(`Error in ${Events.MessageCreate}:`, error);
       }
     }
   },

src/events/messageDelete.js

@@ -8,77 +8,84 @@ import {
   shouldProcessReaction,
 } from '../helpers/utilities.js';
 
-async function processEmojis(message, guildInfo) {
+const processEmojis = async (message, guildInfo) => {
   if (isMessagePartial(message)) return false;
+
   const emojis = extractEmojis(message);
+  if (!emojis.length) return false;
+
+  const users = new Set();
+  const tags = new Set();
   let guildEmojiDetected = false;
 
-  for (const emoji of emojis) {
-    const guildEmoji = await message.guild.emojis.fetch(emoji[3]).catch(() => null);
-    if (!guildEmoji) continue;
-    guildEmojiDetected = true;
-    break;
+  // Check if message itself used guild emojis
+  for (const [, , , emojiId] of emojis) {
+    const guildEmoji = await message.guild.emojis.fetch(emojiId).catch(() => null);
+    if (guildEmoji) {
+      guildEmojiDetected = true;
+      break;
+    }
   }
 
-  const users = [];
-  const tags = [];
-
+  // Process message author
   const messageUserOpt = await getUserOpt(guildInfo, message.author.id);
   if (shouldProcessMessage(message, guildInfo, messageUserOpt)) {
-    users.push(message.author.id);
-    tags.push('message');
+    users.add(message.author.id);
+    tags.add('message');
   }
 
-  const guildEmojiMessageReactions = message.reactions.cache.filter((reaction) =>
+  // Process message reactions
+  const guildReactions = message.reactions.cache.filter((reaction) =>
     message.guild.emojis.resolve(reaction.emoji)
   );
 
-  if (guildEmojiMessageReactions.size > 0) {
+  if (guildReactions.size > 0) {
     guildEmojiDetected = true;
 
-    if (shouldProcessReaction(guildEmojiMessageReactions.first(), guildInfo, messageUserOpt)) {
-      users.push(message.author.id);
-      tags.push('received-reaction');
+    if (shouldProcessReaction(guildReactions.first(), guildInfo, messageUserOpt)) {
+      users.add(message.author.id);
+      tags.add('received-reaction');
     }
 
-    for (const messageReaction of guildEmojiMessageReactions.values()) {
-      for (const reactionUser of messageReaction.users.cache.values()) {
-        const reactionUserOpt = await getUserOpt(guildInfo, reactionUser.id);
-        if (shouldProcessReaction(messageReaction, guildInfo, reactionUserOpt)) {
-          users.push(reactionUser.id);
-          tags.push('sent-reaction');
+    for (const reaction of guildReactions.values()) {
+      for (const user of reaction.users.cache.values()) {
+        const reactionUserOpt = await getUserOpt(guildInfo, user.id);
+        if (shouldProcessReaction(reaction, guildInfo, reactionUserOpt)) {
+          users.add(user.id);
+          tags.add('sent-reaction');
         }
       }
     }
   }
 
+  if (!guildEmojiDetected) return false;
+
   const filter = {
     guild: message.guildId,
     message: message.id,
-    user: { $in: users },
-    tag: { $in: tags },
+    user: { $in: [...users] },
+    tag: { $in: [...tags] },
   };
 
-  if (!guildEmojiDetected) return false;
-
   await deleteEmojiRecords(message.client.db, filter);
-}
+};
 
-async function processMessageDelete(message) {
+const processMessageDelete = async (message) => {
   const guildInfo = await getGuildInfo(message.client.db, message.guild);
   await processEmojis(message, guildInfo);
-}
+};
 
 export default {
   name: Events.MessageDelete,
   async execute(message) {
     try {
       await processMessageDelete(message);
     } catch (error) {
-      if (error.message == `Cannot read properties of null (reading 'usersOpt')`) {
+      if (error.message === `Cannot read properties of null (reading 'usersOpt')`) {
+        console.warn(`Guild data missing for ${message.guild?.name} (${message.guildId}). Reinserting...`);
         await insertGuild(message.client.db, message.guild);
       } else {
-        console.error(Events.MessageDelete, error);
+        console.error(`Error in ${Events.MessageDelete}:`, error);
       }
     }
   },

src/events/messageDeleteBulk.js

@@ -2,22 +2,23 @@ import { Events } from 'discord.js';
 import { processMessageDelete } from './messageDelete.js';
 import { insertGuild } from '../helpers/mongodbModel.js';
 
-async function processMessageDeleteBulk(messages) {
+const processMessageDeleteBulk = async (messages) => {
   for (const message of messages.values()) {
     await processMessageDelete(message);
   }
-}
+};
 
 export default {
   name: Events.MessageBulkDelete,
   async execute(messages, channel) {
     try {
       await processMessageDeleteBulk(messages);
     } catch (error) {
-      if (error.message == `Cannot read properties of null (reading 'usersOpt')`) {
+      if (error.message === `Cannot read properties of null (reading 'usersOpt')`) {
+        console.warn(`Guild data missing for ${channel.guild?.name} (${channel.guildId}). Reinserting...`);
         await insertGuild(channel.client.db, channel.guild);
       } else {
-        console.error(Events.MessageBulkDelete, error);
+        console.error(`Error in ${Events.MessageBulkDelete}:`, error);
       }
     }
   },