djs-builder 0.5.42 → 0.6.0

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); 
-    }
-}
-
-
-

package/lib/discord/functions/anticrash.ts

@@ -1,60 +0,0 @@
-import { WebhookClient, EmbedBuilder } from 'discord.js';
-import { StarterOptions } from '../types/starter';
-
-let uncaughtExceptionThrown = false;
-let unhandledRejectionThrown = false;
-
-export async function AntiCrash(djs: any, options: StarterOptions) {
-    try {
-        if (!options.anticrash?.webhookURL) {
-            throw new Error('Please provide a valid webhook URL.');
-        }
-        const webhookClient = new WebhookClient({ url: options.anticrash.webhookURL });
-
-        process.on('uncaughtException', async (error: any) => {
-            if (!uncaughtExceptionThrown) {
-                uncaughtExceptionThrown = true;
-                console.error('Uncaught Exception:');
-                console.error('⚠️ Error:', error.message);
-                if (error.stack) {
-                    console.error('⚠️ Stack Trace:', error.stack);
-                    const filenameMatch = error.stack.match(/\((.*?):\d+:\d+\)/);
-                    const filename = filenameMatch ? filenameMatch[1] : 'Unknown File';
-
-                    const embed = new EmbedBuilder()
-                        .setTitle('🚨 Uncaught Exception')
-                        .setDescription(`> 📂 **File:** \`${filename}\`\n> 💥 **Error:** \`${error.message}\`\n> 🔍 **Stack Trace:**\n\`\`\`${await error.stack}\`\`\``)
-                        .setColor('#FF0000')
-                        .setTimestamp();
-
-                    webhookClient.send({ content: options.anticrash?.mention || '', embeds: [embed] });
-                }
-            }
-        });
-
-        process.on('unhandledRejection', async (reason: any, promise: any) => {
-            if (!unhandledRejectionThrown) {
-                unhandledRejectionThrown = true;
-                console.error('Unhandled Rejection:');
-                console.error('⚠️ Reason:', reason);
-                if (promise) {
-                    console.error('⚠️ Promise:', await promise);
-                }
-                
-                const stackTrace = reason?.stack || '';
-                const filenameMatch = stackTrace.match(/at\s+(.+):(\d+):(\d+)/);
-                const filename = filenameMatch ? filenameMatch[1] : 'Unknown File';
-                
-                const embed = new EmbedBuilder()
-                    .setTitle('🚨 Unhandled Rejection')
-                    .setDescription(`> 📂 **File:** \`${filename}\`\n> 💡 **Reason:** \`${reason}\`\n> 🔍 **Promise:**\n\`${await promise}\``)
-                    .setColor('#FF0000')
-                    .setTimestamp();
-                
-                webhookClient.send({ content: options.anticrash?.mention || '', embeds: [embed] });
-            }
-        });
-    } catch (error: any) {
-        console.error('An error occurred in AntiCrash function:', error.message);
-    }
-}

package/lib/discord/functions/devLogs.ts

@@ -1,128 +0,0 @@
-import { WebhookClient, EmbedBuilder } from 'discord.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function devLogger(devLogger: any): Promise<void> {
-  const webhook = new WebhookClient({ url: devLogger.webhookURL });
-
-  const watchedExtensions = ['.js', '.json', '.txt', '.md', '.ts', '.tsx', '.jsx', '.html', '.css', '.py', '.verse'];
-
-  const MAX_DESCRIPTION_LENGTH = 2048;
-
-  const watchDirectory = (directory: string) => {
-    fs.readdir(directory, (err, files) => {
-      if (err) {
-        console.error('Error reading directory:', err);
-        return;
-      }
-
-      for (const file of files) {
-        const filePath = path.join(directory, file);
-        fs.stat(filePath, (err, stats) => {
-          if (err) {
-            console.error('Error getting file stats:', err);
-            return;
-          }
-
-          if (stats.isDirectory()) {
-            watchDirectory(filePath);
-          } else {
-            if (watchedExtensions.some(ext => file.endsWith(ext))) {
-              watchFile(filePath);
-            }
-          }
-        });
-      }
-    });
-  };
-
-  const watchFile = (filePath: string) => {
-    fs.watchFile(filePath, { interval: 500 }, (curr, prev) => {
-      if (curr.mtime !== prev.mtime) {
-        readFile(filePath);
-      }
-    });
-  };
-
-  const readFile = (filePath: string) => {
-    fs.readFile(filePath, 'utf-8', (err, data) => {
-      if (err) {
-        console.error('Error reading file:', err);
-        return;
-      }
-
-      const embeds = createEmbeds(filePath, data);
-      sendWebhooks(embeds);
-    });
-  };
-
-  const createEmbeds = (filePath: string, data: string) => {
-    const fileType = getFileType(filePath);
-    const formattedData = '```' + fileType + '\n' + data + '\n```';
-
-    const chunks = chunkString(formattedData, MAX_DESCRIPTION_LENGTH);
-    const embeds: EmbedBuilder[] = [];
-
-    for (const chunk of chunks) {
-      const chunkLines = chunk.split('\n');
-      const fileTypeLine = chunkLines[0];
-      const codeLines = chunkLines.slice(1, chunkLines.length - 1); // Exclude first and last lines (```javascript and ```)
-      const code = codeLines.join('\n');
-
-      const embed = new EmbedBuilder()
-        .setColor('#3498db')
-        .setTitle('File Changed')
-        .setDescription(`File: \`${filePath}\`\n\`\`\`${fileTypeLine.split('```')[1]}\n${code}\n\`\`\``)
-        .setTimestamp();
-
-      embeds.push(embed);
-    }
-
-    return embeds;
-  };
-
-  const sendWebhooks = (embeds: EmbedBuilder[]) => {
-    for (const embed of embeds) {
-      webhook.send({ content: devLogger.mention || '', embeds: [embed] })
-        .then()
-        .catch((error) => console.error('Error Dev Logger Message', error));
-    }
-  };
-
-  const getFileType = (filePath: string): string => {
-    const extension = path.extname(filePath);
-    switch (extension) {
-      case '.js':
-      case '.jsx':
-        return 'js';
-      case 'ts':
-      case 'tsx':
-        return 'ts';
-      case '.json':
-        return 'json';
-      case '.txt':
-      case '.md':
-        return 'plaintext';
-      case '.html':
-        return 'html';
-      case '.css':
-        return 'css';
-      case '.py':
-        return 'python';
-      case '.verse':
-        return 'verse';
-      default:
-        return 'unknown';
-    }
-  };
-
-  const chunkString = (str: string, length: number) => {
-    const chunks = [];
-    for (let i = 0; i < str.length; i += length) {
-      chunks.push(str.substring(i, i + length));
-    }
-    return chunks;
-  };
-
-  watchDirectory(devLogger.pathToWatch);
-}

package/lib/discord/functions/logger.ts

@@ -1,58 +0,0 @@
-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}]`;
-}
-
-function extractErrorLocation(stack: string): string {
-    const lines = stack.split('\n');
-    const locationLine = lines[1] || lines[0];
-    
-    const match = locationLine.match(/\((.*):(\d+):(\d+)\)/);
-    if (match) {
-        const file = match[1];
-        const line = match[2];
-        return `File: ${file}, Line: ${line}`;
-    }
-    return 'Unknown location';
-}
-
-export function logSuccess(message: string) {
-    console.log(`${getTimestamp()} ${green}${successEmoji}${reset} ${green}${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) {
-        const location = extractErrorLocation(error.stack);
-        console.error(`${baseMessage}\n${location}\n${error.stack}`);
-    } else {
-        console.error(baseMessage);
-    }
-}
-
-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/lib/discord/functions/mongoDb.ts

@@ -1,38 +0,0 @@
-import { MongoClient, Db } from 'mongodb';
-
-let db: Db | null = null;
-let isInitialized = false;
-let connectionPromise: Promise<MongoClient> | null = null;
-
-async function initialize(uri: string, dbName: string): Promise<void> {
-    if (isInitialized || connectionPromise) {
-        return;
-    }
-
-    try {
-        const client = new MongoClient(uri);
-        connectionPromise = client.connect();
-        const connectedClient = await connectionPromise;
-        db = connectedClient.db(dbName || 'djsBuilder');
-        isInitialized = true;
-    } catch (error) {
-        console.error('Error initializing MongoDB:', error);
-    } finally {
-        connectionPromise = null;
-    }
-}
-
-export async function mongoConnect(uri: string, dbName: string): Promise<void> {
-    await initialize(uri, dbName);
-}
-
-export async function getDb(): Promise<Db> {
-    if (!isInitialized) {
-        throw new Error('MongoDB connection not initialized');
-    }
-    if (!db) {
-        throw new Error('MongoDB connection not established');
-    }
-    
-    return db;
-}

package/lib/discord/functions/similarity.ts

@@ -1,70 +0,0 @@
-import { Command } from '../types/starter';
-
-export function getSimilarCommands(commandName: string, commands: Command[]): string[] {
-    const similarityThreshold = 0.6;
-    const partialMatches: string[] = [];
-    const similarCommands: { name: string; similarity: number }[] = [];
-
-    for (const command of commands) {
-        const cmdName = command.name;
-
-        if (cmdName.includes(commandName) || commandName.includes(cmdName)) {
-            partialMatches.push(cmdName);
-        }
-
-        const similarity = calculateSimilarity(commandName, cmdName);
-        if (similarity >= similarityThreshold) {
-            similarCommands.push({ name: cmdName, similarity });
-        }
-
-        if (command.aliases && command.aliases.length > 0) {
-            for (const alias of command.aliases) {
-                if (alias.includes(commandName) || commandName.includes(alias)) {
-                    partialMatches.push(alias);
-                }
-
-                const aliasSimilarity = calculateSimilarity(commandName, alias);
-                if (aliasSimilarity >= similarityThreshold) {
-                    similarCommands.push({ name: alias, similarity: aliasSimilarity });
-                }
-            }
-        }
-    }
-
-    const combinedCommands = new Set([...partialMatches, ...similarCommands.map(cmd => cmd.name)]);
-    const uniqueCommands = Array.from(combinedCommands);
-
-    similarCommands.sort((a, b) => b.similarity - a.similarity);
-
-    return uniqueCommands.sort((a, b) => {
-        const aIndex = similarCommands.findIndex(cmd => cmd.name === a);
-        const bIndex = similarCommands.findIndex(cmd => cmd.name === b);
-        return bIndex - aIndex;
-    });
-}
-
-function calculateSimilarity(str1: string, str2: string): number {
-    const len1 = str1.length;
-    const len2 = str2.length;
-    const matrix = [];
-
-    for (let i = 0; i <= len1; i++) {
-        matrix[i] = [i];
-    }
-    for (let j = 0; j <= len2; j++) {
-        matrix[0][j] = j;
-    }
-
-    for (let i = 1; i <= len1; i++) {
-        for (let j = 1; j <= len2; j++) {
-            const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(
-                matrix[i - 1][j] + 1,
-                matrix[i][j - 1] + 1,
-                matrix[i - 1][j - 1] + cost
-            );
-        }
-    }
-
-    return 1 - matrix[len1][len2] / Math.max(len1, len2);
-}