djs-builder 0.4.85 → 0.5.1

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

@@ -1,40 +1,54 @@
-import { logSuccess, logError, logInfo, logWarning } from '../functions/logger';
-import { commands, aliases, commandNames, readCommands } from './prefix-register';
+import { Collection } from 'discord.js';
+import { readdir } from 'fs/promises';
+import { join, resolve, extname } from 'path';
+import { commands, aliases, commandNames } from './prefix-register';
+import { readCommands } from './prefix-register'; 
+import { logError } from '../functions/logger';
 import { botData } from './login';
+const validExtensions = ['.js', '.ts'];
 
-export async function prefixLoader(client: any): Promise<boolean> {
-    const currentCommandNames = new Set(commands.keys());
-    console.log('Before clearing:');
-    console.log('Commands size:', commands.size);
-    console.log('Aliases size:', aliases.size);
-    console.log('Command names size:', commandNames.size);
-
-
-    commands.clear();
-    aliases.clear();
-    commandNames.clear();
+export async function prefixLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
+    try {
 
-    console.log('After clearing:');
-    console.log('Commands size:', commands.size);
-    console.log('Aliases size:', aliases.size);
-    console.log('Command names size:', commandNames.size);
-    const prefixPath = botData.get('prefixPath') as string;
+        const prefixPath =  botData.get('prefixPath') as string;
 
-    logInfo(`Reloading prefix commands from ${prefixPath}`);
+        commands.clear();
+        aliases.clear();
+        commandNames.clear();
+        client.prefixCommands = [];
+        client.prefixSize = 0;
 
-    try {
-        await readCommands(client, { path: prefixPath });
+        const resolvedPath = resolve(process.cwd(), prefixPath);
+        const dirents = await readdir(resolvedPath, { withFileTypes: true });
         
-        commands.forEach((_, name) => {
-            if (!currentCommandNames.has(name)) {
-                logWarning(`Removed old command: ${name}`);
+        const filePaths: string[] = [];
+        for (const dirent of dirents) {
+            if (dirent.isDirectory()) {
+                const folderPath = join(resolvedPath, dirent.name);
+                const files = await readdir(folderPath);
+                for (const file of files) {
+                    if (validExtensions.includes(extname(file))) {
+                        filePaths.push(join(folderPath, file));
+                    }
+                }
+            } else if (validExtensions.includes(extname(dirent.name))) {
+                filePaths.push(join(resolvedPath, dirent.name));
             }
-        });
+        }
 
-        logSuccess(`Successfully reloaded prefix commands.`);
-        return true;
+        for (const filePath of filePaths) {
+            delete require.cache[require.resolve(filePath)];
+        }
+
+        const commandDetails = await readCommands(client, { path: prefixPath });
+        client.prefixCommands = commandDetails;
+        client.prefixSize = commandDetails.length;
+        
+        return { commands: commands, success: true };
     } catch (error: any) {
-        logError(`Error reloading prefix commands: ${error.message}`);
-        return false;
+        logError('Error reloading commands:');
+        logError(error.message);
+
+        return { commands: new Collection(), success: false };
     }
 }

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) {
@@ -31,7 +31,6 @@ export async function registerSlashCommands(client: any, token: string, slash: S
                                 command.data.cooldown = command.cooldown || 0;
                             }
                             slashCommands.set(command.data.name, command);
-                            logInfo(`Loaded command: ${command.data.name}`);
                         }
                     } catch (error: any) {
                         logError(`Error in file: ${path.join(folderPath, file)}`);
@@ -46,7 +45,6 @@ export async function registerSlashCommands(client: any, token: string, slash: S
                             command.data.cooldown = command.cooldown || 0;
                         }
                         slashCommands.set(command.data.name, command);
-                        logInfo(`Loaded command: ${command.data.name}`);
                     }
                 } catch (error: any) {
                     logError(`Error in file: ${path.join(resolvedPath, dirent.name)}`);
@@ -58,24 +56,23 @@ 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:');
         logError(error.message);
+        console.error(error);
+
     }
 
     client.slashCommands = slashCommands;

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

@@ -118,6 +118,7 @@ export async function loadSlash(client: Client, token: string, options: SlashOpt
         } catch (error: any) {
             logError(`Error executing command "${command.data.name}":`);
             logError(error.message);
+            console.error(error);
             if (interaction.channel) {
                 await interaction.channel.send({ content: 'An error occurred while executing the command.' });
             }

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

@@ -1,19 +1,71 @@
-import { logSuccess, logError, logInfo } from '../functions/logger';
-import { registerSlashCommands } from './slash-register';
+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';
 
-export async function slashLoader(client: any, token: string, global: boolean, serverId?: string) {
-    client.slashCommands.clear();
-    const slashPath = botData.get('slashCommands') as string;
-
-    logInfo(`Reloading slash commands from ${slashPath}`);
+const validExtensions = ['.js', '.ts'];
 
+export async function slashLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
     try {
-        const newSlashCommands = await registerSlashCommands(client, token, { path: slashPath, global, serverId });
-        logSuccess(`Successfully reloaded ${newSlashCommands.size} slash commands.`);
-        return true
+        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: ${error.message}`);
-        return false
+        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';
@@ -17,16 +16,13 @@ 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)
-            }            
+            }          
             if (options.bot) {
                 await login(djs, options);
             }
+            if (options.anticrash?.enable) {
+                await AntiCrash(djs, options)
+            }  
         } catch (error: any) {
             console.error('An error occurred during bot startup:', error.message);
             await this.handleStartupError(error, djs, options);

package/lib/discord/functions/logger.ts

@@ -25,10 +25,18 @@ export function logSuccess(message: string) {
     console.log(`${getTimestamp()} ${green}${successEmoji}${reset} ${green}${message}${reset}`);
 }
 
-export function logError(message: string) {
-    console.error(`${getTimestamp()} ${red}${errorEmoji}${reset} ${red}${message}${reset}`);
+export function logError(message: string, error?: Error) {
+    const timestamp = getTimestamp();
+    const baseMessage = `${timestamp} ${red}${errorEmoji}${reset} ${red}${message}${reset}`;
+
+    if (error && error.stack) {
+        console.error(`${baseMessage}\n${error.stack}`);
+    } else {
+        console.error(baseMessage);
+    }
 }
 
+
 export function logInfo(message: string) {
     console.log(`${getTimestamp()} ${cyan}${infoEmoji}${reset} ${cyan}${message}${reset}`);
 }

package/lib/discord/types/starter.ts

@@ -47,6 +47,10 @@ export interface PrefixOptions {
     prefix: string;
     global?: boolean;
     serverIds?: string[];
+    customPrefix?: {
+        serverId: string;
+        prefix: string;
+    }[];
     logsId?: string;
 }
 
@@ -102,9 +106,12 @@ export interface Command {
     cooldown?: number;
     usage?: string;
     developer?: boolean;
-    prefix?: boolean;
     category?: string;
+    fastUse?: boolean;
+    botPerms?: string[];
+    userPerms?: string[];
     owner?: boolean;
+    accessLevel?: string; 
 }
 
 export interface StarterOptions {

package/lib/discord/utils.ts

@@ -1,5 +1,14 @@
 import { Starter } from "./events-handler/starter";
 import { ButtonManager, MenuManager, PermissionChecker } from './builder/utils';
-import { prefixLoader } from "./events-handler/prefixLoader";
 import { slashLoader } from "./events-handler/slashLoader";
-export { Starter, ButtonManager, MenuManager, PermissionChecker, prefixLoader, slashLoader }
+import { prefixLoader } from "./events-handler/prefixLoader";
+import { eventLoader } from "./events-handler/eventLoader";
+import { readCommands } from "./events-handler/prefix-register";
+import { loadPrefix, handleMessageCreate } from "./events-handler/prefix-responder";
+import { registerSlashCommands } from "./events-handler/slash-register";
+import { loadSlash } from "./events-handler/slash-responder";
+import { logError, logInfo, logSuccess, logWarning  } from "./functions/logger";
+import { loadEvents, withRetry, processEventFile, processDirectory, limitConcurrency, countEventFiles } from "./events-handler/events";
+export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile, logError, logInfo, logSuccess, logWarning }

package/lib/index.ts

@@ -27,7 +27,14 @@ fetch("https://registry.npmjs.com/-/v1/search?text=djs-builder")
     .catch((e: any) => {});
 
 
-import { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader} from "./discord/utils";
+import { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile, logError, logInfo, logSuccess, logWarning } from "./discord/utils";
 
-export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader };
-export default { Starter, ButtonManager, MenuManager, PermissionChecker, prefixLoader, slashLoader };
+export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile , logError, logInfo, logSuccess, logWarning};
+export default { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile, logError, logInfo, logSuccess, logWarning };
+export * from './discord/types/starter';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-builder",
-  "version": "0.4.85",
+  "version": "0.5.1",
   "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
-    }
-}