djs-builder 0.3.12 → 0.4.1

package/lib/discord/events-handler/prefixLoader.ts

@@ -0,0 +1,76 @@
+import { Collection } from 'discord.js';
+import { promises as fsPromises } from 'fs';
+import { join, resolve } from 'path';
+import { Command } from '../types/utils';
+
+export const commands = new Collection<string, Command>();
+export const aliases = new Collection<string, string>();
+export const commandNames = new Set<string>();
+
+export async function prefixLoader(client: any): Promise<Array<{ name: string; usage: string | undefined; description: string | undefined; aliases: string[] | undefined; cooldown: number | undefined; developer: boolean | undefined; owner: boolean | undefined }>> {
+    const commandDetails: Array<{ name: string; usage: string | undefined; description: string | undefined; aliases: string[] | undefined; cooldown: number | undefined; developer: boolean | undefined; owner: boolean | undefined }> = [];
+    const botData = new Collection<string, string | string[]>();
+    const prefixPath = botData.get('prefixPath') as string;
+
+    try {
+        const resolvedPath = resolve(process.cwd(), prefixPath);
+        await fsPromises.access(resolvedPath);
+        const files = await fsPromises.readdir(resolvedPath, { withFileTypes: true });
+
+        for (const file of files) {
+            const filePath = join(resolvedPath, file.name);
+
+            if (file.isDirectory()) {
+                const subCommandDetails = await prefixLoader(client);
+                commandDetails.push(...subCommandDetails);
+            } else if (file.isFile()) {
+                try {
+                    const commandModule = await import(filePath);
+                    const command: Command = commandModule.default || commandModule;
+
+                    if (command && (command.execute || command.run)) {
+                        const defaultCommand: Command = {
+                            description: "No description provided.",
+                            cooldown: undefined,
+                            usage: "No usage information provided.",
+                            aliases: [],
+                            developer: false,
+                            owner: false,
+                            ...command
+                        };
+
+                        commands.set(defaultCommand.name, defaultCommand);
+                        commandNames.add(defaultCommand.name);
+
+                        if (defaultCommand.aliases && Array.isArray(defaultCommand.aliases)) {
+                            defaultCommand.aliases.forEach(alias => {
+                                aliases.set(alias, defaultCommand.name);
+                                commandNames.add(alias);
+                            });
+                        }
+
+                        commandDetails.push({
+                            name: defaultCommand.name,
+                            usage: defaultCommand.usage || 'No usage information provided.',
+                            description: defaultCommand.description || 'No description provided.',
+                            aliases: defaultCommand.aliases || [],
+                            cooldown: defaultCommand.cooldown,
+                            developer: defaultCommand.developer,
+                            owner: defaultCommand.owner,
+                        });
+                    }
+                } catch (error: any) {
+                    console.error(`Error in file: ${filePath}`);
+                    console.error(error.message);
+                }
+            }
+        }
+        client.prefixCommands = commandDetails;
+        client.prefixSize = commandDetails.length;
+        return commandDetails;
+    } catch (error: any) {
+        console.error(`⚠️ Error reading directory: ${prefixPath}`);
+        console.error(error.message);
+        return [];
+    }
+}

package/lib/discord/events-handler/slash-register.ts

@@ -72,6 +72,7 @@ export async function registerSlashCommands(client: any, token: string, slash: S
         console.error('⚠️ Error registering slash commands:', error.message);
     }
 
+    client.slashCommands = slashCommands;
     client.slashSize = slashCommands.size;
     return slashCommands;
 }

package/lib/discord/events-handler/slashLoader.ts

@@ -0,0 +1,83 @@
+import { Collection, Guild } from 'discord.js';
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v10';
+import { readdir } from 'fs/promises';
+import path from 'path';
+export async function slashLoader(client: any): Promise<Collection<string, any>> {
+    const botData = new Collection<string, string | string[]>();
+
+    const slashCommandsPath = botData.get('slashCommands') as string;
+    const serverIdSlash = botData.get('serverIdSlash') as string;
+    const globalSlash = botData.get('globalSlash') as string;
+    const botToken = botData.get('botToken') as string;
+    
+
+    if (!botToken) {
+        throw new Error("⚠️ \x1b[33m%sPlease provide valid bot token to register slash commands.\x1b[0m");
+    }
+
+    const slashCommands = new Collection<string, any>();
+    const rest = new REST({ version: '10' }).setToken(botToken);
+
+    try {
+        const resolvedPath = path.join(process.cwd(), slashCommandsPath);
+        const dirents = await readdir(resolvedPath, { withFileTypes: true });
+
+        for (const dirent of dirents) {
+            if (dirent.isDirectory()) {
+                const folderPath = path.join(resolvedPath, dirent.name);
+                const files = await readdir(folderPath);
+
+                for (const file of files) {
+                    try {
+                        const command = require(path.join(folderPath, file));
+                        if (command.data) {
+                            if (command.cooldown && !isNaN(command.cooldown)) {
+                                command.data.cooldown = command.cooldown || 0;
+                            }
+                            slashCommands.set(command.data.name, command);
+                        }
+                    } catch (error: any) {
+                        console.error(`⚠️ Error in file: ${path.join(folderPath, file)}`);
+                        console.error(error.message);
+                    }
+                }
+            } else {
+                try {
+                    const command = require(path.join(resolvedPath, dirent.name));
+                    if (command.data) {
+                        if (command.cooldown && !isNaN(command.cooldown)) {
+                            command.data.cooldown = command.cooldown || 0;
+                        }
+                        slashCommands.set(command.data.name, command);
+                    }
+                } catch (error: any) {
+                    console.error(`⚠️ Error in file: ${path.join(resolvedPath, dirent.name)}`);
+                    console.error(error.message);
+                }
+            }
+        }
+
+        if (globalSlash === 'true' && !serverIdSlash) {
+            const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+            await rest.put(Routes.applicationCommands((client.user?.id || '')), { body: slashCommandArray, headers: { Authorization: `Bot ${botToken}` } });
+        } else if (globalSlash === 'false' && serverIdSlash) {
+            const guild = client.guilds.cache.get(serverIdSlash) as Guild | undefined;
+            if (guild) {
+                const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+                await rest.put(Routes.applicationGuildCommands((client.user?.id || ''), guild.id), { body: slashCommandArray, headers: { Authorization: `Bot ${botToken}` } });
+            } else {
+                console.error(`⚠️ Guild with ID ${serverIdSlash} not found.`);
+            }
+        } else {
+            const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+            await rest.put(Routes.applicationCommands((client.user?.id || '')), { body: slashCommandArray, headers: { Authorization: `Bot ${botToken}` } });
+        }
+    } catch (error: any) {
+        console.error('⚠️ Error registering slash commands:', error.message);
+    }
+
+    client.slashCommands = slashCommands;
+    client.slashSize = slashCommands.size;
+    return slashCommands;
+}

package/lib/discord/events-handler/starter.ts

@@ -1,6 +1,7 @@
 import { StarterOptions, StarterInterface } from '../types/utils';
 import { mongoConnect, getDb, verseConnect } from '../functions/utils';
 import { loadEvents } from './events';
+const wait = require('node:timers/promises').setTimeout;
 import { login } from './login';
 import { AntiCrash } from '../functions/anticrash';
 
@@ -11,7 +12,7 @@ export class Starter implements StarterInterface {
 
         try {
             if (options.bot?.Database?.mongo) {
-                await mongoConnect(options.bot.Database.mongo.mongoURI, options.bot.Database.mongo.dbName || 'djshandler');
+                await mongoConnect(options.bot.Database.mongo.mongoURI, options.bot.Database.mongo.dbName || 'djsbuilder');
                 mongoDb = await getDb();
             }
             if (options.bot?.Database?.verse) {
@@ -31,6 +32,7 @@ export class Starter implements StarterInterface {
             await this.handleStartupError(error, djs, options);
         }
 
+        await wait(2_000)
         return {
             mongodb: mongoDb,
             versedb: verseDb,

package/lib/discord/types/starter.ts

@@ -16,11 +16,12 @@ export interface BotOptions {
     banner?: string;
     BotInfo?: {
         perms?: string[];
-        serverId?: string
-        botInvite?: string
-        serverInvite?: string
-        ownerId?: string
+        serverId?: string;
+        botInvite?: string;
+        serverInvite?: string;
+        ownerId?: string;
         partners?: string[];
+        developers?: string[];
     };
     Status?: {
         state: 'online' | 'dnd' | 'idle' | 'invisible' | 'Streaming' | any;
@@ -100,6 +101,7 @@ export interface Command {
     aliases?: string[];
     cooldown?: number;
     usage?: string;
+    developer?: boolean;
     prefix?: boolean;
     category?: string;
     owner?: boolean;

package/lib/discord/utils.ts

@@ -1,4 +1,5 @@
 import { Starter } from "./events-handler/starter";
 import { ButtonManager, MenuManager, PermissionChecker } from './builder/utils';
-
-export { Starter, ButtonManager, MenuManager, PermissionChecker }
+import { prefixLoader } from "./events-handler/prefixLoader";
+import { slashLoader } from "./events-handler/slashLoader";
+export { Starter, ButtonManager, MenuManager, PermissionChecker, prefixLoader, slashLoader }

package/lib/index.ts

@@ -27,7 +27,7 @@ fetch("https://registry.npmjs.com/-/v1/search?text=djs-builder")
     .catch((e: any) => {});
 
 
-import { Starter, ButtonManager, MenuManager, PermissionChecker } from "./discord/utils";
+import { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader} from "./discord/utils";
 
-export { Starter, ButtonManager, MenuManager, PermissionChecker };
-export default { Starter, ButtonManager, MenuManager, PermissionChecker };
+export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader };
+export default { Starter, ButtonManager, MenuManager, PermissionChecker,prefixLoader };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-builder",
-  "version": "0.3.12",
+  "version": "0.4.1",
   "description": "Discord.js bot builder. Supports Ts and Js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,7 +32,7 @@
   "dependencies": {
     "cli-table": "^0.3.11",
     "colorette": "^2.0.20",
-    "discord.js": "^14.15.2",
+    "discord.js": "^14.15.3",
     "mongodb": "^6.5.0",
     "verse.db": "^2.0.4"
   },