Create command

To start creating a command, follow these steps:

1. Run the following command to create file and boilerplate initial content:

   npx zumito-cli create command

2. It will ask you for the name of the command, and the module where you want to create it.

   Nota

   Don’t worry if you don’t created the module yet, the CLI will create it for you.

3. After that, it will create a file in the src/modules/<module>/commands folder with the name of the command. The file will contain the following code:

   import { Command, CommandParameters, ZumitoFramework, CommandType, SelectMenuParameters } from "zumito-framework";
   
   export class CommandName extends Command {
   
       async execute({ message, interaction, args, guildSettings }: CommandParameters): Promise<void> {
           // Command code
       }
   
       async selectMenu({ path, interaction, guildSettings }: SelectMenuParameters): Promise<void> {
   
       }
   
   }

   Note

   here you can find info on how to write command code

Command code

Here you can write the code that the bot will run when user execute the command

Slash command

    async executeSlashCommand({ interaction, args, guildSettings }: CommandParameters): Promise<void> {
        // Code here will run when slash command is executed
        interaction.reply({
            content: "Test message",
        })
    }

Prefix command

    async executePrefixCommand({ message, args, guildSettings }: CommandParameters): Promise<void> {
        // Code here will run when prefix command is executed
        message.reply({
            content: "Test message",
        })
    }

Both commands

    async execute({ message, interaction, args, guildSettings }: CommandParameters): Promise<void> {
        // Code here will run when slash or prefix command is executed
        (message||interaction).reply({
            content: "Test message",
        })
    }

Note

• If you run command from slash, first we will try to execute executeSlashCommand function. But if the function does not exist, then we will execute execute function.
• If you run command from prefix, first we will try to execute executePrefixCommand function. But if the function does not exist, then we will execute execute function.

So, if you want to run different code on each command system you can define the code for each, but if the code is the same you can write it all on the execute function.

Tip

You can find better explain of the parameters recibed by the execute function in the Execute parameters section.

Execute parameters

The execute function receives a CommandParameters object, which contains the following properties:

• message - Discord.Message object. Undefined if the command is executed from an interaction (slash command).

• interaction - Discord.Interaction object. Undefined if the command is executed from a message with the prefix.

• args - Arguments of the command. Contains the arguments user passed to the command.

  • You can get the arguments using the get method, which receives the name of the argument and the type of the argument.

    args.get("argumentName"); // Output: "Argument value"

  • Output comes in the type you specified, so if you specify a number, the output will be a number and if you specify a user it will be a Discord.User object.

• guildSettings - Guild settings object. Contains the settings of the guild where the command was executed. The data is loaded from the database on each command execution.

• trans - A shorthand function to translate strings. It receives the key of the string and the variables to replace in the string.

  • It does not require language to be specified, it will use the language of the guild where the command was executed.
  • The key is relative to current command, so if you have a key named command.yourCommandName.yourKey, you can use it like this: trans("yourKey"). if you want to use a key from anywhere else, you can use $ prefix, like this: trans("$command.yourCommandName.yourKey").

Command atributes

In the header of your command class, you can define some atributes. You can find here a little description of each one.

• adminOnly: true/false. Defines if the command can be used only by guild admins or any user. Defaults to any user (false)
• aliases: array of strings. Defines alternative alias for the commnad.
• args: array of CommandArgDefinition. Defines the parameters that te user can use on the command.
• binds: CommandBinds object. Defines event listeners related to command. Here you can listen for select menu interaction, modal form submit, etc.
• botPermissions: WIP
• categories: array of strings. Defines the categories of the command. Useful for help command.
• cooldown: WIP
• dm: true/false. Defines if the command can be runned in a dm channel. Defaults to false.

  Caution

  Remember in a dm you cannot acces to guild properties.

• examples: array of strings. Defines example usages of the bot. So for a clean command with first argument as a number you can write ['clean 100']. Do not write any prefix.
• hidden: true/false. Defines if the command would be hidden from help commands. The command will be still usable.
• name: Defines alternative name if you don’t want to use class name.
• nsfw: true/false. Defines if the command could be executed out of a nsfw channel. Defaults to false (The command can be runned anywhere)
• parent: string. Parent command. Useful for subcommands. WIP.
• type: CommandType object. Defines if the command can be runned using slash and/or prefix. CommandType.slash / CommandType.prefix / CommandType.any

Tips

Acces to discord client instance

To get the discord.js client instance you will need to do some simple steps:

1. Import ServiceContainer from zumito-framework and Client from zumito-framework/discord

   import { ServiceContainer, Command, CommandParameters, ZumitoFramework, CommandType, SelectMenuParameters } from "zumito-framework";
   import { Client } from 'zumito-framework/discord';
   export class CommandName extends Command {
       ...
   }

2. Define variable inside the class

   export class CommandName extends Command {
       private client: Client;
   }

3. Initialize variable by obtaining from ServiceContainer:

   export class CommandName extends Command {
       private client: Client;
       constructor() {
           super();
           this.client = ServiceContainer.get(Client);
       }
   }

4. Now you can use the client in any part of the command:

   export class CommandName extends Command {
       private client: Client;
       constructor() {
           super();
           this.client = ServiceContainer.get(Client);
       }
   
       async execute(params): Promise<void> {
           console.log(this.client.status);
       }
   }

Did you know?

You can simplify the code by initializing in the constructor parameters:

constructor(
    private client: Client = ServiceContainer.get(Client)
) {
    super();
}

Read command args

args parameter of the execute function contains the arguments user passed to the command. You can get the arguments using the get method, which receives the name of the argument and the type of the argument.

Text arg

async execute({ message, interaction, args, client, framework, guildSettings }: CommandParameters): Promise<void> {
   const textArg: string = args.get("argumentName"); // Output: "Argument value"
}

Output: String

User arg

async execute({ message, interaction, args, client, framework, guildSettings }: CommandParameters): Promise<void> {
   const userArg: User =  args.get("argumentName");
}

Output: User

Channel arg

async execute({ message, interaction, args, client, framework, guildSettings }: CommandParameters): Promise<void> {
   const channelArg: GuildChannel =  args.get("argumentName");
}

Output: GuildChannel