Different approach for commands order

[jose-devcode]

Hello everybody.
I was recently reading the https://discordjs.guide/ and the command organization system seemed a little "overcoded" for me. And i want to share an approach i tried and seem to work.

In the current guide the setup performs a search + evaluation for each file inside the /utility folder in which using fs and path modules with a loop we do this:

folder structure:

commands/
├── utility
           ├── ping.js
           ├── server.js
           └── user.js

const fs = require('node:fs')
const path = require('node:path')
const foldersPath = path.join(__dirname, 'commands')
const commandFolders = fs.readdirSync(foldersPath)

for (const folder of commandFolders) {
  // Grab all the command files from the commands directory you created earlier
  const commandsPath = path.join(foldersPath, folder)
  const commandFiles = fs
    .readdirSync(commandsPath)
    .filter((file) => file.endsWith('.js'))
  // Grab the SlashCommandBuilder#toJSON() output of each command's data for deployment
  for (const file of commandFiles) {
    const filePath = path.join(commandsPath, file)
    const command = require(filePath)
    if ('data' in command && 'execute' in command) {
      commands.push(command.data.toJSON())
    } else {
      console.log(
        `[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`
      )
    }
  }
}

try {
const data = await rest.put(
      Routes.applicationGuildCommands(clientId, guildId),
      { body: commands }
    )
} catch (error) {
cnosole.error(error)
}

basically with this code we sync with the folder, evaluate extension ".js" , evaluate 'data' and 'execute' strings inside files, etc..

My idea is to organize the structure like this.

commands/
├── index.js
├── utility
           ├── ping.js
           ├── server.js
           └── user.js

Then inside index.js

const ping = require('./utility/ping')
const server = require('./utility/server')
const user = require('./utility/user')

module.exports = { ping, server, user }

Then on deploy-command or anywhere else we can have all of our commands required by calling just index.js

e.g. inside deploy-command.js for registering commands.

const candidates = require('./commands')
const commands = Object.values(candidates).map((command) => command.data)
const rest = new REST().setToken(token)
;(async () => {
  try {
    console.log(
      `Started refreshing ${commands.length} application (/) commands.`
    )

    const data = await rest.put(
      Routes.applicationGuildCommands(clientId, guildId),
      { body: commands }
    )

     console.log(
      `Successfully reloaded ${data.length} application (/) commands.`
     )
  } catch (error) {
     And of course, make sure you catch and log any errors!
    console.error(error)
  }
})()

and on the index.js

const commands = require('./commands')
const client = new Client({ intents: [GatewayIntentBits.Guilds] })
client.commands = new Collection()

Object.values(commands).map((command) => {
  client.commands.set(command.data.name, command)
})

client.once(Events.ClientReady, (readyClient) => {
  console.log(`Ready! Logged in as ${readyClient.user.tag}`)
})
...

I hope you find this approach leaner and helpful. Im very brand new to this Discord.js module and appreciate all recommendations and tips.

Cheers!

[sdanialraza]

But then you'd have to add stuff to that index file every time you add a command, and you can absolutely do that for your project, but discord.js just went with you write the loading once and don't have to worry about importing, the new guide that's still in development just uses create-discord-bot, a CLI to generate boilerplate but it also does something similar.

[jose-devcode]

Yes of course is a personal preference to not rely the functionality on file system modules loops but just maintaining the code tight together using indexes. Thanks a lot for replying !

[Qjuh]

Also do note that while your code looks shorter for now it‘ll get longer the more commands you add. While the guide code stays the same, so with more commands the total line count would grow further in your solution. And if you loop over an fs result or hide the looping in an Object.values call doesn’t change that you still loop.