djs-builder 0.4.6 → 0.4.7

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

@@ -2,6 +2,7 @@ import { Collection } from 'discord.js';
 import { promises as fsPromises } from 'fs';
 import { join, resolve } from 'path';
 import { Command } from '../types/utils';
+import { logSuccess, logError, logInfo } from '../functions/logger'; 
 
 export const commands = new Collection<string, Command>();
 export const aliases = new Collection<string, string>();
@@ -56,20 +57,23 @@ export async function readCommands(client: any, prefix: { path: string }): Promi
                             developer: defaultCommand.developer,
                             owner: defaultCommand.owner,
                         });
+
+                        logSuccess(`Loaded command: ${defaultCommand.name}`);
                     }
                 } catch (error: any) {
-                    console.error(`Error in file: ${filePath}`);
-                    console.error(error.message);
+                    logError(`Error in file: ${filePath}`);
+                    logError(error.message);
                 }
             }
         }
         
         client.prefixCommands = commandDetails;
         client.prefixSize = commandDetails.length;
+        logSuccess(`Successfully loaded ${commandDetails.length} commands.`);
         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);
         return [];
     }
 }

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

@@ -1,79 +1,20 @@
-import { Collection } from 'discord.js';
-import { promises as fsPromises } from 'fs';
-import { join, resolve, basename } from 'path';
-import { Command } from '../types/utils';
-import { botData } from './login';
+import { logSuccess, logError, logInfo } from '../functions/logger';
+import { commands, aliases, commandNames, readCommands } from './prefix-register';
 
-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, prefixPath: string) {
+    commands.clear();
+    aliases.clear();
+    commandNames.clear();
 
-export async function prefixLoader(client: any, basePath: 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 }> = [];
-    const prefixPath = botData.get('prefixPath') as string;
-    const resolvedBasePath = resolve(process.cwd(), prefixPath);
-    
-    try {
-        const resolvedPath = resolve(resolvedBasePath, basePath);
-        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()) {
-                if (basename(filePath) !== basename(__filename)) { // Avoid processing the current file
-                    const subCommandDetails = await prefixLoader(client, join(basePath, file.name));
-                    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
-                        };
+    logInfo(`Reloading prefix commands from ${prefixPath}`);
 
-                        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;
+    try {
+        const newCommandDetails = await readCommands(client, { path: prefixPath });
+        logSuccess(`Successfully reloaded ${newCommandDetails.length} prefix commands.`);
+        return true
     } catch (error: any) {
-        console.error(`⚠️ Error reading directory: ${prefixPath}`);
-        console.error(error.message);
-        return [];
+        logError(`Error reloading prefix commands: ${error.message}`);
+        return false
+
     }
-}
+}

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

@@ -4,11 +4,11 @@ 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'; 
 
 export async function registerSlashCommands(client: any, token: string, slash: SlashOptions): Promise<Collection<string, any>> {
-
     if (!token) {
-        throw new Error("⚠️ \x1b[33m%sPlease provide valid bot token to register slash commands.\x1b[0m");
+        throw new Error("⚠️ Please provide valid bot token to register slash commands.");
     }
 
     const slashCommands = new Collection<string, any>();
@@ -31,10 +31,11 @@ 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) {
-                        console.error(`⚠️ Error in file: ${path.join(folderPath, file)}`);
-                        console.error(error.message);
+                        logError(`Error in file: ${path.join(folderPath, file)}`);
+                        logError(error.message);
                     }
                 }
             } else {
@@ -45,10 +46,11 @@ 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) {
-                    console.error(`⚠️ Error in file: ${path.join(resolvedPath, dirent.name)}`);
-                    console.error(error.message);
+                    logError(`Error in file: ${path.join(resolvedPath, dirent.name)}`);
+                    logError(error.message);
                 }
             }
         }
@@ -56,20 +58,24 @@ 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 {
-                console.error(`⚠️ Guild with ID ${slash.serverId} not found.`);
+                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) {
-        console.error('⚠️ Error registering slash commands:', error.message);
+        logError('Error registering slash commands:');
+        logError(error.message);
     }
 
     client.slashCommands = slashCommands;

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

@@ -1,12 +1,13 @@
 import { Client, Collection, Interaction, EmbedBuilder, Snowflake, PermissionResolvable } from 'discord.js';
 import { registerSlashCommands } from './slash-register';
 import { SlashOptions } from '../types/starter';
+import { logWarning, logError, logInfo } from '../functions/logger';
 
 export async function loadSlash(client: Client, token: string, options: SlashOptions): Promise<void> {
     const slashCommands = await registerSlashCommands(client, token, options);
 
     if (!slashCommands || slashCommands.size === 0) {
-        console.warn('\x1b[33m%s\x1b[0m', '⚠️ No registered slash commands. SlashHandler won\'t work.');
+        logWarning('No registered slash commands. SlashHandler won\'t work.');
         return;
     }
 
@@ -58,7 +59,8 @@ export async function loadSlash(client: Client, token: string, options: SlashOpt
             interactionCooldowns.set(interaction.user.id, userCooldowns);
         }
 
- 
+        const startExecutionTime = Date.now();
+
         try {
             if (command.run) {
                 if (command.run.length === 2) {
@@ -66,17 +68,16 @@ export async function loadSlash(client: Client, token: string, options: SlashOpt
                 } else {
                   await command.run(interaction);
                 }
-              }
-              else if (command.execute) {
+            }
+            else if (command.execute) {
                 if (command.execute.length === 2) {
                   await command.execute(interaction, client);
                 } else {
                   await command.execute(interaction);
                 }
             } else {
-                console.warn('⚠️ \x1b[33m%s\x1b[0m', `Command "${command.data.name}" has neither run nor execute method.`);
+                logWarning(`Command "${command.data.name}" has neither run nor execute method.`);
             }
-            const startExecutionTime = Date.now();
 
             const channel = interaction.guild.channels.cache.get(options.logsId || '') as any;
             const userName = interaction.user.username;
@@ -84,38 +85,39 @@ export async function loadSlash(client: Client, token: string, options: SlashOpt
             const serverName = interaction.guild.name || 'Unknown Server';
             const serverId = interaction.guild.id || 'Unknown ID';
             let messageLink = '';
-    
+
             if (interaction.channel) {
                 messageLink = `https://discord.com/channels/${serverId}/${interaction.channel.id}/${interaction.id}`;
             } else {
                 messageLink = 'Unknown';
             }
-    
-    
+
             const embedLog = new EmbedBuilder()
-            .setColor("Blue")
-            .setThumbnail(interaction.client.user?.displayAvatarURL())
-            .setTitle("Use Slash Command")
-            .setTimestamp()
-            .addFields(
-                { name: "📧 Cmd:", value: `- ${command.data.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 }
-            );
+                .setColor("Blue")
+                .setThumbnail(interaction.client.user?.displayAvatarURL())
+                .setTitle("Use Slash Command")
+                .setTimestamp()
+                .addFields(
+                    { name: "📧 Cmd:", value: `- ${command.data.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 (options.logsId && channel) {
                 await channel.send({ embeds: [embedLog] });
             }
 
             const executionTime = Date.now() - startExecutionTime;
             if (executionTime > 3000) {
-                console.log('⚠️ \x1b[33m%s\x1b[0m', `Command "${command.data.name}" took ${executionTime}ms to execute.`);
+                logInfo(`Command "${command.data.name}" took ${executionTime}ms to execute.`);
             }
-        } catch (error) {
-            console.error('\x1b[31m%s\x1b[0m', `⚠️ Error executing command "${command.data.name}":`, error);
+        } catch (error: any) {
+            logError(`Error executing command "${command.data.name}":`);
+            logError(error.message);
             if (interaction.channel) {
                 await interaction.channel.send({ content: 'An error occurred while executing the command.' });
             }

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

@@ -1,83 +1,17 @@
-import { Collection, Guild } from 'discord.js';
-import { REST } from '@discordjs/rest';
-import { Routes } from 'discord-api-types/v10';
-import { readdir } from 'fs/promises';
-import { botData } from './login';
-import path from 'path';
-export async function slashLoader(client: any): Promise<Collection<string, any>> {
+import { logSuccess, logError, logInfo } from '../functions/logger';
+import { registerSlashCommands } from './slash-register';
 
-    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;
-    
+export async function slashLoader(client: any, token: string, slashPath: string, global: boolean, serverId?: string) {
+    client.slashCommands.clear();
 
-    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);
+    logInfo(`Reloading slash commands from ${slashPath}`);
 
     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}` } });
-        }
+        const newSlashCommands = await registerSlashCommands(client, token, { path: slashPath, global, serverId });
+        logSuccess(`Successfully reloaded ${newSlashCommands.size} slash commands.`);
+        return true
     } catch (error: any) {
-        console.error('⚠️ Error registering slash commands:', error.message);
+        logError(`Error reloading slash commands: ${error.message}`);
+        return false
     }
-
-    client.slashCommands = slashCommands;
-    client.slashSize = slashCommands.size;
-    return slashCommands;
 }

package/lib/discord/functions/logger.ts

@@ -0,0 +1,39 @@
+const successEmoji = '✅';
+const errorEmoji = '❌';
+const infoEmoji = 'ℹ️';
+const warningEmoji = '⚠️';
+
+const green = '\x1b[32m'; 
+const red = '\x1b[31m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+const yellow = '\x1b[33m';
+
+
+function getTimestamp(): string {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    return `[${year}-${month}-${day} ${hours}:${minutes}:${seconds}]`;
+}
+
+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 logInfo(message: string) {
+    console.log(`${getTimestamp()} ${cyan}${infoEmoji}${reset} ${cyan}${message}${reset}`);
+}
+
+
+export function logWarning(message: string) {
+    console.warn(`${getTimestamp()} ${yellow}${warningEmoji}${reset} ${yellow}${message}${reset}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-builder",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Discord.js bot builder. Supports Ts and Js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",