Nevertheless Published Mine

    TypeScript icon, indicating that this package has built-in type declarations

    11.4.0 • Public • Published

    Discord server NPM version NPM downloads Build status paypal

    Create a discord bot with TypeScript and Decorators!

    📖 Introduction

    This module is an extension of discord.js, so the internal behavior (methods, properties, ...) is the same.

    This library allows you to use TypeScript decorators on discord.js, it simplifies your code and improves the readability!

    💻 Installation

    Version 16.6.0 or newer of Node.js is required

    npm install discordx
    yarn add discordx

    installation guide

    one-click installation

    📜 Documentation

    Tutorials (

    🤖 Bot Examples

    discordx-templates (starter repo)

    music bot (ytdl)

    lavalink bot

    Shana from @VictoriqueMoe

    💡 Why discordx?

    With discordx, we intend to provide the latest up-to-date package to easily build feature-rich bots with multi-bot compatibility, simple commands, pagination, music, and much more. Updated daily with discord.js changes.

    Try discordx now with CodeSandbox

    If you have any issues or feature requests, Please open an issue at GitHub or join discord server

    🆕 Features

    • Support multiple bots in a single nodejs instance (@Bot)
    • @SimpleCommand to use old fashioned command, such as !hello world
    • @SimpleCommandOption parse and define command options like @SlashOption
    • client.initApplicationCommands to create/update/remove discord application commands
    • Handler for all discord interactions (slash/button/menu/context)
    • Support TSyringe and TypeDI
    • Support ECMAScript

    🧮 Packages

    Here are more packages from us to extend the functionality of your Discord bot.

    Package Description
    create-discordx Create discordx apps with one command
    discordx Create a discord bot with TypeScript and Decorators!
    @discordx/changelog Changelog generator, written in TypeScript with Node.js
    @discordx/di Dependency injection service with TSyringe support
    @discordx/importer Import solution for ESM and CJS
    @discordx/internal discordx internal methods, can be used for external projects
    @discordx/koa Create rest api server with Typescript and Decorators
    @discordx/lava-player Create lavalink player
    @discordx/lava-queue Create queue system for lavalink player
    @discordx/music Create discord music player easily
    @discordx/pagination Add pagination to your discord bot
    @discordx/ Create server with Typescript and Decorators
    @discordx/utilities Create own group with @Category and guards
    discord-spams Tiny but powerful discord spam protection library

    📔 Decorators

    There is a whole system that allows you to implement complex slash/simple commands and handle interactions like button, select-menu, context-menu etc.



    GUI Interactions

    📟 @Slash

    Discord has it's own command system now, you can simply declare commands and use Slash commands this way

    class Example {
      @Slash({ description: "say hello", name: "hello" })
          description: "enter your greeting",
          name: "message",
          required: true,
          type: ApplicationCommandOptionType.String,
        message: string,
        interaction: CommandInteraction
      ): void {
        interaction.reply(`:wave: from ${interaction.user}: ${message}`);

    📟 @ButtonComponent

    Create discord button handler with ease!

    class Example {
      @ButtonComponent({ id: "hello" })
      handler(interaction: ButtonInteraction): void {
      @ButtonComponent({ id: "hello" })
      handler2(interaction: ButtonInteraction): void {
        console.log(`${interaction.user} says hello`);
      @Slash({ description: "test" })
      test(interaction: CommandInteraction): void {
        const btn = new ButtonBuilder()
        const buttonRow =
          new ActionRowBuilder<MessageActionRowComponentBuilder>().addComponents(
          components: [buttonRow],

    📟 @SelectMenuComponent

    Create discord select menu handler with ease!

    const roles = [
      { label: "Principal", value: "principal" },
      { label: "Teacher", value: "teacher" },
      { label: "Student", value: "student" },
    class Example {
      @SelectMenuComponent({ id: "role-menu" })
      async handle(interaction: SelectMenuInteraction): Promise<unknown> {
        await interaction.deferReply();
        // extract selected value by member
        const roleValue = interaction.values?.[0];
        // if value not found
        if (!roleValue) {
          return interaction.followUp("invalid role id, select again");
          `you have selected role: ${
            roles.find((r) => r.value === roleValue)?.label ?? "unknown"
      @Slash({ description: "roles menu", name: "my-roles" })
      async myRoles(interaction: CommandInteraction): Promise<unknown> {
        await interaction.deferReply();
        // create menu for roles
        const menu = new SelectMenuBuilder()
        // create a row for message actions
        const buttonRow =
          new ActionRowBuilder<MessageActionRowComponentBuilder>().addComponents(
        // send it
          components: [buttonRow],
          content: "select your role!",

    📟 @ContextMenu

    Create discord context menu options with ease!

    class Example {
        name: "Hello from discordx",
        type: ApplicationCommandType.Message,
      messageHandler(interaction: MessageContextMenuCommandInteraction): void {
        console.log("I am message");
        interaction.reply("message interaction works");
        name: "Hello from discordx",
        type: ApplicationCommandType.User,
      userHandler(interaction: UserContextMenuCommandInteraction): void {
        console.log(`Selected user: ${interaction.targetId}`);
        interaction.reply("user interaction works");

    📟 @ModalComponent

    Create discord modal with ease!

    class Example {
      @Slash({ description: "modal" })
      modal(interaction: CommandInteraction): void {
        // Create the modal
        const modal = new ModalBuilder()
          .setTitle("My Awesome Form")
        // Create text input fields
        const tvShowInputComponent = new TextInputBuilder()
          .setLabel("Favorite TV show")
        const haikuInputComponent = new TextInputBuilder()
          .setLabel("Write down your favorite haiku")
        const row1 = new ActionRowBuilder<TextInputBuilder>().addComponents(
        const row2 = new ActionRowBuilder<TextInputBuilder>().addComponents(
        // Add action rows to form
        modal.addComponents(row1, row2);
        // --- snip ---
        // Present the modal to the user
      async AwesomeForm(interaction: ModalSubmitInteraction): Promise<void> {
        const [favTVShow, favHaiku] = ["tvField", "haikuField"].map((id) =>
        await interaction.reply(
          `Favorite TV Show: ${favTVShow}, Favorite haiku: ${favHaiku}`

    📟 @SimpleCommand

    Create a simple command handler for messages using @SimpleCommand. Example !hello world

    class Example {
      @SimpleCommand({ aliases: ["hey", "hi"], name: "hello" })
      hello(command: SimpleCommandMessage): void {

    💡@On / @Once

    We can declare methods that will be executed whenever a Discord event is triggered.

    Our methods must be decorated with the @On(event: string) or @Once(event: string) decorator.

    That's simple, when the event is triggered, the method is called:

    class Example {
      @On({ name: "messageCreate" })
      messageCreate() {
        // ...
      @Once({ name: "messageDelete" })
      messageDelete() {
        // ...


    Create a reaction handler for messages using @Reaction.

    class Example {
      @Reaction({ emoji: "⭐", remove: true })
      async starReaction(reaction: MessageReaction, user: User): Promise<void> {
        await reaction.message.reply(`Received a ${reaction.emoji} from ${user}`);
      @Reaction({ aliases: ["📍", "custom_emoji"], emoji: "📌" })
      async pin(reaction: MessageReaction): Promise<void> {

    ⚔️ Guards

    We implemented a guard system that functions like the Koa middleware system

    You can use functions that are executed before your event to determine if it's executed. For example, if you want to apply a prefix to the messages, you can simply use the @Guard decorator.

    The order of execution of the guards is done according to their position in the list, so they will be executed in order (from top to bottom).

    Guards can be set for @Slash, @On, @Once, @Discord and globally.

    import { Discord, On, Client, Guard } from "discordx";
    import { NotBot } from "./NotBot";
    import { Prefix } from "./Prefix";
    class Example {
        NotBot // You can use multiple guard functions, they are executed in the same order!
      messageCreate([message]: ArgsOf<"messageCreate">) {
        switch (message.content.toLowerCase()) {
          case "hello":
            message.reply("Command not found");

    📜 Documentation

    ☎️ Need help?

    💖 Thank you

    You can support discordx by giving it a GitHub star.


    npm i discordx

    DownloadsWeekly Downloads






    Unpacked Size

    603 kB

    Total Files


    Last publish


    • iorp