How to split my chat commands into differents files? - node.js

Question

I'm creating a basic nodejs based chatbot for discord using discordjs.
In my main script, when a 'message' event is sent, the bot checks if the message match with a specific command and, in this case call it. The functions corresponding to these commands are in methods in a "TextCommand" class, inported in the main script, but the TextCommand file is getting too big I think...
I tried to split each command in one file and export it, but I can't import it as methods into TextCommand class.
index.js
const TextCommand = require('./src/commands.js');
client.on('message', (msg) => {
if (!msg.author.bot) {
let command;
let reg;
let prefix;
if (msg.guild != undefined){ // Guild commands
db.query(`SELECT prefix FROM guilds WHERE discord_id=${msg.guild.id};`, (err, result) => {
if (err) throw err;
prefix = result[0].prefix
command = new TextCommand(prefix, msg)
reg = new RegExp('^' + prefix, 'i')
if (msg.content.startsWith(prefix + 'help')) {
command.help();
} else if (msg.content.startsWith(prefix + 'ping')) {
command.ping();
} else if (msg.content.startsWith(prefix + 'search')) {
command.search();
TextCommand file
module.exports = class TextCommand {
constructor(prefix, msg){
this.message = msg;
this.prefix = prefix;
}
ping(){
this.message.channel.send('pong !');
}
search(){
let search = this.message.content.slice(this.prefix.length + 'search '.length).replace(/ /g, '+');
this.message.channel.send(`http://google.com/search?q=${search}`);
}
I do not understand how to use class extands... but maybe it's a part of the solution, I would include my functions into TextCommands just wrinting them somewhere else (and export it)

Answer 1

Instead of using a class to hold every command you own, try exporting commands.
For instance, in the ready event, you'll want to search the commands folder for command files, which may follow the format of <command name>.js, so a command !foo would be foo.js in the folder commands.
To find all the files in the commands folder:
const { promisify } = require('util');
const readdir = promisify(require('fs').readdir);
client.commands = new Map();
client.on('ready', async () => {
readdir('./commands/', (error, files) => {
if (error) throw error;
files.forEach(file => {
if (!file.endsWith('.js')) return; // make sure the file is what you are looking for
try {
const properties = require(`./commands/${file}`);
client.commands.set(properties.help.name, properties);
} catch (err) {
throw err;
}
});
}
});
This basically defines a Map, extended from the client object called client.commands. This map will contain the command properties, which is used to run the command later. The readdir reads the directory of ./commands/ for any file (using the module fs), and tries to filter them so they are only javascript files (ending with .js), and then adds the commands to the map with its properties.
Later, on the message event, you'll want to test to see if the message content is the command that you have coded:
client.on('message', async (message) => {
if (!message.guild) return; // exit if the message does not have a guild
if (message.author.bot) return; // exit if the message author is a bot
// ... your database code to get the prefix ...
const args = message.content.slice(prefix.length).trim().split(/ +/g).call(Function.prototype.call, String.prototype.trim);
const command = args.shift().toLowerCase();
const cmd = client.commands.get(command);
if (!cmd) return; // the message is not a command we know of
cmd.run(client, message, args); // run the command with client object, message object and args array
});
This code does the basic checks, to make sure the bot is only responding to a user in a guild channel (you may also want to check if the message is from Discord: message.system).
After, it'll separate the content after the prefix into an array, splitting on a space, and then trimming every element of leading and trailing white space.
It'll then assign the first element of the args array to the constant command, to then be checked if that command exists in our map.
If it does, it'll run the command (apart of the module.exports), passing along the client object, message object, and the arguments array.
Finally, in a command file, such as foo.js, you'll need to have some important code to make sure the bot registers said the file is a command we want to run. This is:
module.exports.run = async (client, message, args) => {
// ... command logic
message.channel.send('Hello!');
};
module.exports.help = {
name: 'foo'
};
This is the basic layout of the command file the system is able to read. The first line exports the run process of the command, which is an async function. It also exports the help object, which includes the name of the command. It's best that this is the same as the file name since this name is what the command is responding to.
In my opinion, this is a better method than creating the class holding all the commands, but I'll keep an open mind!