discordx Documentation

The discordx ecosystem consists of several specialized packages designed to extend Discord bot functionality, ranging from core framework capabilities to music playback and pagination.

Core Framework

• discordx: The main framework for creating Discord bots using TypeScript and Decorators.
• create-discordx: A CLI tool used to scaffold new projects using pre-defined templates.
• @discordx/di: A dependency injection service that supports agnostic Inversion of Control (IOC).
• @discordx/importer: A solution for importing modules in both ESM and CJS environments.
• @discordx/utilities: A collection of utilities to enhance general discordx functionality.
• @discordx/internal: Contains internal methods used by the discordx framework.

Music and Audio

• @discordx/lava-player: A Lavalink player library written in TypeScript for Node.js.
• @discordx/lava-queue: A queue management system specifically for @discordx/lava-player.
• @discordx/music: A music player library utilizing YTDL.
• @discordx/plugin-lava-player: A high-level Discord music player plugin that leverages Lavalink.
• @discordx/plugin-ytdl-player: A high-level Discord music player plugin that utilizes YTDL.

UI and UX

• @discordx/pagination: A library dedicated to creating pagination-based messages within Discord bots.

The @SlashGroup decorator allows you to create hierarchical command structures in Discord, such as subcommands and subcommand groups.

Hierarchy Levels

• Level 1 (Groups): A top-level command containing multiple subcommands.
  • command -> subcommand
• Level 2 (Subgroups): A command containing groups, which in turn contain subcommands.
  • command -> subcommand-group -> subcommand

Creating Groups and Subgroups

To create a group or subgroup, use @SlashGroup as a Class Decorator on a class decorated with @Discord().

• For a Group: Pass a SlashGroupOptions object.
• For a Subgroup: Pass a SlashGroupOptions object and specify the root property to link it to its parent group.

Assigning Commands to Groups

Once a group is defined, you can assign @Slash methods to it using @SlashGroup as a Method Decorator or a Class Decorator.

1. Class Level Assignment: Applying @SlashGroup(name) to the class will automatically assign all methods within that class to the specified group.
2. Method Level Assignment: Applying @SlashGroup(name) directly to a specific method assigns only that method to the group.

When working with subgroups, you must provide both the subgroup name and the root group name: @SlashGroup(subgroupName, rootName).

// Creating a subgroup
@Discord()
@SlashGroup({ description: "Manage permissions", name: "permission" })
@SlashGroup({
  description: "Manage permissions",
  name: "user",
  root: "permission", // must specify the parent group name
})
class Example {}

// Assigning a method to a subgroup
@Slash({ description: "get" })
@SlashGroup("user", "permission")
get() {}

Autocomplete allows you to dynamically return suggestions to a user as they type. You can implement this in two ways:

1. Using a Resolver

Pass a function to the autocomplete property within the @SlashOption configuration. This function receives the AutocompleteInteraction and you call interaction.respond([...]) to provide choices.

2. Using a Boolean flag

Set autocomplete: true in the @SlashOption configuration. In this mode, discordx will call your command handler with an AutocompleteInteraction instead of a standard CommandInteraction. You must then check interaction.isAutocomplete() inside your handler to process the suggestions.

Note on this context: If you use a standard function for the resolver, this will refer to your class instance. If you use an arrow function, this will not be bound to your class.

// Method 1: Resolver
@SlashOption({
  autocomplete: function (interaction: AutocompleteInteraction) {
      interaction.respond([
        { name: "option a", value: "a" },
        { name: "option b", value: "b" },
      ]);
  },
  description: "autocomplete",
  name: "autocomplete",
  required: true,
  type: ApplicationCommandOptionType.String,
})
input: string,

// Method 2: Boolean flag
@Slash({ description: "autocomplete" })
autocomplete(
  @SlashOption({
    autocomplete: true,
    description: "option-a",
    name: "option-a",
    required: true,
    type: ApplicationCommandOptionType.String,
  })
  searchText: string,
  interaction: CommandInteraction | AutocompleteInteraction
): void {
  if (interaction.isAutocomplete()) {
    // Handle autocomplete logic here
  }
}