djs-builder 0.4.10 → 0.4.11

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

@@ -4,7 +4,7 @@ import { Routes } from 'discord-api-types/v10';
 import { readdir } from 'fs/promises';
 import path from 'path';
 import { SlashOptions } from '../types/starter';
-import { logSuccess, logError, logInfo } from '../functions/logger'; 
+import { logError } from '../functions/logger'; 
 
 export async function registerSlashCommands(client: any, token: string, slash: SlashOptions): Promise<Collection<string, any>> {
     if (!token) {
@@ -56,20 +56,17 @@ export async function registerSlashCommands(client: any, token: string, slash: S
         if (slash.global && !slash.serverId) {
             const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
             await rest.put(Routes.applicationCommands((client.user?.id || '')), { body: slashCommandArray, headers: { Authorization: `Bot ${token}` } });
-            logSuccess('Successfully registered global slash commands.');
         } else if (!slash.global && slash.serverId) {
             const guild = client.guilds.cache.get(slash.serverId) 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 ${token}` } });
-                logSuccess(`Successfully registered guild slash commands for server ID: ${slash.serverId}`);
             } else {
                 logError(`Guild with ID ${slash.serverId} 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 ${token}` } });
-            logSuccess('Successfully registered global slash commands.');
         }
     } catch (error: any) {
         logError('Error registering slash commands:');

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

@@ -0,0 +1,71 @@
+import { Collection } from 'discord.js';
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v10';
+import { readdir } from 'fs/promises';
+import { resolve, extname } from 'path';
+import { botData } from './login';
+import { logError, logInfo } from '../functions/logger';
+
+const validExtensions = ['.js', '.ts'];
+
+export async function slashLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
+    try {
+        const slashPath = botData.get('slashCommandPath') as string;
+        const token = botData.get('botToken') as string;
+
+        const commandPath = resolve(process.cwd(), slashPath);
+
+        const getAllFiles = async (dirPath: string): Promise<string[]> => {
+            let files: string[] = [];
+            const dirents = await readdir(dirPath, { withFileTypes: true });
+
+            for (const dirent of dirents) {
+                const res = resolve(dirPath, dirent.name);
+                if (dirent.isDirectory()) {
+                    files = files.concat(await getAllFiles(res));
+                } else if (validExtensions.includes(extname(dirent.name))) {
+                    files.push(res);
+                }
+            }
+            return files;
+        };
+
+        const files = await getAllFiles(commandPath);
+        if (files.length === 0) {
+            logInfo(`No command files found in directory \`${commandPath}\`.`);
+            return { commands: new Collection<string, any>(), success: false };
+        }
+
+        for (const file of files) {
+            delete require.cache[require.resolve(file)];
+            logInfo(`Unlinked cached module: ${file}`);
+        }
+
+        const newCommands = new Collection<string, any>();
+        for (const file of files) {
+            try {
+                const command = require(file);
+                if (command.data) {
+                    client.slashCommands.set(command.data.name, command);
+                    newCommands.set(command.data.name, command);
+                }
+            } catch (error: any) {
+                logError(`Error re-importing file: ${file}`);
+                logError(error.message);
+            }
+        }
+
+        const rest = new REST({ version: '10' }).setToken(token);
+        const slashCommandArray = Array.from(newCommands.values()).map((command: any) => command.data.toJSON());
+
+        await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: [] });
+        await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: slashCommandArray });
+
+        return { commands: newCommands, success: true };
+    } catch (error: any) {
+        logError('Error reloading slash commands:');
+        logError(error.message);
+        console.error(error);
+        return { commands: new Collection<string, any>(), success: false };
+    }
+}

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

@@ -1,6 +1,5 @@
 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';
@@ -18,9 +17,6 @@ export class Starter implements StarterInterface {
             if (options.bot?.Database?.verse) {
                 verseDb = await verseConnect(options.bot.Database.verse);
             }
-            if (options.events) {
-                await loadEvents(djs, options.events);
-            }
             if (options.anticrash?.enable) {
               await AntiCrash(djs, options)
             }            

package/lib/discord/utils.ts

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

package/lib/index.ts

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

package/package.json

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

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

@@ -1,21 +0,0 @@
-import { logSuccess, logError, logInfo } from '../functions/logger';
-import { EventsOptions } from '../types/starter';
-import { loadEvents } from './events'; 
-export async function eventsLoader(client: any, eventsOptions: EventsOptions) {
-
-    client.eventSize = 0;
-    client.removeAllListeners();
-
-    logInfo(`Reloading events from ${eventsOptions.path}`);
-
-    try {
-
-        await loadEvents(client, eventsOptions);
-
-        logSuccess(`Successfully reloaded ${client.eventSize} events.`);
-        return true
-    } catch (error: any) {
-        logError(`Error reloading events: ${error.message}`);
-        return false
-    }
-}