djs-builder 0.5.42 → 0.6.0

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

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