djs-builder 0.5.41 → 0.6.0

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

@@ -1,160 +0,0 @@
-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'];
-
-export async function processEventFile(client: any, eventsOptions: EventsOptions, filePath: string) {
-    try {
-        const resolvedPath = resolve(process.cwd(), filePath);
-        const stats = await stat(resolvedPath);
-
-        if (stats.isFile() && validExtensions.includes(extname(resolvedPath))) {
-            const event: Event = await import(resolvedPath);
-            if (eventsOptions.eventBlacklist?.includes(resolvedPath)) {
-                return;
-            }
-
-            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);
-                client.eventSize++;
-            
-                if (event.interval) {
-                    if (event.intervalId) clearInterval(event.intervalId);
-                    event.intervalId = setInterval(async () => {
-                        await event.execute(...args, client);
-                        client.eventSize++;
-                    }, 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);
-            }
-        }
-    } catch (error: any) {
-        logError(`Error in event file: ${filePath}`);
-        logError(error.message, error);
-    }
-}
-
-export 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));
-        }
-    };
-}
-
-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) {
-            try {
-                await handler(...args);
-                return; 
-            } catch (error: any) {
-                logError('Error executing event:');
-                logError(error.message, error);
-                attempts++;
-            }
-        }
-        logError('Reached maximum retry attempts.');
-    };
-}
-
-export async function processDirectory(client: any, eventsOptions: EventsOptions, directoryPath: string) {
-    try {
-        const filesInDirectory = await readdir(directoryPath);
-        for (const file of filesInDirectory) {
-            const filePath = join(directoryPath, file);
-            const fileStats = await stat(filePath);
-            if (fileStats.isDirectory() && eventsOptions.recursive) {
-                await processDirectory(client, eventsOptions, filePath);
-            } else if (fileStats.isFile()) {
-                await processEventFile(client, eventsOptions, filePath);
-            }
-        }
-    } catch (error: any) {
-        logError(`Error while processing directory: ${directoryPath}`);
-        logError(error.message, error);
-    }
-}
-
-export async function loadEvents(client: any, eventsOptions: EventsOptions) {
-    try {
-        const resolvedPath = resolve(process.cwd(), eventsOptions.path);
-        const stats = await stat(resolvedPath);
-        client.eventSize = 0;
-
-        if (stats.isDirectory()) {
-            await processDirectory(client, eventsOptions, resolvedPath);
-        } else if (stats.isFile()) {
-            await processEventFile(client, eventsOptions, eventsOptions.path);
-        } else {
-            logError(`Invalid file or directory: ${resolvedPath}`);
-        }
-
-        const eventCount = await countEventFiles(eventsOptions.path, eventsOptions);
-        client.eventSize = eventCount;
-        
-    } catch (error: any) {
-        logError(`Error while loading events from path: ${eventsOptions.path}`);
-        logError(error.message, error);
-    }
-}
-
-export async function countEventFiles(filePath: string, eventsOptions: EventsOptions): Promise<number> {
-    let count = 0;
-    try {
-        const resolvedPath = resolve(process.cwd(), filePath);
-        const stats = await stat(resolvedPath);
-        if (!eventsOptions.recursive && stats.isDirectory()) {
-            const filesInDirectory = await readdir(resolvedPath);
-            for (const item of filesInDirectory) {
-                const itemPath = resolve(resolvedPath, item);
-                if ((await stat(itemPath)).isFile() && validExtensions.includes(extname(itemPath))) {
-                    count++;
-                }
-            }
-        } else if (stats.isDirectory() && eventsOptions.recursive) {
-            const filesInDirectory = await readdir(resolvedPath);
-            for (const item of filesInDirectory) {
-                const itemPath = resolve(resolvedPath, item);
-                count += await countEventFiles(itemPath, eventsOptions);
-            }
-        } else if (stats.isFile() && validExtensions.includes(extname(resolvedPath))) {
-            count++;
-        }
-    } catch (error: any) {
-        logError(`Error counting event files in directory: ${filePath}`);
-        logError(error.message, error);
-    }
-    return count;
-}

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

@@ -1,265 +0,0 @@
-import { Collection, Routes, resolveImage, ActivityType, Client } from 'discord.js';
-import { StarterOptions } from '../types/starter';
-import { loadPrefix } from './prefix-responder';
-import { loadSlash } from './slash-responder';
-import { readCommands } from './prefix-register';
-import { GatewayIntentBits } from 'discord-api-types/v10';
-import { logError, logInfo, logWarning } from '../utils';
-import * as path from 'path';
-import fs from 'fs';
-import { autoSlashLoader } from './slashLoader';
-import { autoPrefixLoader } from './prefixLoader';
-import { autoEventLoader } from './eventLoader';
-
-export const botData = new Collection<string, string | string[]>();
-
-export async function login(djs: Client & { botData?: Collection<string, string | string[]>; botInfo?: any; ownerId?: string }, options: StarterOptions) { 
-
-    if (!djs) {
-        throw new Error("⚠️ \x1b[31mMissing client parameter. Please provide a valid Discord client.\x1b[0m");
-    }
-
-    djs.on('rateLimit', (rateLimitInfo) => {
-        logWarning(`Rate limit hit: ${rateLimitInfo.timeout}ms timeout for ${rateLimitInfo.limit} requests.`);
-        logInfo(`Route: ${rateLimitInfo.route}`);
-    });
-    
-    djs.on('error', (error) => {
-        logError('An error occurred', error);
-    });
-
-    if (options.bot.token) {
-        try {
-            await djs.login(options.bot.token);
-            
-            if (options.bot?.token) botData.set('botToken', options.bot.token); 
-            
-            const REQUIRED_INTENTS = {
-                'guildCreate': GatewayIntentBits.Guilds,
-                'guildUpdate': GatewayIntentBits.Guilds,
-                'guildDelete': GatewayIntentBits.Guilds,
-                'channelCreate': GatewayIntentBits.Guilds,
-                'channelUpdate': GatewayIntentBits.Guilds,
-                'channelDelete': GatewayIntentBits.Guilds,
-                'channelPinsUpdate': GatewayIntentBits.Guilds,
-                'threadCreate': GatewayIntentBits.Guilds,
-                'threadUpdate': GatewayIntentBits.Guilds,
-                'threadDelete': GatewayIntentBits.Guilds,
-                'threadListSync': GatewayIntentBits.Guilds,
-                'threadMemberUpdate': GatewayIntentBits.Guilds,
-                'threadMembersUpdate': GatewayIntentBits.Guilds,
-                'stageInstanceCreate': GatewayIntentBits.Guilds,
-                'stageInstanceUpdate': GatewayIntentBits.Guilds,
-                'stageInstanceDelete': GatewayIntentBits.Guilds,
-                'guildMemberAdd': GatewayIntentBits.GuildMembers,
-                'guildMemberUpdate': GatewayIntentBits.GuildMembers,
-                'guildMemberRemove': GatewayIntentBits.GuildMembers,
-                'guildAuditLogEntryCreate': GatewayIntentBits.GuildModeration,
-                'guildBanAdd': GatewayIntentBits.GuildModeration,
-                'guildBanRemove': GatewayIntentBits.GuildModeration,
-                'guildEmojisUpdate': GatewayIntentBits.GuildEmojisAndStickers,
-                'guildStickersUpdate': GatewayIntentBits.GuildEmojisAndStickers,
-                'guildIntegrationsUpdate': GatewayIntentBits.GuildIntegrations,
-                'integrationCreate': GatewayIntentBits.GuildIntegrations,
-                'integrationUpdate': GatewayIntentBits.GuildIntegrations,
-                'integrationDelete': GatewayIntentBits.GuildIntegrations,
-                'webhooksUpdate': GatewayIntentBits.GuildWebhooks,
-                'inviteCreate': GatewayIntentBits.GuildInvites,
-                'inviteDelete': GatewayIntentBits.GuildInvites,
-                'voiceStateUpdate': GatewayIntentBits.GuildVoiceStates,
-                'presenceUpdate': GatewayIntentBits.GuildPresences,
-                'messageCreate': GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages,
-                'messageUpdate': GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages,
-                'messageDelete': GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages,
-                'messageDeleteBulk': GatewayIntentBits.GuildMessages,
-                'messageReactionAdd': GatewayIntentBits.GuildMessageReactions,
-                'messageReactionRemove': GatewayIntentBits.GuildMessageReactions,
-                'messageReactionRemoveAll': GatewayIntentBits.GuildMessageReactions,
-                'messageReactionRemoveEmoji': GatewayIntentBits.GuildMessageReactions,
-                'typingStart': GatewayIntentBits.GuildMessageTyping,
-                'guildScheduledEventCreate': GatewayIntentBits.GuildScheduledEvents,
-                'guildScheduledEventUpdate': GatewayIntentBits.GuildScheduledEvents,
-                'guildScheduledEventDelete': GatewayIntentBits.GuildScheduledEvents,
-                'guildScheduledEventUserAdd': GatewayIntentBits.GuildScheduledEvents,
-                'guildScheduledEventUserRemove': GatewayIntentBits.GuildScheduledEvents,
-                'autoModerationRuleCreate': GatewayIntentBits.AutoModerationConfiguration,
-                'autoModerationRuleUpdate': GatewayIntentBits.AutoModerationConfiguration,
-                'autoModerationRuleDelete': GatewayIntentBits.AutoModerationConfiguration,
-                'autoModerationActionExecution': GatewayIntentBits.AutoModerationExecution,
-                'messagePollVoteAdd': GatewayIntentBits.GuildMessagePolls,
-                'messagePollVoteRemove': GatewayIntentBits.GuildMessagePolls
-            };
-
-            const missingIntents = new Set();
-            const intents = Number(djs.options.intents.bitfield);
-            for (const eventName of Object.keys((djs as any)._events)) {
-                const requiredBit = REQUIRED_INTENTS[eventName as keyof typeof REQUIRED_INTENTS];
-                if (!requiredBit) continue;
-                if ((intents & requiredBit) === 0) {
-                    missingIntents.add(requiredBit);
-                }
-            }
-
-            if (missingIntents.size > 0) {
-                const EventNames: { [key: number]: string } = Object.fromEntries(
-                    Object.entries(GatewayIntentBits).map(([key, value]) => [value, key])
-                );
-                
-                const missingIntentNames = [...missingIntents].map(bit => {
-                    return EventNames[bit as keyof typeof EventNames] ?? 'unknown';
-                });
-                
-                logError(`Missing intents: ${missingIntentNames.join(', ')}`);
-            }
-
-        } catch (error: any) {
-            logError("⚠️ \x1b[31mInvalid token provided. Please provide a valid bot token\x1b[0m", error);
-            process.exit(1);
-        }
-    }
-    djs.on('ready', async () => {
-        if (options.bot.name) djs.user?.setUsername(options.bot.name);
-        if (options.bot.avatar) {
-            const avatarPath = options.bot.avatar.startsWith('http') ?options. bot.avatar : path.join(process.cwd(), options.bot.avatar);
-            await djs.user?.setAvatar(avatarPath);
-        }
-        if (options.bot.banner) {
-            const fileBuffer = fs.readFileSync(path.join(process.cwd(), options.bot.banner));
-            const base64String = fileBuffer.toString('base64');
-
-            await djs.rest.patch(Routes.user(), {
-                body: { banner: await resolveImage(base64String) }
-            });
-        }
-        
-    djs.botInfo = djs.botInfo || {};
-
-    if (options.bot.BotInfo) {
-        if (options.bot.BotInfo.botInvite) {
-          botData.set('inviteURL', options.bot.BotInfo.botInvite);
-          djs.botInfo.inviteURL = options.bot.BotInfo.botInvite;
-        }
-
-        if (options.bot.BotInfo.perms) {
-          botData.set('permissions', options.bot.BotInfo.perms);
-          djs.botInfo.perms = options.bot.BotInfo.perms;
-        }
-
-        if (options.bot.BotInfo.partners) {
-          botData.set('partners', options.bot.BotInfo.partners);
-          djs.botInfo.partners = options.bot.BotInfo.partners;
-        }
-
-        if (options.bot.BotInfo.ownerId) {
-          botData.set('ownerId', options.bot.BotInfo.ownerId);
-          djs.ownerId = options.bot.BotInfo.ownerId;
-        }
-
-        if (options.bot.BotInfo.serverId) {
-          botData.set('serverId', options.bot.BotInfo.serverId);
-          djs.botInfo.serverId = options.bot.BotInfo.serverId;
-        }
-
-        if (options.bot.BotInfo.serverInvite) {
-          botData.set('serverInvite', options.bot.BotInfo.serverInvite);
-          djs.botInfo.serverInvite = options.bot.BotInfo.serverInvite;
-        }
-
-        if (options.bot.BotInfo.developers) {
-          botData.set('developers', options.bot.BotInfo.developers);
-          djs.botInfo.developers = options.bot.BotInfo.developers;
-        }
-    }
-
-        if (options.prefix) {
-            await readCommands(djs, options.prefix)
-            await loadPrefix(djs, options.prefix);
-            if (options.prefix.path) botData.set('prefixPath', options.prefix.path); 
-
-        }
-        if (options.slash && options.bot.token) {
-            await loadSlash(djs, options.bot?.token, options.slash);
-            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'); 
-        }
-
-
-        const userChosenType = options.bot.Status ? options.bot.Status.type : 3;
-        if (options.bot.Status?.activities) {
-            if (options.bot.Status.activities.length >= 1) {
-                const initialActivity = options.bot.Status.activities[0];
-                if (options.bot.Status.state === 'idle' || options.bot.Status.state === 'online' || options.bot.Status.state === 'dnd' || options.bot.Status.state === 'invisible') {
-                    djs.user?.setPresence({
-                    activities: [{ name: initialActivity, type: userChosenType }],
-                    status: options.bot.Status.state,
-                });
-              } else if (options.bot.Status.state === 'Streaming') {
-                djs.user?.setActivity({
-                    name: initialActivity,
-                    type: ActivityType.Streaming,
-                    url: 'https://www.twitch.tv/discord'
-                });
-              } else {
-                throw new Error('⚠️ \x1b[31mInvalid bot Status.\x1b[0m');
-              }
-            }
-
-            if (options.bot.Status?.activities.length > 1) {
-                let delay = 60000; 
-                if (options.bot.Status.delay !== undefined) {
-                    if (options.bot.Status.delay < 60000) {
-                        logWarning('⚠️ Delay must be at least 1 minute.');
-                    }
-                    delay = options.bot.Status.delay;
-                }
-                setInterval(() => {
-                    try {
-                        const randomActivity: string | undefined = options.bot.Status?.activities?.[Math.floor(Math.random() * options.bot.Status.activities?.length)];
-                     
-                      if (randomActivity && options.bot.Status?.state === 'Streaming') {
-                            djs.user?.setActivity({
-                                name: randomActivity,
-                                type: ActivityType.Streaming,
-                                url: 'https://www.twitch.tv/discord'
-                            });
-                      } if (randomActivity && options.bot.Status?.state !== 'Streaming') {
-                            djs.user?.setPresence({
-                                activities: [{ name: randomActivity, type: userChosenType }],
-                                status: options.bot.Status?.state,
-                            });
-                      } 
-                    } catch (error: any) {
-                        logError("Error setting activity: ${error}", error);
-                    }
-                }, delay);
-            }
-        } else if (options.bot.Status?.activities !== undefined){
-            throw new Error('⚠️ \x1b[31mActivities array must be provided.\x1b[0m');
-        }
-        
-
-        if (options.bot.logs?.terminal) {
-            const { terminalLogs } = require('../functions/terminal');
-            await terminalLogs(djs, options.bot); 
-        }
-
-        if (options.bot.logs?.devLogs?.enable) {
-            const { devLogger } = require('../functions/devLogs');
-            await devLogger(options.bot.logs.devLogs); 
-        }
-
-        (djs as any).botData = botData;
-
-        if (options.slash?.autoLoader?.enable) {
-            autoSlashLoader(djs, options.slash?.autoLoader?.DEBOUNCE_DELAY);
-        }
-        if (options.prefix?.autoLoader?.enable) {
-            autoPrefixLoader(djs, options.prefix?.autoLoader?.DEBOUNCE_DELAY);
-        }
-        if (options.events?.autoLoader?.enable) {
-            autoEventLoader(djs, options.events?.autoLoader?.DEBOUNCE_DELAY, options.events);
-        }
-    });
-}

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

@@ -1,117 +0,0 @@
-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;
-    fastUse: boolean | undefined;
-    botPerms: string[] | undefined;
-    userPerms: string[] | undefined;
-    category: string | undefined;
-    accessLevel: string | undefined;
-    method?: (...args: any[]) => void;
-}>> {
-    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;
-        method?: (...args: any[]) => void; 
-    }> = [];
-
-    try {
-        const resolvedPath = resolve(process.cwd(), prefix.path);
-        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()) {
-                const subCommandDetails = await readCommands(client, { path: filePath });
-                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 method = command.execute ? command.execute : command.run
-                        const defaultCommand: Command = {
-                            description: "No description provided.",
-                            cooldown: undefined,
-                            usage: "No usage information provided.",
-                            aliases: [],
-                            developer: false,
-                            owner: false,
-                            fastUse: false,
-                            botPerms: [],
-                            userPerms: [],
-                            category: "Uncategorized",
-                            accessLevel: undefined, 
-                            ...command,
-                            method
-                        };
-
-                        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,
-                            fastUse: defaultCommand.fastUse,
-                            botPerms: defaultCommand.botPerms,
-                            userPerms: defaultCommand.userPerms,
-                            category: defaultCommand.category || 'Uncategorized',
-                            accessLevel: defaultCommand.accessLevel,
-                            method
-                        });
-                    }
-                } catch (error: any) {
-                    logError(`Error in file: ${filePath}`);
-                    logError(error.message, error);
-                }
-            }
-        }
-        
-        client.prefixCommands = commandDetails;
-        client.prefixSize = commandDetails.length;
-        return commandDetails;
-    } catch (error: any) {
-        logError(`⚠️ Error reading directory: ${prefix.path}`);
-        logError(error.message, error);
-        return [];
-    }
-}