Update to DJS v13, slash commands

.env.example

@@ -1,11 +1,13 @@
 WEB_IP=
 WEB_PORT=
+WEB_HOST=
 
 DISCORD_TOKEN=
+DISCORD_OWNER_ID=
+DISCORD_OWNER_SERVER=
 DISCORD_CLIENT_ID=
 DISCORD_CLIENT_SECRET=
 DISCORD_CHANNEL_LOGGING=
-DISCORD_PREFIX=
 
 GITHUB_TOKEN=
 BDPW_KEY=

.gitignore

@@ -1,6 +1,8 @@
 .DS_Store
 node_modules
-yarn.lock
 .env
 .vscode
 db/*.sqlite
+
+yalc.lock
+.yalc

README.md

@@ -11,7 +11,7 @@ Join our Discord server at https://discord.gg/HHqndMG
 
 ### Commands
 
-Prefixes are `G! ` (with space), custom prefix set up, or mention the bot.
+You can use the following commands through Discord Slash Commands.
 
 __**Util**__:
   - `help` - a help command... yeah :P

lib/Discord/Client.js

@@ -2,7 +2,11 @@ const Discord = require('discord.js');
 const DiscordClient = Discord.Client;
 const fs = require('fs');
 const Log = require('../Util/Log');
-const Guild = require('../Models/Guild');
+
+const { REST } = require('@discordjs/rest');
+const { Routes } = require('discord-api-types/v10');
+
+const rest = new REST({ version: '10' }).setToken(process.env.DISCORD_TOKEN);
 
 /**
  * @typedef {external:ClientOptions} ClientOptions
@@ -72,6 +76,7 @@ class Client extends DiscordClient {
           this.addCommand(require(`./Commands/${f}`), f);
         } catch (error) {
           this.emit('error', `Command | ${f}`, error);
+          Log.error(error);
         }
       });
       return this;
@@ -177,50 +182,42 @@ class Client extends DiscordClient {
    * @param {Message} msg
    * @return {Client}
    */
-  async runCommand(msg) {
-    if (msg.author.equals(this.user) || msg.author.bot) return;
-    const serverConf = msg.guild && (await Guild.find(msg.guild.id));
-
-    if (
-      !msg.mentions.has(this.user)
-    )
-      return;
+  async runCommand(interaction) {
+    if (!interaction.isCommand()) return;
 
-    const content = this.getMsgContent(msg);
-    const command = content.split(' ')[0].toLowerCase();
-    const args = content.split(' ').slice(1);
-
-    const middleware = this.middleware
-      .array()
-      .sort((a, b) => b.priority - a.priority);
+    const middleware = Array.from(this.middleware.values()).sort(
+      (a, b) => b.priority - a.priority
+    );
     let i = 0;
 
-    const handleErr = (err, currentMiddleware) =>
-      middleware[middleware.length - 1].run(
-        msg,
-        args,
+    const handleErr = (err, currentMiddleware) => {
+      Log.error(err);
+
+      return middleware[middleware.length - 1].run(
+        interaction,
         next,
         currentMiddleware,
         err
       );
+    };
 
     const next = (err) => {
       const currentMiddleware = middleware[i] || middleware[i - 1];
       const nextMiddleware = middleware[i++];
       if (err) return handleErr(err, currentMiddleware);
       if (nextMiddleware) {
         try {
-          const thisMiddleware = nextMiddleware.run(msg, args, next, command);
+          const thisMiddleware = nextMiddleware.run(interaction, next);
           if (
-            thisMiddleware.catch &&
+            thisMiddleware?.catch &&
             typeof thisMiddleware.catch === 'function'
           ) {
             thisMiddleware.catch((e) =>
               handleErr(e, nextMiddleware || currentMiddleware)
             );
           }
         } catch (e) {
-          handleErr(err, nextMiddleware || currentMiddleware);
+          handleErr(e, nextMiddleware || currentMiddleware);
         }
       }
     };
@@ -230,28 +227,40 @@ class Client extends DiscordClient {
     return this;
   }
 
-  commandError(msg, cmd, err) {
+  async runCommandMessage(msg) {
+    if (msg.author?.id !== this.config.owner) return;
+
+    if (!msg.mentions.has(this.user)) return;
+
+    const content = this.getMsgContent(msg);
+    const command = content.split(' ')[0].toLowerCase();
+    const args = content.split(' ').slice(1);
+
+    const cmd =
+      this.commands.get(command) ||
+      this.commands.get(this.aliases.get(command));
+
+    if (!cmd?.conf?.msgTrigger) return;
+
+    try {
+      let commandRun = cmd.run(msg, args);
+      if (commandRun && commandRun.catch) {
+        commandRun.catch((e) => cmd.commandError(msg, e));
+      }
+    } catch (e) {
+      cmd.commandError(msg, e);
+    }
+  }
+
+  commandError(interaction, cmd, err) {
     this.emit('error', err);
-    return msg.channel
-      .send([
+    return interaction.reply(
+      [
         `❌ An unexpected error occurred when trying to run command \`${cmd.help.name}\``,
         `\`${err}\``,
-      ])
-      .catch(() => {
-        if (err && typeof err === 'object' && err.response)
-          err = err.response
-            ? err.response.body || err.response.text
-            : err.stack;
-        if (err && typeof err === 'object' && err.content)
-          err = `Discord - ${err.content ? err.content[0] : err.message}`;
-        if (err && typeof err === 'object' && err.code && err.message)
-          err = err.message;
-
-        msg.author.send([
-          `❌ An unexpected error occurred when trying to run command \`${cmd.help.name}\` in ${msg.channel}`,
-          `\`${err}\``,
-        ]);
-      });
+      ].join('\n'),
+      { ephemeral: true }
+    );
   }
 
   /**
@@ -262,21 +271,20 @@ class Client extends DiscordClient {
   getMsgContent(message) {
     const { content, mentions } = message;
 
-    return (
-      (mentions.users.size &&
-        mentions.users.first().equals(this.user) &&
-        content.split(' ').slice(1).join(' ')) ||
-        content
-    );
+    return content.replace(new RegExp(`^<@!?${this.user.id}>\\s*`), '');
   }
 
-  permissions(msg) {
+  permissions(interaction) {
     /* This function should resolve to an ELEVATION level which
     is then sent to the command handler for verification*/
     let permlvl = 0;
 
-    if (msg.member && msg.member.hasPermission(`ADMINISTRATOR`)) permlvl = 1;
-    if (this.config.owner === msg.author.id) permlvl = 2;
+    if (
+      interaction.memberPermissions &&
+      interaction.memberPermissions.has(Discord.Permissions.FLAGS.ADMINISTRATOR)
+    )
+      permlvl = 1;
+    if (this.config.owner === interaction.user.id) permlvl = 2;
 
     return permlvl;
   }
@@ -307,6 +315,35 @@ class Client extends DiscordClient {
     }
     return embed;
   }
+
+  registerCommands(env = process.env.NODE_ENV) {
+    const commands = this.commands.filter((cmd) => !cmd.conf.msgTrigger);
+    const globalCommands = commands.filter((cmd) => cmd.conf.permLevel !== 2);
+    const ownerCommands = commands.filter((cmd) => cmd.conf.permLevel === 2);
+
+    const isDev = env !== 'production';
+
+    const ownerCommandsRoute = Routes.applicationGuildCommands(
+      String(process.env.DISCORD_CLIENT_ID),
+      process.env.DISCORD_OWNER_SERVER
+    );
+    const globalCommandsRoute = Routes.applicationCommands(
+      String(process.env.DISCORD_CLIENT_ID)
+    );
+
+    Log.verbose(`Registering ${ownerCommands.size} owner commands @ ${ownerCommandsRoute}`);
+    Log.verbose(`Registering ${globalCommands.size} global commands @ ${isDev ? ownerCommandsRoute : globalCommandsRoute}`);
+
+    return Promise.all([
+      rest.put(ownerCommandsRoute, {
+        body: ownerCommands.map((cmd) => cmd.getSlashCommand()),
+      }),
+
+      rest.put(isDev ? ownerCommandsRoute : globalCommandsRoute, {
+        body: globalCommands.map((cmd) => cmd.getSlashCommand()),
+      }),
+    ]);
+  }
 }
 
 module.exports = Client;

lib/Discord/Commands/Announce.js

@@ -10,6 +10,7 @@ class AnnounceCommand extends Command {
     };
     this.setConf({
       permLevel: 2,
+      msgTrigger: true,
     });
   }
   async run(msg, args) {
@@ -19,12 +20,14 @@ class AnnounceCommand extends Command {
       .filter((e, i, o) => o.indexOf(e) === i);
     let messagedOwners = [];
     let message = await msg.channel.send({
-      embed: {
-        title: 'Announce',
-        color: 0xfb5432,
-        description: 'Announcing message....',
-        timestamp: new Date(),
-      },
+      embeds: [
+        {
+          title: 'Announce',
+          color: 0xfb5432,
+          description: 'Announcing message....',
+          timestamp: new Date(),
+        },
+      ],
     });
     for (let owner of owners) {
       if (!owner) return;
@@ -38,7 +41,7 @@ class AnnounceCommand extends Command {
         )
         .setDescription([`\u200B`, announcement, `\u200B`].join('\n'))
         .setTimestamp();
-      await owner.send({ embed });
+      await owner.send({ embeds: [embed] });
     }
     // await message.delete();
     return message.edit({

lib/Discord/Commands/Clean.js

@@ -1,3 +1,4 @@
+const { CommandInteraction } = require('discord.js');
 const Command = require('../Command');
 
 class CleanCommand extends Command {
@@ -6,7 +7,8 @@ class CleanCommand extends Command {
 
     this.props.help = {
       name: 'clean',
-      description: 'clean the messages of the bot found in the number provided',
+      description:
+        'Clean 10 messages (by default) sent by the bot, found in the last 50 messages in the channel.',
       usage: 'clean [number=10]',
       examples: ['clean', 'clean 14'],
     };
@@ -16,22 +18,39 @@ class CleanCommand extends Command {
     });
   }
 
-  run(msg, args) {
-    let messageCount = args[0] && !isNaN(args[0]) ? Number(args[0]) : 10;
-
-    return msg.channel.messages
-      .fetch({
-        limit: 50,
-      })
-      .then((messages) => {
-        let msgs = messages.filter((e) => e.author.equals(this.bot.user));
-        let i = 1;
-        for (let [, message] of msgs) {
-          if (i > messageCount) break;
-          message.delete();
-          i++;
-        }
-      });
+  getSlashCommand() {
+    return super
+      .getSlashCommand()
+      .addIntegerOption((option) =>
+        option
+          .setName('count')
+          .setDescription('The number of messages to clean.')
+          .setMinValue(1)
+      );
+  }
+
+  /**
+   *
+   * @param {CommandInteraction} interaction
+   */
+  async run(interaction) {
+    const messageCount = interaction.options.getInteger('count') || 10;
+
+    await interaction.deferReply({ ephemeral: true });
+
+    const messages = await interaction.channel.messages.fetch({
+      limit: 50,
+    });
+
+    const msgs = messages.filter((e) => e.author.equals(this.bot.user));
+    let i = 0;
+    for (let [, message] of msgs) {
+      if (i >= messageCount) break;
+      message.delete();
+      i++;
+    }
+
+    await interaction.editReply(`Done. Deleted ${i} messages`);
   }
 }