Glyria LogoGlyria.JS
Exemples

Commandes

Créez et organisez des commandes slash avec glyria.js.

Commande de base

Créez un fichier dans src/commands/ — il sera automatiquement chargé et enregistré sur Discord.

// src/commands/ping.ts
export default GlyriaCommand()
  .setName("ping")
  .setDescription("Pong!")
  .execute(async (ctx) => {
    await ctx.reply({ content: "Pong!" })
  })
GlyriaCommand est disponible globalement — aucun import nécessaire. \

Commande avec options

// src/commands/hello.ts
export default GlyriaCommand()
  .setName("hello")
  .setDescription("Dire bonjour à quelqu'un")
  .addUserOption((option) =>
    option
      .setName("user")
      .setDescription("L'utilisateur à saluer")
      .setRequired(true)
  )
  .addStringOption((option) =>
    option
      .setName("message")
      .setDescription("Un message personnalisé")
      .setRequired(false)
  )
  .execute(async (ctx) => {
    await ctx.reply({ content: "Bonjour !" })
  })

Types d'options disponibles

MéthodeType Discord
addStringOptionString
addIntegerOptionInteger
addNumberOptionNumber
addBooleanOptionBoolean
addUserOptionUser
addRoleOptionRole

Permissions

Restreignez l'utilisation d'une commande aux membres possédant des permissions Discord spécifiques avec .setPermissions() :

export default GlyriaCommand()
  .setName("ban")
  .setDescription("Bannir un utilisateur")
  .setPermissions(djs.PermissionsBitField.Flags.BanMembers)
  .addUserOption((option) =>
    option
      .setName("user")
      .setDescription("Utilisateur à bannir")
      .setRequired(true)
  )
  .execute(async (ctx) => {
    // seuls les membres possédant la permission BanMembers peuvent utiliser cette commande
  })

PermissionsBitField est disponible via l'espace de noms djs — aucun import nécessaire. ::

Métadonnées

Ajoutez des données personnalisées à une commande avec .setMetaData(). Glyria stocke ces données telles quelles et ne les interprète jamais.

export default GlyriaCommand()
  .setName("ban")
  .setDescription("Bannir un utilisateur")
  .setMetaData({
    category: "moderation",
    cooldown: 5000,
    premium: false,
    guildOnly: true,
  })
  .execute(async (ctx) => {
    // votre logique ici
  })

useCommands()

useCommands() retourne la liste complète des commandes chargées avec leurs métadonnées.

const commands = useCommands()

// [
//   {
//     name: "ban",
//     description: "Bannir un utilisateur",
//     meta: {
//       category: "moderation",
//       cooldown: 5000
//     }
//   }
// ]

Exemple de commande /help organisée par catégories :

export default GlyriaCommand()
  .setName("help")
  .setDescription("Lister toutes les commandes")
  .execute(async () => {
    const commands = useCommands()

    const byCategory = commands.reduce((acc, cmd) => {
      const category = (cmd.meta.category as string) ?? "general"

      acc[category] ??= []
      acc[category].push(cmd)

      return acc
    }, {} as Record<string, typeof commands>)

    // construire votre embed à partir de byCategory
  })

Sous-commandes

// src/commands/moderation.ts
export default GlyriaCommand()
  .setName("moderation")
  .setDescription("Commandes de modération")
  .addSubCommand((cmd) =>
    cmd
      .setName("ban")
      .setDescription("Bannir un utilisateur")
      .addUserOption((option) =>
        option
          .setName("user")
          .setDescription("Utilisateur à bannir")
          .setRequired(true)
      )
      .addStringOption((option) =>
        option
          .setName("reason")
          .setDescription("Raison du bannissement")
      )
      .execute(async (ctx) => {
        // gérer le bannissement
      })
  )
  .addSubCommand((cmd) =>
    cmd
      .setName("kick")
      .setDescription("Expulser un utilisateur")
      .addUserOption((option) =>
        option
          .setName("user")
          .setDescription("Utilisateur à expulser")
          .setRequired(true)
      )
      .execute(async (ctx) => {
        // gérer l'expulsion
      })
  )

Groupes de sous-commandes

export default GlyriaCommand()
  .setName("config")
  .setDescription("Commandes de configuration")
  .addSubCommandGroup((group) =>
    group
      .setName("logs")
      .setDescription("Configuration des logs")
      .addSubCommand((cmd) =>
        cmd
          .setName("enable")
          .setDescription("Activer les logs")
          .execute(async (ctx) => {
            // gérer l'activation des logs
          })
      )
      .addSubCommand((cmd) =>
        cmd
          .setName("disable")
          .setDescription("Désactiver les logs")
          .execute(async (ctx) => {
            // gérer la désactivation des logs
          })
      )
  )

Cela génère une structure de commandes similaire à :

/config logs enable
/config logs disable
/moderation ban <user> [reason]
/moderation kick <user>

Organisation des commandes

Les sous-dossiers dans src/commands/ servent uniquement à l'organisation — chaque fichier, peu importe sa profondeur, est automatiquement chargé.

src/commands/
  ping.ts
  moderation/
    ban.ts
    kick.ts
  config/
    advanced/
      logs.ts

Conservez une seule commande par fichier. Utilisez les sous-commandes et les groupes de sous-commandes pour regrouper les fonctionnalités liées. ::

Client

Comment créer et configurer votre client de bot Discord avec glyria.js.

Events

Créez et organisez des events avec glyria.js.

Copyright © 2026