Créer un robot Discord avec les Slash Commands

node --version

cd /nomDuDossier

npm install discord.js discord-api-types fs

{
  "name": "example_discord_bot_slash_commands",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "keywords": [
    "discordapp",
    "bot",
    "discordjs"
  ],
  "author": "Thomas Bnt <contact+git@thomasbnt.fr>",
  "license": "GPL-3.0-only",
  "dependencies": {
    "discord-api-types": "^0.37.31",
    "discord.js": "^14.7.1"
  }
}

npm install

/**
 @document   : app.js
 @author     : Thomas Bnt
 @version    : 3.0.0
 @copyright  : 2023, Thomas Bnt
 @license    : GNU General Public License v3.0
 @repository : https://github.com/thomasbnt/Bord-Pi
 @description: Un robot Discord gérant et aidant les utilisateurs pour un serveur.
 */

const fs = require('fs')
const {Client, Collection, GatewayIntentBits, Options} = require('discord.js')

const client = new Client({
  // Les intents dépendra de ce que vous voulez faire avec le robot, 
  // mais n'oubliez pas de les activer dans votre dashboard discord.dev
  // à l'adresse https://discord.com/developers/applications/{ID}/bot, 
  // section "Privileged Gateway Intents"
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages
  ],
})

// Nous créons une collection pour les commandes
client.commands = new Collection()
const commandFiles = fs
  .readdirSync('./commands')
  .filter((file) => file.endsWith('.js'))

for (const file of commandFiles) {
  const command = require(`./commands/${file}`)
  client.commands.set(command.data.name, command)
}

// Les events comme par exemple ready.js (quand le robot s'allume), 
// ou encore messageCreate.js (quand un utilisateur/robot envoie un message)
const eventFiles = fs
  .readdirSync('./events')
  .filter((file) => file.endsWith('.js'))

for (const file of eventFiles) {
  const event = require(`./events/${file}`)
  if (event.once) {
    client.once(event.name, (...args) => event.execute(...args, client))
  } else {
    client.on(event.name, (...args) => event.execute(...args, client))
  }
}

// L'event interactionCreate directement ici, car c'est en soit le coeur du robot.
client.on('interactionCreate', async (interaction) => {
  if (!interaction.isCommand()) return
  const command = client.commands.get(interaction.commandName)
  if (!command) return

  // On log quand un utilisateur fait une commande
  try {
    await console.log(
      `/${interaction.commandName} — Par ${interaction.user.username}`
    )
    await command.execute(interaction, client)
    // Mais s'il y a une erreur, 
    // alors on log ça et on renvoi un message d'erreur seulement à la personne (ephemeral: true)
  } catch (error) {
    console.error(error)
    return interaction.reply({
      content: "Une erreur s'est produite lors de l'exécution de cette commande !",
      ephemeral: true,
      fetchReply: true
    })
  }
})

// Le token de votre robot à insérer
client.login("JOLI TOKEN A NE JAMAIS DIVULGER")

const Discord = require('discord.js')
module.exports = async (client, commands, options = {debug: false, guildId: null}) => {
  const log = (message) => options.debug && console.log(message)

  const ready = client.readyAt
    ? await Promise.resolve()
    : new Promise((resolve) => client.once('ready', resolve))
  await ready
  const currentCommands = await client.application.commands.fetch(
    options.guildId && {guildId: options.guildId}
  )

  log(`Synchronizing commands...`)
  log(`Currently ${currentCommands.size} commands.`)

  const newCommands = commands.filter(
    (command) => !currentCommands.some((c) => c.name === command.name)
  )
  for (const newCommand of newCommands) {
    await client.application.commands.create(newCommand, options.guildId)
  }

  log(`Created ${newCommands.length} commands!`)

  const deletedCommands = currentCommands
    .filter((command) => !commands.some((c) => c.name === command.name))
    .toJSON()
  for (const deletedCommand of deletedCommands) {
    await deletedCommand.delete()
  }

  log(`Deleted ${deletedCommands.length} commands!`)

  const updatedCommands = commands.filter((command) =>
    currentCommands.some((c) => c.name === command.name)
  )
  let updatedCommandCount = 0
  for (const updatedCommand of updatedCommands) {
    const newCommand = updatedCommand
    const previousCommand = currentCommands.find(
      (c) => c.name === updatedCommand.name
    )
    let modified = false
    if (previousCommand.description !== newCommand.description) modified = true
    if (
      !Discord.ApplicationCommand.optionsEqual(
        previousCommand.options ?? [],
        newCommand.options ?? []
      )
    )
      modified = true
    if (modified) {
      await previousCommand.edit(newCommand)
      updatedCommandCount++
    }
  }

  log(`Updated ${updatedCommandCount} commands!`)

  log(`Commands synchronized!`)

  return {
    currentCommandCount: currentCommands.size,
    newCommandCount: newCommands.length,
    deletedCommandCount: deletedCommands.length,
    updatedCommandCount
  }
}

const synchronizeSlashCommands = require('../modules/sync_commands')
const {ActivityType} = require('discord.js')
module.exports = {
  name: 'ready',
  async execute(client) {
    console.log(`Connecté en tant que ${client.user.username}`)
    client.user.setActivity(`/bord`, {type: ActivityType.Watching})

    // C'est à ce moment-là que la synchronisation des Slash Commands se lance
    await synchronizeSlashCommands(client,
      client.commands.map((c) => c.data),
      {
        // Les paramètres à modifier pour la synchronisation
        debug: true,
        // Si vous définissez un ID de serveur, alors ça ne sera QUE pour le serveur ciblé.
        // Si dans le cas contraire vous ne mettez pas guildID, ça sera en GLOBAL,
        // Donc sur tout les serveurs.
        guildId: "TonIDDeServeurOuSupprimeCetteLigne"
      }
    )
  }
}

const {EmbedBuilder} = require('discord.js')
module.exports = {
  // "data" est le corps de la commande,
  // c'est ce qu'on va retrouver quand on va taper /ping
  data: {
    name: 'ping',
    description: 'Obtenir le ping du robot',
    options: []
  },
  // et tout ça, c'est la logique de la commande
  async execute(interaction, client) {
    // Par exemple là on créée un embed avec EmbedBuilder de discord.js
    // On lui ajoute un name et iconURL, et on va par la suite le modifier avec les valeurs.
    const PingBeforeEmbed = new EmbedBuilder().setAuthor({
      name: `L'oiseau va revenir avec le ping du robot...`,
      iconURL: client.user.avatarURL()
    })
    const sent = await interaction.reply({
      embeds: [PingBeforeEmbed],
      fetchReply: true,
      ephemeral: true
    })
    const TotalPing = sent.createdTimestamp - interaction.createdTimestamp
    const PingEmbed = new EmbedBuilder()
      .setAuthor({
        name: `Le ping de ${client.user.username}`,
        iconURL: client.user.avatarURL()
      })
      .addFields(
        {
          name: 'Total du ping',
          value: `${TotalPing}ms`,
          inline: true
        },
        {
          name: 'Websocket',
          value: `${client.ws.ping} ms`,
          inline: true
        }
      )
    await interaction.editReply({
      embeds: [PingEmbed],
      ephemeral: true
    })
  }
}

.
├── app.js
├── commands
│   └── ping.js
├── events
│   └── ready.js
├── modules
│   └── sync_commands.js
└── package.json

client.login("VOTRE TOKEN ICI SANS ESPACE")

node app.js