djs-builder 0.5.41 → 0.6.0

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

@@ -1,176 +0,0 @@
-import { Client, Message, Collection, EmbedBuilder, TextChannel, PermissionResolvable } from 'discord.js';
-import { getSimilarCommands } from '../functions/utils';
-import { botData } from './login';
-import { logError } from '../functions/logger';
-import { PrefixOptions } from '../types/starter';
-
-const cooldowns: Collection<string, Collection<string, number>> = new Collection();
-
-export async function handleMessageCreate(message: Message, prefixOptions: PrefixOptions): Promise<void> {
-    if (message.author.bot) return;
-
-    let botPrefix = prefixOptions.prefix || '!';
-    const developers = botData.get('developers') as string[] | undefined;
-    const ownerId = botData.get('ownerId') as string;
-
-    if (message.guild) {
-        const customPrefixEntry = prefixOptions.customPrefix?.find(entry => entry.serverId === message.guild?.id);
-        if (customPrefixEntry) {
-            botPrefix = customPrefixEntry.prefix;
-        }
-    }
-
-    let args = [];
-    let commandName: string | undefined;
-
-    if (message.content.startsWith(botPrefix)) {
-        args = message.content.slice(botPrefix.length).trim().split(/ +/);
-        commandName = args.shift()?.toLowerCase();
-    } else {
-        commandName = message.content.split(/ +/)[0].toLowerCase();
-        args = message.content.split(/ +/).slice(1);
-    }
-
-    if (!commandName) return;
-
-    const command = (message.client as any).prefixCommands.find((cmd: any) => cmd.name === commandName) 
-                  || (message.client as any).prefixCommands.find((cmd: any) => cmd.aliases.includes(commandName));
-
-    if (!command) {
-        if (message.content.startsWith(botPrefix) && prefixOptions.similarity) {
-            const similarCommands = getSimilarCommands(commandName, (message.client as any).prefixCommands);
-            if (similarCommands.length > 0) {
-                await message.reply(`Command not found. Did you mean: ${similarCommands.join(', ')}?`);
-            } else {
-                await message.reply(`Command '${commandName}' doesn't exist.`);
-            }
-        }
-        return;
-    }
-
-
-    if (command.owner && message.author.id !== ownerId) {
-        await message.reply(`Only the bot owner can use this command.`);
-        return;
-    }
-
-    if (command.developer && (!developers || !developers.includes(message.author.id)) && message.author.id !== ownerId) {
-        await message.reply("You are not authorized to use this command.");
-        return;
-    }
-
-    if (message.guild) {
-        if (command.botPerms && command.botPerms.length > 0) {
-            const missingBotPerms = command.botPerms.filter((perm: any) => !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: any) => !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 accessRole = message.guild.roles.cache.get(command.accessLevel);
-                if (!accessRole) {
-                    await message.reply("The required role does not exist in this server.");
-                    return;
-                }
-
-                const hasRequiredRole = member.roles.cache.some(role => role.id === command.accessLevel || role.position > accessRole.position);
-                if (!hasRequiredRole) {
-                    await message.reply("You do not have the required role or a role higher than it to use this command.");
-                    return;
-                }
-            }
-        }
-    }
-
-    // Handle cooldowns
-    const now = Date.now();
-    const timestamps = cooldowns.get(command.name) || new Collection<string, number>();
-    const cooldownAmount = (command.cooldown || 3) * 1000;
-
-    if (timestamps.has(message.author.id)) {
-        const expirationTime = timestamps.get(message.author.id) || 0;
-        const timeLeft = (expirationTime - now) / 1000;
-
-        if (now < expirationTime) {
-            await message.reply(`Please wait ${timeLeft.toFixed(1)} more second(s) before reusing the \`${command.name}\` command.`);
-            return;
-        }
-    }
-
-    timestamps.set(message.author.id, now);
-    setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
-    cooldowns.set(command.name, timestamps);
-
-    try {
-        if (command && command.fastUse && !message.content.startsWith(botPrefix)) {
-            if (command.method) {
-                command.method(message.client, message, args);
-            } else {
-                logError(`Error executing command ${command.name}`);
-            }
-        }
-        else {
-            if (command && command.method) {
-                command.method(message.client, message, args);
-            } else {
-                logError(`Error executing command ${command.name}`);
-            }
-        }
-        if (message.guild && prefixOptions.logsId && commandName) {
-            const channel = message.guild.channels.cache.get(prefixOptions.logsId) as TextChannel;
-            if (channel) {
-                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: `- ${commandName}`, 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 }
-                    );
-
-                await channel.send({ embeds: [embedLog] });
-            }
-        }
-    } 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("⚠️ No command prefix provided. Please provide a command prefix.");
-    }
-
-    try {
-        client.on("messageCreate", async (message) => await handleMessageCreate(message, prefix));
-    } catch (error: any) {
-        logError("An error occurred while loading prefix.", error);
-    }
-}

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

@@ -1,83 +0,0 @@
-import { Client, 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, logInfo } from '../functions/logger';
-import { botData } from './login';
-import { watch } from 'fs';
-const validExtensions = ['.js', '.ts'];
-
-export async function prefixLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
-    try {
-
-        const prefixPath =  botData.get('prefixPath') as string;
-
-        commands.clear();
-        aliases.clear();
-        commandNames.clear();
-        client.prefixCommands = [];
-        client.prefixSize = 0;
-
-        const resolvedPath = resolve(process.cwd(), prefixPath);
-        const dirents = await readdir(resolvedPath, { withFileTypes: true });
-        
-        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));
-            }
-        }
-
-        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 commands:');
-        logError(error.message, error);
-
-        return { commands: new Collection(), success: false };
-    }
-}
-
-
-export function autoPrefixLoader(client: Client, DEBOUNCE_DELAY: number = 10000) {
-
-    const slashPath = botData.get('slashCommandPath') as string;
-    const commandPath = resolve(process.cwd(), slashPath);
-
-    let debounceTimer: NodeJS.Timeout | null = null;
-
-    const handleReload = async () => {
-        if (debounceTimer) {
-            clearTimeout(debounceTimer);
-        }
-        debounceTimer = setTimeout(async () => {
-            await prefixLoader(client);
-            logInfo('Slash commands successfully reloaded after debounce.');
-        }, DEBOUNCE_DELAY);
-    };
-
-    watch(commandPath, { recursive: false }, (eventType: any, filename: any) => {
-        if (filename && validExtensions.includes(extname(filename))) {
-            logInfo(`Detected ${eventType} in ${filename}, waiting for debouncing...`);
-            handleReload();
-        }
-    });
-
-    logInfo('Started watching for changes in slash commands...');
-}

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

@@ -1,81 +0,0 @@
-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';
-import { SlashOptions } from '../types/starter';
-import { logError } from '../functions/logger';
-
-async function loadCommand(filePath: string) {
-    try {
-        const command = require(filePath);
-        if (command.data) {
-            command.data.cooldown = command.cooldown && !isNaN(command.cooldown) ? command.cooldown : 0;
-            command.data.botPerms = command.botPerms || [];
-            command.data.userPerms = command.userPerms || [];
-            command.data.owner = command.owner || false;
-            command.data.developer = command.developer || false;
-            command.data.category = command.category || 'Uncategorized';
-            return command;
-        }
-    } catch (error: any) {
-        logError(`Error loading command from file: ${filePath}`);
-        logError(error.message);
-    }
-    return null;
-}
-
-export async function registerSlashCommands(client: any, token: string, slash: SlashOptions): Promise<Collection<string, any>> {
-    if (!token) {
-        throw new Error("⚠️ Please provide valid bot token to register slash commands.");
-    }
-
-    const slashCommands = new Collection<string, any>();
-    const rest = new REST({ version: '10' }).setToken(token);
-
-    try {
-        const resolvedPath = path.join(process.cwd(), slash.path);
-        const dirents = await readdir(resolvedPath, { withFileTypes: true });
-
-        for (const dirent of dirents) {
-            const folderPath = path.join(resolvedPath, dirent.name);
-            if (dirent.isDirectory()) {
-                const files = await readdir(folderPath);
-                for (const file of files) {
-                    const command = await loadCommand(path.join(folderPath, file));
-                    if (command) {
-                        slashCommands.set(command.data.name, command);
-                    }
-                }
-            } else {
-                const command = await loadCommand(path.join(resolvedPath, dirent.name));
-                if (command) {
-                    slashCommands.set(command.data.name, command);
-                }
-            }
-        }
-
-        const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
-
-        if (slash.global && !slash.serverId) {
-            await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: slashCommandArray });
-        } else if (!slash.global && slash.serverId) {
-            const guild = client.guilds.cache.get(slash.serverId) as Guild | undefined;
-            if (guild) {
-                await rest.put(Routes.applicationGuildCommands(client.user?.id || '', guild.id), { body: slashCommandArray });
-            } else {
-                logError(`Guild with ID ${slash.serverId} not found.`);
-            }
-        } else {
-            await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: slashCommandArray });
-        }
-    } catch (error: any) {
-        logError('Error registering slash commands:');
-        logError(error.message);
-        console.error(error);
-    }
-
-    client.slashCommands = slashCommands;
-    client.slashSize = slashCommands.size;
-    return slashCommands;
-}

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

@@ -1,136 +0,0 @@
-import {
-    Collection,
-    Interaction,
-    EmbedBuilder,
-    Snowflake,
-    PermissionResolvable,
-    TextChannel
-} 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: any, token: string, options: SlashOptions): Promise<void> {
-    const slashCommands = await registerSlashCommands(client, token, options);
-
-    if (!slashCommands || slashCommands.size === 0) {
-        logWarning('No registered slash commands. SlashHandler won\'t work.');
-        return;
-    }
-
-    const interactionCooldowns: Collection<Snowflake, Collection<string, number>> = new Collection();
-
-    client.on('interactionCreate', async (interaction: Interaction) => {
-        // Ensure we are handling the correct type of interaction
-        if (!interaction.isCommand() && !interaction.isChatInputCommand() && !interaction.isContextMenuCommand()) {
-            return;
-        }
-
-        const guild = interaction.guild; // Get the guild once for better readability
-        const user = interaction.user;
-
-        if (guild) {
-            const botData = new Collection<string, string | string[]>();
-            const permissionsArray = botData.get('permissions') as string[] | undefined;
-
-            // Check if bot has permission to send messages
-            if (!guild.members.me?.permissions.has('SendMessages')) {
-                try {
-                    await user.send({ content: "I'm sorry, but I don't have permission to send messages in this server." });
-                } catch (error) {
-                    return; // Ignore errors when sending the message
-                }
-            }
-
-            // Check for missing permissions
-            if (permissionsArray && permissionsArray.length > 0) {
-                const missingPermissions = permissionsArray.filter(permission => !guild.members.me?.permissions.has(permission as PermissionResolvable));
-
-                if (missingPermissions.length > 0) {
-                    try {
-                        await user.send({ content: `I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.` });
-                    } catch (error) {
-                        return; // Ignore errors when sending the message
-                    }
-                }
-            }
-        }
-
-        const commandName = interaction.commandName;
-        const command = slashCommands.get(commandName);
-
-        if (!command) return;
-
-        // Handle command cooldowns
-        if (command.cooldown && !isNaN(command.cooldown)) {
-            const userCooldowns = interactionCooldowns.get(interaction.user.id) || new Collection<string, number>();
-            const cooldownExpiration = userCooldowns.get(command.data.name);
-            if (cooldownExpiration && cooldownExpiration > Date.now()) {
-                const remainingCooldown = (cooldownExpiration - Date.now()) / 1000;
-                await interaction.reply(`Command is on cooldown. Please wait ${remainingCooldown.toFixed(1)} seconds.`);
-                return;
-            }
-            userCooldowns.set(command.data.name, Date.now() + command.cooldown * 1000);
-            interactionCooldowns.set(interaction.user.id, userCooldowns);
-        }
-
-        const startExecutionTime = Date.now();
-
-        try {
-            if (command.run) {
-                await command.run.length === 2 ? command.run(interaction, client) : command.run(interaction);
-            } else if (command.execute) {
-                await command.execute.length === 2 ? command.execute(interaction, client) : command.execute(interaction);
-            } else {
-                logWarning(`Command "${command.data.name}" has neither run nor execute method.`);
-            }
-
-            // Logging command usage
-            if (options.logsId && guild) {
-                const channel = guild.channels.cache.get(options.logsId as string) as TextChannel;
-                if (channel) {
-                    const userName = user.username;
-                    const userId = user.id;
-                    const serverName = guild.name || 'Unknown Server';
-                    const serverId = 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 }
-                        );
-
-                    await channel.send({ embeds: [embedLog] });
-                }
-            }
-
-            const executionTime = Date.now() - startExecutionTime;
-            if (executionTime > 3000) {
-                logInfo(`Command "${command.data.name}" took ${executionTime}ms to execute.`);
-            }
-        } 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,104 +0,0 @@
-import { Client, 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';
-import { watch } from 'fs';
-
-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) {
-                    command.cooldown = command.cooldown || 0;
-                    command.owner = command.owner || false;
-                    command.developer = command.developer || false;
-                    command.botPerms = command.botPerms || [];
-                    command.userPerms = command.userPerms || [];
-                    
-                    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, error);
-        return { commands: new Collection<string, any>(), success: false };
-    }
-}
-
-export function autoSlashLoader(client: Client, DEBOUNCE_DELAY: number = 10000) {
-
-    const slashPath = botData.get('slashCommandPath') as string;
-    const commandPath = resolve(process.cwd(), slashPath);
-
-    let debounceTimer: NodeJS.Timeout | null = null;
-
-    const handleReload = async () => {
-        if (debounceTimer) {
-            clearTimeout(debounceTimer);
-        }
-        debounceTimer = setTimeout(async () => {
-            await slashLoader(client);
-            logInfo('Slash commands successfully reloaded after debounce.');
-        }, DEBOUNCE_DELAY);
-    };
-
-    watch(commandPath, { recursive: false }, (eventType: any, filename: any) => {
-        if (filename && validExtensions.includes(extname(filename))) {
-            logInfo(`Detected ${eventType} in ${filename}, waiting for debouncing...`);
-            handleReload();
-        }
-    });
-
-    logInfo('Started watching for changes in slash commands...');
-}

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

@@ -1,85 +0,0 @@
-import { StarterOptions, StarterInterface,  } from '../types/utils';
-import { mongoConnect, getDb, verseConnect } from '../functions/utils';
-const wait = require('node:timers/promises').setTimeout;
-import { botData, login } from './login';
-import { AntiCrash } from '../functions/anticrash';
-import { loadEvents } from './events';
-import { MessageCollector, InteractionCollector, ShardingManager, ShardClientUtil } from 'discord.js';
-import path from 'path';
-import fs from 'fs';
-import { logError, logInfo, logSuccess } from '../utils';
-
-export class Starter implements StarterInterface {
-    async start(djs: any, options: StarterOptions): Promise<any> {
-        let mongoDb;
-        let verseDb;
-
-        if (options.sharding?.enable) {
-            try {
-                const packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
-                const mainFile = packageJson.main || 'index.js';
-
-                const manager = new ShardingManager(path.join(process.cwd(), mainFile), {
-                    totalShards: options.sharding.totalShards || 'auto',
-                    mode: options.sharding.mode || 'process',
-                    shardList: options.sharding.shardList || 'auto',
-                    respawn: options.sharding.respawn !== undefined ? options.sharding.respawn : true,
-                    silent: options.sharding.silent || false,
-                    shardArgs: options.sharding.shardArgs || [],
-                    token: options.sharding.token || options.bot?.token,
-                    execArgv: options.sharding.execArgv || process.execArgv,
-                });
-
-                manager.on('shardCreate', shard => logInfo(`Launched shard ${shard.id}`));
-                await manager.spawn();
-                djs.shard = manager;
-                djs.shardClient = ShardClientUtil.singleton(djs, options?.sharding?.mode || 'process');
-                logSuccess('Sharding setup complete and shards spawned.');
-            } catch (error: any) {
-                logError('Failed to setup sharding', error);
-            }
-        }
-        try {
-            if (options.bot?.Database?.mongo) {
-                await mongoConnect(options.bot.Database.mongo.mongoURI, options.bot.Database.mongo.dbName || 'djsbuilder');
-                mongoDb = await getDb();
-            }
-            if (options.bot?.Database?.verse) {
-                verseDb = await verseConnect(options.bot.Database.verse);
-            }
-            if (options.events) {
-                await loadEvents(djs, options.events);
-                botData.set('eventsPath', options.events.path);
-            }         
-            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);
-        }
-
-        await wait(2_000)
-        return {
-            mongodb: mongoDb,
-            versedb: verseDb,
-            slashSize: djs.slashSize || 0,
-            prefixSize: djs.prefixSize || 0,
-            eventSize: djs.eventSize || 0,
-            client: djs
-        };
-    }
-
-    async handleStartupError(error: any, djs: any, options: StarterOptions) {
-        console.error('Error during bot startup:', error);
-        setTimeout(() => {
-            this.start(djs, options);
-        }, 5000); 
-    }
-}
-
-
-