Moved event handlers to seperate files

utils/eventHandler.js

@@ -0,0 +1,9 @@
+const { loadButtonEvents } = require('./eventHandlers/button.js')
+const { loadSlashCommands } = require('./eventHandlers/command.js')
+const { loadContextMenu } = require('./eventHandlers/contextmenu.js')
+const { loadMessageEvents } = require('./eventHandlers/message.js')
+const { loadModalEvents } = require('./eventHandlers/modal.js')
+const { loadReadyEvents } = require('./eventHandlers/ready.js')
+
+
+module.exports = { loadSlashCommands, loadButtonEvents, loadContextMenu, loadMessageEvents, loadModalEvents, loadReadyEvents }

utils/eventHandlers/button.js

@@ -0,0 +1,46 @@
+const { Events } = require('discord.js')
+const path = require('path');
+const fs = require('fs');
+
+/** @param { import('discord.js').Client } client */
+
+function loadButtonEvents(client) {
+    const btnPath = path.join(__dirname, '..', '..', 'events', 'buttons');
+    const btnFiles = fs.readdirSync(btnPath).filter(file => file.endsWith('.js'));
+
+    for (const file of btnFiles) {
+
+        const filePath = path.join(btnPath, file);
+        const btn = require(filePath);
+
+        if ('name' in btn && 'execute' in btn && btn.type === 'button') {
+            client.events.set(btn.name, btn);
+        } else {
+            console.log(`[WARNING] The button at ${filePath} is missing a required "name", "execute" or "type" property.`);
+        }
+    }
+
+    client.on(Events.InteractionCreate, async event => {
+        if (!event.isButton())
+            return;
+
+        const event2 = event.client.events.get(event.customId);
+
+        if (!event2) {
+            console.error(`No event matching ${event.customId} was found.`);
+            return;
+        }
+
+        try {
+            await event2.execute(event);
+        } catch (error) {
+            console.error(error);
+            await event.reply({
+                content: 'There was an error while executing this event!',
+                ephemeral: true
+            })
+        }
+    })
+}
+
+module.exports = { loadButtonEvents }

utils/eventHandlers/command.js

@@ -0,0 +1,63 @@
+const { Events } = require('discord.js')
+const path = require('path');
+const fs = require('fs');
+
+/** @param { import('discord.js').Client } client */
+
+function loadSlashCommands(client) {
+    const cmdPath = path.join(__dirname, '..', '..', 'commands');
+    const cmdFiles = fs.readdirSync(cmdPath).filter(file => file.endsWith('.js'));
+
+    for (const file of cmdFiles) {
+
+        const filePath = path.join(cmdPath, file);
+        const cmd = require(filePath);
+
+        if ('data' in cmd && 'execute' in cmd && cmd.type === 'slash') {
+            client.commands.set(cmd.data.name, cmd);
+        } else {
+            console.log(`[WARNING] The command at ${filePath} is missing a required "data", "execute" or "type" property.`);
+        }
+    }
+
+    //! commands testing
+    const cmdTestPath = path.join(__dirname, '..', '..', 'commands-testing');
+    const cmdTestFiles = fs.readdirSync(cmdTestPath).filter(file => file.endsWith('.js'));
+
+    for (const file of cmdTestFiles) {
+
+        const filePath = path.join(cmdTestPath, file);
+        const cmd = require(filePath);
+
+        if ('data' in cmd && 'execute' in cmd && cmd.type === 'slash') {
+            client.commands.set(cmd.data.name, cmd);
+        } else {
+            console.log(`[WARNING] The command at ${filePath} is missing a required "data", "execute" or "type" property.`);
+        }
+    }
+
+    //! command handler
+    client.on(Events.InteractionCreate, async interaction => {
+        if (!interaction.isChatInputCommand())
+            return;
+
+        const command = interaction.client.commands.get(interaction.commandName);
+
+        if (!command) {
+            console.error(`No command matching ${interaction.commandName} was found.`);
+            return;
+        }
+
+        try {
+            await command.execute(interaction);
+        } catch (error) {
+            console.error(error);
+            await interaction.reply({
+                content: 'There was an error while executing this command!',
+                ephemeral: true
+            })
+        }
+    })
+}
+
+module.exports = { loadSlashCommands }

utils/eventHandlers/contextmenu.js

@@ -0,0 +1,47 @@
+const { Events } = require('discord.js')
+const path = require('path');
+const fs = require('fs');
+
+/** @param { import('discord.js').Client } client */
+
+function loadContextMenu(client) {
+    const contextMenuPath = path.join(__dirname, '..', '..', 'commands-contextmenu');
+    const contextMenuFiles = fs.readdirSync(contextMenuPath).filter(file => file.endsWith('.js'));
+
+    for (const file of contextMenuFiles) {
+
+        const filePath = path.join(contextMenuPath, file);
+        const cmd = require(filePath);
+
+        if ('data' in cmd && 'execute' in cmd && cmd.type === 'contextmenu') {
+            client.commands.set(cmd.data.name, cmd);
+        } else {
+            console.log(`[WARNING] The command at ${filePath} is missing a required "data", "execute" or "type" property.`);
+        }
+    }
+
+    //! context menu command handler
+    client.on(Events.InteractionCreate, async interaction => {
+        if (!interaction.isContextMenuCommand())
+            return;
+
+        const command = interaction.client.commands.get(interaction.commandName);
+
+        if (!command) {
+            console.error(`No command matching ${interaction.commandName} was found.`);
+            return;
+        }
+
+        try {
+            await command.execute(interaction);
+        } catch (error) {
+            console.error(error);
+            await interaction.reply({
+                content: 'There was an error while executing this command!',
+                ephemeral: true
+            })
+        }
+    })
+}
+
+module.exports = { loadContextMenu }

utils/eventHandlers/message.js

@@ -0,0 +1,24 @@
+const { Events } = require('discord.js')
+const path = require('path');
+const fs = require('fs');
+
+/** @param { import('discord.js').Client } client */
+
+function loadMessageEvents(client) {
+    const messagePath = path.join(__dirname, '..', '..', 'events', 'messages');
+    const messageFiles = fs.readdirSync(messagePath).filter(file => file.endsWith('.js'));
+
+    for (const file of messageFiles) {
+
+        const filePath = path.join(messagePath, file);
+        const message = require(filePath);
+
+        if (message.type === 'message') {
+            client.on(Events.MessageCreate, message.execute);
+        } else {
+            console.log(`[WARNING] The message at ${filePath} is missing a required "type" property.`);
+        }
+    }
+}
+
+module.exports = { loadMessageEvents }

utils/eventHandlers/modal.js

@@ -0,0 +1,24 @@
+const { Events } = require('discord.js')
+const path = require('path');
+const fs = require('fs');
+
+/** @param { import('discord.js').Client } client */
+
+function loadModalEvents(client) {
+    const modalPath = path.join(__dirname, '..', '..', 'events', 'modals');
+    const modalFiles = fs.readdirSync(modalPath).filter(file => file.endsWith('.js'));
+
+    for (const file of modalFiles) {
+
+        const filePath = path.join(modalPath, file);
+        const modal = require(filePath);
+
+        if ('name' in modal && 'execute' in modal && modal.type === 'modal') {
+            client.on(Events.InteractionCreate, modal.execute);
+        } else {
+            console.log(`[WARNING] The modal at ${filePath} is missing a required "name", "execute" or "type" property.`);
+        }
+    }
+}
+
+module.exports = { loadModalEvents }

utils/eventHandlers/ready.js

@@ -0,0 +1,23 @@
+const { Events } = require('discord.js')
+const path = require('path');
+const fs = require('fs');
+
+/** @param { import('discord.js').Client } client */
+
+function loadReadyEvents(client) {
+    const readyPath = path.join(__dirname, '..', '..', 'events', 'ready')
+    const readyFiles = fs.readdirSync(readyPath).filter(file => file.endsWith('.js'));
+
+    for (const file of readyFiles) {
+        const filePath = path.join(readyPath, file);
+        const ready = require(filePath);
+
+        if ('name' in ready && 'execute' in ready && ready.type === 'ready') {
+            client.on(Events.ClientReady, ready.execute)
+        } else {
+            console.log(`[WARNING] The ready event at ${filePath} is missing a required "name", "execute" or "type" property.`);
+        }
+    }
+}
+
+module.exports = { loadReadyEvents }