mjx-client 1.0.0-beta.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 majcek210
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# MJX CLIENT
+
+[![npm version](https://img.shields.io/npm/v/mjx-client)](https://www.npmjs.com/package/mjx-client)  
+[![License](https://img.shields.io/npm/l/mjx-client)](LICENSE)  
+
+MJX Client is a highly customizable Discord bot framework built on top of Discord.js v14. It allows structured management of commands, events, and bot behavior, providing a flexible framework for creating Discord bots.
+
+---
+
+## Features
+
+- Structured event handling with support for `once` and recurring events.
+- Easy registration of slash commands and automatic handling of interactions.
+- Built-in debug logging
+- Modular architecture with dynamic command and event loading.
+
+---
+
+## Installation
+
+```bash
+npm install mjx-client
+```
+
+---
+
+## Configuration
+
+MJX Client can be configured during instantiation, allowing you to set the client name(which can be acessed anytime from the client), enable debug mode, and specify Discord intents.
+
+---
+
+## Directory Structure
+
+```
+project/
+│
+├─ commands/       # Slash commands
+├─ events/         # Event handlers
+├─ src/
+│   └─ index.ts    # Main bot entry
+└─ package.json
+```
+
+---
+
+## License
+
+MJX Client is licensed under the MIT License. See [LICENSE](LICENSE) for details.

package/dist/src/client.d.ts

@@ -0,0 +1,36 @@
+import { Client as DiscordClient, IntentsBitField, ChatInputCommandInteraction, SlashCommandBuilder, Collection, ClientEvents } from "discord.js";
+type ClientOptions = {
+    name?: string;
+    debug?: boolean;
+    intents?: IntentsBitField;
+};
+export interface Command {
+    data: Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">;
+    execute: (interaction: ChatInputCommandInteraction) => Promise<void>;
+}
+export interface Event<K extends keyof ClientEvents = keyof ClientEvents> {
+    name: K;
+    once?: boolean;
+    execute: (...args: ClientEvents[K]) => void | Promise<void>;
+}
+export default class Client {
+    private _name;
+    private _debug;
+    private started;
+    private _discord;
+    commands: Collection<string, Command>;
+    events: Collection<string, Event>;
+    clientId: string | undefined;
+    constructor(options?: ClientOptions);
+    setName(name: string): this;
+    setDebug(enabled: boolean): this;
+    get name(): string;
+    get debug(): boolean;
+    get discord(): DiscordClient;
+    start(token?: string): Promise<this>;
+    registerCommandsRoute(dir: string): Promise<void>;
+    registerEventsRoute(dir: string): Promise<void>;
+    pushCommands(token?: string, guildId?: string): Promise<void>;
+    private ensureMutable;
+}
+export {};

package/dist/src/client.js

@@ -0,0 +1,149 @@
+import { Client as DiscordClient, GatewayIntentBits, Collection, Events, } from "discord.js";
+import { CollectCommands, CollectEvents } from "./lib/collector.js";
+import logger from "./lib/logger.js";
+import { REST } from "@discordjs/rest";
+import { Routes } from "discord.js";
+export default class Client {
+    _name;
+    _debug;
+    started = false;
+    _discord;
+    commands = new Collection();
+    events = new Collection();
+    clientId = undefined;
+    constructor(options = {}) {
+        this._name = options.name ?? "Unnamed Client";
+        this._debug = options.debug ?? false;
+        this._discord = new DiscordClient({
+            intents: options.intents ?? [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.MessageContent,
+            ],
+        });
+    }
+    setName(name) {
+        this.ensureMutable();
+        if (name.length < 3) {
+            throw new Error("Client name must be at least 3 characters");
+        }
+        this._name = name;
+        return this;
+    }
+    setDebug(enabled) {
+        this.ensureMutable();
+        this._debug = enabled;
+        return this;
+    }
+    get name() {
+        return this._name;
+    }
+    get debug() {
+        return this._debug;
+    }
+    get discord() {
+        return this._discord;
+    }
+    async start(token) {
+        if (this.started) {
+            throw new Error("Client already started");
+        }
+        const resolvedToken = token ?? process.env.DISCORD_TOKEN;
+        if (!resolvedToken) {
+            throw new Error("DISCORD_TOKEN is missing");
+        }
+        this._discord.once(Events.ClientReady, () => {
+            logger.output(`${this._name} logged in as ${this._discord.user?.tag}`);
+            if (!this.clientId) {
+                this.clientId = this._discord?.user?.id;
+            }
+        });
+        this._discord.on("interactionCreate", async (interaction) => {
+            if (!interaction.isChatInputCommand())
+                return;
+            const command = this.commands.get(interaction.commandName);
+            if (!command)
+                return;
+            try {
+                await command.execute(interaction);
+            }
+            catch (err) {
+                logger.error(err);
+            }
+        });
+        await this._discord.login(resolvedToken);
+        this.events.forEach((event) => {
+            if (event.once) {
+                try {
+                    this._discord.once(event.name, (...args) => event.execute(...args));
+                }
+                catch (err) {
+                    logger.error(err);
+                }
+            }
+            else {
+                try {
+                    this._discord.on(event.name, (...args) => event.execute(...args));
+                }
+                catch (err) {
+                    logger.error(err);
+                }
+            }
+        });
+        this.started = true;
+        return this;
+    }
+    async registerCommandsRoute(dir) {
+        const { total, loaded, commands } = await CollectCommands(dir);
+        commands.forEach((cmd, name) => this.commands.set(name, cmd));
+        if (this._debug)
+            logger.output(`Loaded ${loaded} out of ${total} commands.`);
+    }
+    async registerEventsRoute(dir) {
+        const { total, loaded, events } = await CollectEvents(dir);
+        events.forEach((event, name) => this.events.set(name, event));
+        if (this._debug)
+            logger.output(`Loaded ${loaded} out of ${total} events.`);
+    }
+    async pushCommands(token, guildId) {
+        const resolvedToken = token ?? process.env.DISCORD_TOKEN;
+        if (!resolvedToken) {
+            logger.error("DISCORD_TOKEN is missing");
+            return;
+        }
+        if (!this._discord.isReady()) {
+            logger.warn("Client isn't ready yet. Waiting...");
+            await new Promise((resolve) => {
+                this._discord.once(Events.ClientReady, () => resolve());
+            });
+        }
+        const commandsData = this.commands.map((cmd) => cmd.data.toJSON());
+        const rest = new REST({ version: "10" }).setToken(resolvedToken);
+        if (!this.clientId) {
+            logger.error("Client ID wasnt intalized correctly, try adding it manualy with setClientId");
+            return;
+        }
+        try {
+            if (guildId) {
+                await rest.put(Routes.applicationGuildCommands(this.clientId, guildId), { body: commandsData });
+                if (this._debug)
+                    logger.output(`Registered ${commandsData.length} commands to guild ${guildId}`);
+            }
+            else {
+                await rest.put(Routes.applicationCommands(this.clientId), {
+                    body: commandsData,
+                });
+                if (this._debug)
+                    logger.output(`Registered ${commandsData.length} global commands`);
+            }
+        }
+        catch (err) {
+            logger.error("Failed to register commands:", err);
+        }
+    }
+    ensureMutable() {
+        if (this.started) {
+            throw new Error("Cannot modify client after start");
+        }
+    }
+}

package/dist/src/lib/collector.d.ts

@@ -0,0 +1,11 @@
+import type { Command, Event } from "../client.js";
+export declare function CollectCommands(dir: string): Promise<{
+    total: number;
+    loaded: number;
+    commands: Map<string, Command>;
+}>;
+export declare function CollectEvents(dir: string): Promise<{
+    total: number;
+    loaded: number;
+    events: Map<string, Event>;
+}>;

package/dist/src/lib/collector.js

@@ -0,0 +1,54 @@
+import fs from "fs";
+import path from "path";
+import logger from "./logger.js";
+import { pathToFileURL } from "url";
+export async function CollectCommands(dir) {
+    try {
+        const commands = new Map();
+        const files = fs
+            .readdirSync(dir)
+            .filter((f) => f.endsWith(".js"));
+        const total = files.length;
+        let loaded = 0;
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const module = await import(pathToFileURL(filePath).href);
+            const command = module.default ?? module.command;
+            if (!command?.data || !command?.execute)
+                continue;
+            commands.set(command.data.name, command);
+            loaded++;
+        }
+        return { total, loaded, commands };
+    }
+    catch (err) {
+        logger.error(err);
+        return {
+            total: 0,
+            loaded: 0,
+            commands: new Map(),
+        };
+    }
+}
+export async function CollectEvents(dir) {
+    try {
+        const events = new Map();
+        const files = fs.readdirSync(dir).filter(f => f.endsWith(".js"));
+        const total = files.length;
+        let loaded = 0;
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const module = await import(pathToFileURL(filePath).href);
+            const event = module.default ?? module.event;
+            if (!event?.name || !event?.execute)
+                continue;
+            events.set(event.name, event);
+            loaded++;
+        }
+        return { total, loaded, events };
+    }
+    catch (err) {
+        logger.error(err);
+        return { total: 0, loaded: 0, events: new Map() };
+    }
+}

package/dist/src/lib/logger.d.ts

@@ -0,0 +1,6 @@
+export default class logger {
+    private static format;
+    static output(...messages: any[]): void;
+    static warn(...messages: any[]): void;
+    static error(...messages: any[]): void;
+}

package/dist/src/lib/logger.js

@@ -0,0 +1,15 @@
+export default class logger {
+    static format(message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] ${message}`;
+    }
+    static output(...messages) {
+        console.log(this.format(messages.map(String).join(" ")));
+    }
+    static warn(...messages) {
+        console.warn(`\x1b[33m${this.format(messages.map(String).join(" "))}\x1b[0m`);
+    }
+    static error(...messages) {
+        console.error(`\x1b[31m${this.format(messages.map(String).join(" "))}\x1b[0m`);
+    }
+}

package/dist/tests/Commands/ping.d.ts

@@ -0,0 +1,2 @@
+declare const pingCommand: any;
+export default pingCommand;

package/dist/tests/Commands/ping.js

@@ -0,0 +1,10 @@
+import { SlashCommandBuilder } from "discord.js";
+const pingCommand = {
+    data: new SlashCommandBuilder()
+        .setName("ping")
+        .setDescription("Replies with Pong!"),
+    execute: async (interaction) => {
+        await interaction.reply("Pong!");
+    },
+};
+export default pingCommand;

package/dist/tests/Events/message.d.ts

@@ -0,0 +1,3 @@
+import type { Event } from "../../src/client.js";
+declare const messageEvent: Event<"messageCreate">;
+export default messageEvent;

package/dist/tests/Events/message.js

@@ -0,0 +1,14 @@
+import { Events } from "discord.js";
+const messageEvent = {
+    name: Events.MessageCreate,
+    once: false,
+    async execute(message) {
+        if (message.author.bot)
+            return;
+        const channel = message.client.channels.cache.get(process.env.TEST_CHANNEL);
+        if (channel?.isTextBased()) {
+            await channel.send(`Hello! Received a message from ${message.author.tag}`);
+        }
+    }
+};
+export default messageEvent;

package/dist/tests/Events/ready.d.ts

@@ -0,0 +1,2 @@
+declare const readyEvent: any;
+export default readyEvent;

package/dist/tests/Events/ready.js

@@ -0,0 +1,9 @@
+import { Events } from "discord.js";
+const readyEvent = {
+    name: Events.ClientReady,
+    once: true,
+    execute(client) {
+        console.log(`Ready! Logged in as ${client.user.tag}`);
+    }
+};
+export default readyEvent;

package/dist/tests/main.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/dist/tests/main.js

@@ -0,0 +1,12 @@
+import "dotenv/config";
+import Client from "../src/client.js";
+const client = new Client({ debug: true })
+    .setName("tuff bot");
+client.registerEventsRoute("./dist/tests/Events");
+client.registerCommandsRoute("./dist/tests/Commands");
+client.discord.on("messageCreate", (msg) => {
+    if (msg.content === "!ping")
+        msg.reply("pong");
+});
+client.start(process.env.TOKEN);
+client.pushCommands(process.env.TOKEN);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "mjx-client",
+  "version": "1.0.0-beta.7",
+  "description": "A discord bot framework built on top of discord.js made by majcek210",
+  "keywords": [
+    "bot",
+    "discord",
+    "discord.js"
+  ],
+  "license": "ISC",
+  "author": "majcek210",
+  "type": "module",
+  "main": "dist/src/client.js",
+  "types": "dist/src/client.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node dist/tests/main.js"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "discord.js": "^14.25.1"
+  }
+}