Simple Discord Handler

A lightweight library to simplify Discord.js message handling.

Installation

npm install simple-discord-handler

Usage

const { Client, GatewayIntentBits } = require("discord.js");
const SimpleMessageHandler = require("simple-discord-handler");

const client = new Client({
    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
});

const handler = new SimpleMessageHandler(client, { prefix: "!" });

handler.registerCommand("ping", async (message) => {
    await message.reply("Pong!");
});

client.once("ready", () => {
    console.log("Bot is online!");
    handler.start();
});

client.login("YOUR_BOT_TOKEN");

Buttons Handler

const { Client, Events, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require("discord.js");

class SimpleMessageHandler {
    constructor(client, options = {}) {
        if (!(client instanceof Client)) {
            throw new Error("Invalid Discord.js client.");
        }

        this.client = client;
        this.prefix = options.prefix || "!";
        this.commands = new Map();
        this.middlewares = [];
        this.buttons = new Map();
    }

    registerCommand(name, handler) {
        if (typeof name !== "string" || typeof handler !== "function") {
            throw new Error("Invalid command name or handler.");
        }
        this.commands.set(name, handler);
    }

    useMiddleware(middleware) {
        if (typeof middleware !== "function") {
            throw new Error("Middleware must be a function.");
        }
        this.middlewares.push(middleware);
    }

    /**
     * Register a button handler.
     * @param {string} customId - The custom ID of the button.
     * @param {function} handler - The handler function to execute when the button is clicked.
     */
    registerButton(customId, handler) {
        if (typeof customId !== "string" || typeof handler !== "function") {
            throw new Error("Invalid button customId or handler.");
        }
        this.buttons.set(customId, handler);
    }

    /**
     * Create a button.
     * @param {string} label - The text displayed on the button.
     * @param {string} customId - The unique identifier for the button.
     * @param {ButtonStyle} style - The style of the button (PRIMARY, SECONDARY, etc.).
     * @returns {ButtonBuilder} - The created button.
     */
    createButton(label, customId, style = ButtonStyle.Primary) {
        return new ButtonBuilder()
            .setLabel(label)
            .setCustomId(customId)
            .setStyle(style);
    }

    start() {
        // Handle messages
        this.client.on(Events.MessageCreate, async (message) => {
            if (message.author.bot) return;

            for (const middleware of this.middlewares) {
                const result = await middleware(message);
                if (result === false) return;
            }

            if (!message.content.startsWith(this.prefix)) return;

            const args = message.content.slice(this.prefix.length).trim().split(/\s+/);
            const commandName = args.shift()?.toLowerCase();

            const command = this.commands.get(commandName);
            if (command) {
                try {
                    await command(message, args);
                } catch (error) {
                    console.error(`Error executing command "${commandName}":`, error);
                    message.reply("There was an error executing that command.");
                }
            }
        });

        // Handle button interactions
        this.client.on(Events.InteractionCreate, async (interaction) => {
            if (!interaction.isButton()) return;

            const handler = this.buttons.get(interaction.customId);
            if (handler) {
                try {
                    await handler(interaction);
                } catch (error) {
                    console.error(`Error executing button handler "${interaction.customId}":`, error);
                    interaction.reply({ content: "There was an error handling this button.", ephemeral: true });
                }
            }
        });
    }
}

module.exports = SimpleMessageHandler;

Features

• Command registration
• Middleware support
• Argument parsing
• Easy setup