djs-builder 0.4.85 → 0.5.1

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

@@ -0,0 +1,130 @@
+import { Collection } from 'discord.js';
+import { readdir } from 'fs/promises';
+import { resolve, extname } from 'path';
+import { EventsOptions, Event } from '../types/utils';
+import { logError, logInfo } from '../functions/logger';
+import { botData } from './login';
+const validExtensions = ['.js', '.ts'];
+
+export async function eventLoader(client: any, eventsOptions: EventsOptions): Promise<{ events: Collection<string, Event>; success: boolean }> {
+    try {
+        const eventsPath = botData.get('eventsPath') as string;
+        const eventPath = resolve(process.cwd(), eventsPath);
+
+        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(eventPath);
+        if (files.length === 0) {
+            logInfo(`No event files found in directory \`${eventPath}\`.`);
+            return { events: new Collection<string, Event>(), success: false };
+        }
+
+        client.removeAllListeners();
+
+        for (const file of files) {
+            delete require.cache[require.resolve(file)];
+            logInfo(`Unlinked cached module: ${file}`);
+        }
+
+        const newEvents = new Collection<string, Event>();
+        for (const file of files) {
+            try {
+                const event: Event = await import(file);
+                if (eventsOptions.eventBlacklist?.includes(file)) {
+                    continue;
+                }
+
+                let eventHandler: (...args: any[]) => Promise<void> = async (...args: any[]) => {
+                    if (event.initializer) {
+                        await new Promise(resolve => setTimeout(resolve, event.initializer));
+                    }
+                    await event.execute(...args, client);
+
+                    if (event.interval) {
+                        if (event.intervalId) clearInterval(event.intervalId);
+                        event.intervalId = setInterval(async () => {
+                            await event.execute(...args, client);
+                        }, event.interval);
+                    }
+                };
+
+                if (event.once) {
+                    client.once(event.name, eventHandler);
+                } else {
+                    client.on(event.name, eventHandler);
+                }
+
+                if (event.maxExecution !== undefined) {
+                    eventHandler = await limitConcurrency(eventHandler, event.maxExecution);
+                }
+
+                if (event.retryAttempts !== undefined) {
+                    eventHandler = await withRetry(eventHandler, event.retryAttempts);
+                }
+
+                newEvents.set(event.name, event);
+            } catch (error: any) {
+                logError(`Error re-importing file: ${file}`);
+                logError(error.message, error);
+            }
+        }
+
+        client.eventSize = newEvents.size;
+
+        return { events: newEvents, success: true };
+    } catch (error: any) {
+        logError('Error reloading events:');
+        logError(error.message, error);
+        return { events: new Collection<string, Event>(), success: false };
+    }
+}
+
+async function limitConcurrency(handler: (...args: any[]) => void, maxConcurrentExecutions: number): Promise<(...args: any[]) => Promise<void>> {
+    let executing = 0;
+    const queue: any[] = [];
+
+    return async function(...args: any[]) {
+        if (executing < maxConcurrentExecutions) {
+            executing++;
+            await handler(...args);
+            executing--;
+
+            if (queue.length > 0) {
+                const next = queue.shift();
+                next();
+            }
+        } else {
+            queue.push(() => handler(...args));
+        }
+    };
+}
+
+async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttempts: number): Promise<(...args: any[]) => Promise<void>> {
+    return async function(...args: any[]) {
+        let attempts = 0;
+        while (attempts < retryAttempts) {
+            try {
+                await handler(...args);
+                return;
+            } catch (error: any) {
+                logError('Error executing event:');
+                logError(error.message, error);
+                attempts++;
+            }
+        }
+        logError('Reached maximum retry attempts.');
+    };
+}

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

@@ -1,11 +1,11 @@
-import { logSuccess, logError } from '../functions/logger';
 import { readdir, stat } from 'fs/promises';
 import { resolve, join, extname } from 'path';
 import { EventsOptions, Event } from '../types/utils';
+import { logError } from '../functions/logger';
 
 const validExtensions = ['.js', '.ts'];
 
-async function processEventFile(client: any, eventsOptions: EventsOptions, filePath: string) {
+export async function processEventFile(client: any, eventsOptions: EventsOptions, filePath: string) {
     try {
         const resolvedPath = resolve(process.cwd(), filePath);
         const stats = await stat(resolvedPath);
@@ -48,11 +48,11 @@ async function processEventFile(client: any, eventsOptions: EventsOptions, fileP
         }
     } catch (error: any) {
         logError(`Error in event file: ${filePath}`);
-        logError(error.message);
+        logError(error.message, error);
     }
 }
 
-async function limitConcurrency(handler: (...args: any[]) => void, maxConcurrentExecutions: number): Promise<(...args: any[]) => Promise<void>> {
+export async function limitConcurrency(handler: (...args: any[]) => void, maxConcurrentExecutions: number): Promise<(...args: any[]) => Promise<void>> {
     let executing = 0;
     const queue: any[] = [];
 
@@ -72,7 +72,7 @@ async function limitConcurrency(handler: (...args: any[]) => void, maxConcurrent
     };
 }
 
-async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttempts: number): Promise<(...args: any[]) => Promise<void>> {
+export async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttempts: number): Promise<(...args: any[]) => Promise<void>> {
     return async function(...args: any[]) {
         let attempts = 0;
         while (attempts < retryAttempts) {
@@ -81,7 +81,7 @@ async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttemp
                 return; 
             } catch (error: any) {
                 logError('Error executing event:');
-                logError(error.message);
+                logError(error.message, error);
                 attempts++;
             }
         }
@@ -89,7 +89,7 @@ async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttemp
     };
 }
 
-async function processDirectory(client: any, eventsOptions: EventsOptions, directoryPath: string) {
+export async function processDirectory(client: any, eventsOptions: EventsOptions, directoryPath: string) {
     try {
         const filesInDirectory = await readdir(directoryPath);
         for (const file of filesInDirectory) {
@@ -103,7 +103,7 @@ async function processDirectory(client: any, eventsOptions: EventsOptions, direc
         }
     } catch (error: any) {
         logError(`Error while processing directory: ${directoryPath}`);
-        logError(error.message);
+        logError(error.message, error);
     }
 }
 
@@ -123,14 +123,13 @@ export async function loadEvents(client: any, eventsOptions: EventsOptions) {
 
         const eventCount = await countEventFiles(eventsOptions.path, eventsOptions);
         client.eventSize = eventCount;
-        logSuccess(`Loaded ${eventCount} events successfully.`);
     } catch (error: any) {
         logError(`Error while loading events from path: ${eventsOptions.path}`);
-        logError(error.message);
+        logError(error.message, error);
     }
 }
 
-async function countEventFiles(filePath: string, eventsOptions: EventsOptions): Promise<number> {
+export async function countEventFiles(filePath: string, eventsOptions: EventsOptions): Promise<number> {
     let count = 0;
     try {
         const resolvedPath = resolve(process.cwd(), filePath);
@@ -154,7 +153,7 @@ async function countEventFiles(filePath: string, eventsOptions: EventsOptions):
         }
     } catch (error: any) {
         logError(`Error counting event files in directory: ${filePath}`);
-        logError(error.message);
+        logError(error.message, error);
     }
     return count;
 }

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

@@ -3,9 +3,11 @@ import { StarterOptions } from '../types/starter';
 import { loadPrefix } from './prefix-responder';
 import { loadSlash } from './slash-responder';
 import { readCommands } from './prefix-register';
+
 export const botData = new Collection<string, string | string[]>();
 import * as path from 'path';
 import fs from 'fs';
+import { loadEvents } from './events';
 export async function login(djs: Client, options: StarterOptions) { 
 
     if (!djs) {
@@ -57,6 +59,10 @@ export async function login(djs: Client, options: StarterOptions) {
             botData.set('developers', options.bot.BotInfo.developers); 
         }
 
+        if (options.events) {
+            await loadEvents(djs, options.events);
+            botData.set('eventsPath', options.events.path);
+        }
 
         if (options.prefix) {
             await readCommands(djs, options.prefix)
@@ -66,7 +72,7 @@ export async function login(djs: Client, options: StarterOptions) {
         }
         if (options.slash && options.bot.token) {
             await loadSlash(djs, options.bot?.token, options.slash);
-            botData.set('slashCommands', options.slash.path);
+            botData.set('slashCommandPath', options.slash.path);
             if (options.slash.serverId) botData.set('serverIdSlash', options.slash.serverId); 
             if (options.slash.global === true) botData.set('globalSlash', 'true'); 
             if (options.slash.global === false) botData.set('globalSlash', 'false'); 

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

@@ -2,13 +2,40 @@ import { Collection } from 'discord.js';
 import { promises as fsPromises } from 'fs';
 import { join, resolve } from 'path';
 import { Command } from '../types/utils';
+import { logError } from '../functions/logger';
 
 export const commands = new Collection<string, Command>();
 export const aliases = new Collection<string, string>();
 export const commandNames = new Set<string>();
 
-export async function readCommands(client: any, prefix: { path: string }): 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 }> = [];
+export async function readCommands(client: any, prefix: { path: string }): Promise<Array<{ 
+    name: string; 
+    usage: string | undefined; 
+    description: string | undefined; 
+    aliases: string[] | undefined; 
+    cooldown: number | undefined; 
+    developer: boolean | undefined; 
+    owner: boolean | undefined;
+    fastUse: boolean | undefined;
+    botPerms: string[] | undefined;
+    userPerms: string[] | undefined;
+    category: string | undefined;
+    accessLevel: string | undefined; 
+}>> {
+    const commandDetails: Array<{ 
+        name: string; 
+        usage: string | undefined; 
+        description: string | undefined; 
+        aliases: string[] | undefined; 
+        cooldown: number | undefined; 
+        developer: boolean | undefined; 
+        owner: boolean | undefined;
+        fastUse: boolean | undefined;
+        botPerms: string[] | undefined;
+        userPerms: string[] | undefined;
+        category: string | undefined;
+        accessLevel: string | undefined;
+    }> = [];
 
     try {
         const resolvedPath = resolve(process.cwd(), prefix.path);
@@ -34,6 +61,11 @@ export async function readCommands(client: any, prefix: { path: string }): Promi
                             aliases: [],
                             developer: false,
                             owner: false,
+                            fastUse: false,
+                            botPerms: [],
+                            userPerms: [],
+                            category: "Uncategorized",
+                            accessLevel: undefined, 
                             ...command
                         };
 
@@ -55,11 +87,16 @@ export async function readCommands(client: any, prefix: { path: string }): Promi
                             cooldown: defaultCommand.cooldown,
                             developer: defaultCommand.developer,
                             owner: defaultCommand.owner,
+                            fastUse: defaultCommand.fastUse,
+                            botPerms: defaultCommand.botPerms,
+                            userPerms: defaultCommand.userPerms,
+                            category: defaultCommand.category || 'Uncategorized',
+                            accessLevel: defaultCommand.accessLevel,
                         });
                     }
                 } catch (error: any) {
-                    console.error(`Error in file: ${filePath}`);
-                    console.error(error.message);
+                    logError(`Error in file: ${filePath}`);
+                    logError(error.message, error);
                 }
             }
         }
@@ -68,8 +105,8 @@ export async function readCommands(client: any, prefix: { path: string }): Promi
         client.prefixSize = commandDetails.length;
         return commandDetails;
     } catch (error: any) {
-        console.error(`⚠️ Error reading directory: ${prefix.path}`);
-        console.error(error.message);
+        logError(`⚠️ Error reading directory: ${prefix.path}`);
+        logError(error.message, error);
         return [];
     }
 }

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

@@ -1,53 +1,62 @@
 import { Client, Message, Collection, EmbedBuilder, TextChannel, PermissionResolvable } from 'discord.js';
 import { commands, aliases } from './prefix-register';
 import { PrefixOptions } from '../types/utils';
-import { getSimilarCommands } from '../functions/utils'
+import { getSimilarCommands } from '../functions/utils';
 import { botData } from './login';
+import { logError } from '../functions/logger'; 
+
 const cooldowns: Collection<string, Collection<string, number>> = new Collection();
 
-async function handleMessageCreate(message: Message, prefix: PrefixOptions): Promise<void> {
-    const botPrefix = prefix.prefix || '!';
+export async function handleMessageCreate(message: Message, prefixOptions: PrefixOptions): Promise<void> {
+    let botPrefix = prefixOptions.prefix || '!';
     const developers = botData.get('developers') as string[] | undefined;
     const ownerId = botData.get('ownerId') as string;
 
-    if (message.guild?.members.me) {
+    if (message.guild) {
+        const customPrefixEntry = prefixOptions.customPrefix?.find(entry => entry.serverId === message.guild?.id);
+        if (customPrefixEntry) {
+            botPrefix = customPrefixEntry.prefix;
+        }
+    }
+
+    if (message.guild && message.guild.members.me) {
         const user = message.author;
-        const botData = new Collection<string, string | string[]>();
-        const permissionsArray = botData.get('permissions') as string[] | undefined;
+        const botPermissions = message.guild.members.me.permissions;
 
-        if (!message.guild.members.me.permissions.has('SendMessages')) {
+        if (!botPermissions.has('SendMessages')) {
             try {
-                user.send({ content:"I'm sorry, but I don't have permission to send messages in this server."});
-            } catch (error) {
+                await user.send("I'm sorry, but I don't have permission to send messages in this server.");
+            } catch (error: any) {
+                logError("Failed to send permission error message to user.", error);
                 return;
             }
         }
-    
+
+        const permissionsArray = botData.get('permissions') as string[] | undefined;
         if (permissionsArray && permissionsArray.length > 0) {
-            const missingPermissions = permissionsArray.filter(permission => !message.guild?.members.me?.permissions.has(permission as PermissionResolvable));
-    
+            const missingPermissions = permissionsArray.filter(permission => !botPermissions.has(permission as PermissionResolvable));
+
             if (missingPermissions.length > 0) {
                 try {
-                    user.send({ content:`I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.`});
-                } catch (error) {
+                    await user.send(`I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.`);
+                } catch (error: any) {
+                    logError("Failed to send missing permissions message to user.", error);
                     return;
                 }
             }
         }
     }
-        
-
-    if (!message.content.startsWith(botPrefix) || message.author.bot) return;
-
-    if (prefix.global === false && prefix.serverIds && prefix.serverIds.length > 0) {
 
-        const guildId = message.guild?.id;
-        if (guildId && !prefix.serverIds.includes(guildId)) return;
+    let args = [];
+    let commandName: string | undefined;
 
+    if (message.content.startsWith(botPrefix)) {
+        args = message.content.slice(botPrefix.length).trim().split(/ +/);
+        commandName = args.shift()?.toLowerCase();
     } else {
-
-    const args = message.content.slice(botPrefix.length).trim().split(/ +/);
-    const commandName = args.shift()?.toLowerCase();
+        commandName = message.content.split(/ +/)[0].toLowerCase();
+        args = message.content.split(/ +/).slice(1);
+    }
 
     if (!commandName || (!commands.has(commandName) && !aliases.has(commandName))) return;
 
@@ -68,7 +77,6 @@ async function handleMessageCreate(message: Message, prefix: PrefixOptions): Pro
         return;
     }
 
-
     if (command.developer) {
         if (developers && !developers.includes(message.author.id)) {
             if (message.author.id === ownerId) return;
@@ -77,6 +85,78 @@ async function handleMessageCreate(message: Message, prefix: PrefixOptions): Pro
         }
     }
 
+    if (message.guild) {
+        if (command.botPerms && command.botPerms.length > 0) {
+            const missingBotPerms = command.botPerms.filter(perm => !message.guild?.members.me?.permissions.has(perm as PermissionResolvable));
+            if (missingBotPerms.length > 0) {
+                await message.reply(`I'm missing the following permissions to execute this command: ${missingBotPerms.join(', ')}`);
+                return;
+            }
+        }
+
+        if (command.userPerms && command.userPerms.length > 0) {
+            const member = message.guild.members.cache.get(message.author.id);
+            if (member) {
+                const missingUserPerms = command.userPerms.filter(perm => !member.permissions.has(perm as PermissionResolvable));
+                if (missingUserPerms.length > 0) {
+                    await message.reply(`You are missing the following permissions to use this command: ${missingUserPerms.join(', ')}`);
+                    return;
+                }
+            }
+        }
+
+        if (command.accessLevel) {
+            const member = message.guild.members.cache.get(message.author.id);
+            if (member) {
+                const highestRole = member.roles.highest;
+                if (highestRole.id !== command.accessLevel) {
+                    await message.reply("You do not have the required role to use this command.");
+                    return;
+                }
+            }
+        }
+    }
+
+    if (command.fastUse && !message.content.startsWith(botPrefix)) {
+        try {
+            if (command.run) {
+                await command.run(message.client, message, args);
+            } else if (command.execute) {
+                await command.execute(message.client, message, args);
+            }
+
+            if (message.guild) {
+                const channel = message.guild.channels.cache.get(prefixOptions.logsId || '') as TextChannel | undefined;
+                const userName = message.author.username;
+                const userId = message.author.id;
+                const serverName = message.guild.name || null;
+                const serverId = message.guild.id || null;
+                const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
+
+                const embedLog = new EmbedBuilder()
+                    .setColor("Blue")
+                    .setThumbnail(message.client.user?.displayAvatarURL())
+                    .setTitle("Use Prefix Command")
+                    .setTimestamp()
+                    .addFields(
+                        { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
+                        { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                        { name: "\u200B", value: "\u200B", inline: true },
+                        { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                        { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                        { name: "\u200B", value: "\u200B", inline: true },
+                        { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+                    );
+
+                if (prefixOptions.logsId && channel) {
+                    await channel.send({ embeds: [embedLog] });
+                }
+            }
+        } catch (error: any) {
+            logError(`Error executing command ${command.name}`, error);
+        }
+        return;
+    }
 
     const now = Date.now();
     const timestamps = cooldowns.get(command.name) || new Collection<string, number>();
@@ -96,53 +176,53 @@ async function handleMessageCreate(message: Message, prefix: PrefixOptions): Pro
     setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
     cooldowns.set(command.name, timestamps);
 
-
     try {
         if (command.run) {
-             command.run(message.client, message, args);
+            await command.run(message.client, message, args);
         } else if (command.execute) {
-             command.execute(message.client, message, args);
+            await command.execute(message.client, message, args);
         }
 
-        const channel = message.guild?.channels.cache.get(prefix.logsId || '') as TextChannel | undefined;
-        const userName = message.author.username;
-        const userId = message.author.id;
-        const serverName = message.guild?.name || null;
-        const serverId = message.guild?.id || null;
-        const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
-    
-        const embedLog = new EmbedBuilder()
-            .setColor("Blue")
-            .setThumbnail(message.client.user?.displayAvatarURL())
-            .setTitle("Use Prefix Command")
-            .setTimestamp()
-            .addFields(
-                { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
-                { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
-                { name: "\u200B", value: "\u200B", inline: true },
-                { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
-                { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
-                { name: "\u200B", value: "\u200B", inline: true },
-                { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
-            );
-
-        if (prefix.logsId && channel) {
-            await channel.send({ embeds: [embedLog] });
+        if (message.guild) {
+            const channel = message.guild.channels.cache.get(prefixOptions.logsId || '') as TextChannel | undefined;
+            const userName = message.author.username;
+            const userId = message.author.id;
+            const serverName = message.guild.name || null;
+            const serverId = message.guild.id || null;
+            const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
+
+            const embedLog = new EmbedBuilder()
+                .setColor("Blue")
+                .setThumbnail(message.client.user?.displayAvatarURL())
+                .setTitle("Use Prefix Command")
+                .setTimestamp()
+                .addFields(
+                    { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
+                    { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                    { name: "\u200B", value: "\u200B", inline: true },
+                    { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                    { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                    { name: "\u200B", value: "\u200B", inline: true },
+                    { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+                );
+
+            if (prefixOptions.logsId && channel) {
+                await channel.send({ embeds: [embedLog] });
+            }
         }
-    } catch (error) {
-        console.error(`⚠️ \x1b[33m%s Error executing command ${command.name}\x1b[0m:`, error);
+    } catch (error: any) {
+        logError(`Error executing command ${command.name}`, error);
     }
-  }
 }
 
 export async function loadPrefix(client: Client, prefix: PrefixOptions): Promise<void> {
     if (!prefix.prefix) {
-        throw new Error("⚠️ \x1b[33m%s No command prefix provided. Please provide a command prefix.\x1b[0m");
+        throw new Error("⚠️ No command prefix provided. Please provide a command prefix.");
     }
 
-    try { 
-        client.on("messageCreate", async message => await handleMessageCreate(message, prefix));
-    } catch (error) {
-        console.error('⚠️ \x1b[33m%s An error occurred while loading prefix\x1b[0m:', error);
+    try {
+        client.on("messageCreate", async (message) => await handleMessageCreate(message, prefix));
+    } catch (error: any) {
+        logError("An error occurred while loading prefix.", error);
     }
-}
+}