djs-next 1.0.0-dev.1 → 1.0.0-dev.3

package/src/client.ts

@@ -1,4 +1,4 @@
-import { Client, Collection, Interaction } from 'discord.js';
+import { Client, Collection, Interaction, Message } from 'discord.js';
 import { DJSNextClientOptions, FileCommand, FileComponent, DJSNextConfig } from './types.js';
 import { loadAndDeployCommands } from './handlers/commandHandler.js';
 import { loadEvents } from './handlers/eventHandler.js';
@@ -28,7 +28,12 @@ export class DJSNextClient<DB = any> extends Client {
   private _clientId?: string;
   private _guildId?: string;
   private _developers: string[];
-  private _middleware?: (interaction: Interaction, client: Client) => Promise<boolean> | boolean;
+  private _middleware?: (interaction: Interaction | Message, client: Client) => Promise<boolean> | boolean;
+  private _prefixes: string[];
+  private _enableSlashCommands: boolean;
+  private _enableTextCommands: boolean;
+  private _enableMentionPrefix: boolean | string[];
+  private _enableNoPrefix: boolean | string[];
 
   constructor(options: DJSNextClientOptions) {
     super(options);
@@ -43,7 +48,17 @@ export class DJSNextClient<DB = any> extends Client {
     this._clientId = options.clientId;
     this._guildId = options.guildId;
     this._developers = options.developers || [];
-    this._middleware = options.middleware;
+    this._middleware = options.middleware as any;
+    
+    const prefs = options.prefixes || [];
+    this._prefixes = Array.isArray(prefs) ? prefs : [prefs];
+    this._prefixes = this._prefixes.filter(p => p !== ''); // Remove empty strings, handle explicitly via enableNoPrefix
+
+    this._enableSlashCommands = options.enableSlashCommands ?? true;
+    this._enableTextCommands = options.enableTextCommands ?? true;
+    this._enableMentionPrefix = options.enableMentionPrefix ?? true;
+    this._enableNoPrefix = options.enableNoPrefix ?? false;
+    if (options.db) this.db = options.db as any;
 
     this.attachCoreListeners();
   }
@@ -63,6 +78,8 @@ export class DJSNextClient<DB = any> extends Client {
 
       // 2. Chat Input Commands Execution
       if (interaction.isChatInputCommand()) {
+        if (!this._enableSlashCommands) return;
+        
         let commandKey = interaction.commandName;
         const group = interaction.options.getSubcommandGroup(false);
         const sub = interaction.options.getSubcommand(false);
@@ -73,56 +90,12 @@ export class DJSNextClient<DB = any> extends Client {
         const command = this.commands.get(commandKey);
         if (!command || !command.execute) return;
 
-        // --- Permissions & Validation Checks ---
-        if (command.developerOnly && !this._developers.includes(interaction.user.id)) {
-          return interaction.reply({ content: 'Only developers can use this command.', ephemeral: true }) as never;
-        }
-
-        if (command.guildOnly && !interaction.inGuild()) {
-          return interaction.reply({ content: 'This command can only be used in a server.', ephemeral: true }) as never;
-        }
-
-        if (command.userPermissions && interaction.memberPermissions) {
-          const missing = interaction.memberPermissions.missing(command.userPermissions);
-          if (missing.length > 0) {
-            return interaction.reply({ content: `You are missing permissions: \`${missing.join(', ')}\``, ephemeral: true }) as never;
-          }
-        }
-
-        if (command.botPermissions && interaction.guild?.members.me?.permissions) {
-          const missing = interaction.guild.members.me.permissions.missing(command.botPermissions);
-          if (missing.length > 0) {
-            return interaction.reply({ content: `I am missing permissions to run this: \`${missing.join(', ')}\``, ephemeral: true }) as never;
-          }
-        }
-
-        // --- Built-in Cooldowns ---
-        if (command.cooldown) {
-          if (!this.cooldowns.has(commandKey)) this.cooldowns.set(commandKey, new Collection());
-          const now = Date.now();
-          const timestamps = this.cooldowns.get(commandKey)!;
-          const cooldownAmount = command.cooldown * 1000;
-
-          if (timestamps.has(interaction.user.id)) {
-            const expirationTime = timestamps.get(interaction.user.id)! + cooldownAmount;
-            if (now < expirationTime) {
-              return interaction.reply({ 
-                content: `Please wait, you are on a cooldown. You can use it again <t:${Math.round(expirationTime / 1000)}:R>.`, 
-                ephemeral: true 
-              }) as never;
-            }
-          }
-          timestamps.set(interaction.user.id, now);
-          setTimeout(() => timestamps.delete(interaction.user.id), cooldownAmount);
-        }
+        if (!(await this.handlePreconditions(command, interaction, commandKey))) return;
 
         try {
           await command.execute(interaction, this);
         } catch (error) {
-          console.error(`[djs-next] Error executing command: "${commandKey}"`, error);
-          const msg = { content: 'We ran into an internal error executing this command. The developers have been notified.', ephemeral: true };
-          if (interaction.replied || interaction.deferred) await interaction.followUp(msg).catch(()=>null);
-          else await interaction.reply(msg).catch(()=>null);
+          await this.handleCommandError(error, commandKey, interaction);
         }
       }
 
@@ -169,17 +142,87 @@ export class DJSNextClient<DB = any> extends Client {
           }
         }
         if (component) {
+          if (!(await this.handlePreconditions(component, interaction, interaction.customId))) return;
+
           try {
             await component.execute(interaction, this, params);
           } catch (error) {
-            console.error(`[djs-next] Error executing component: "${interaction.customId}"`, error);
-            const msg = { content: 'We ran into an internal error executing this component.', ephemeral: true };
-            if (interaction.replied || interaction.deferred) await interaction.followUp(msg).catch(()=>null);
-            else await interaction.reply(msg).catch(()=>null);
+            await this.handleCommandError(error, interaction.customId, interaction);
           }
         }
       }
     });
+
+    this.on('messageCreate', async (message: Message) => {
+      if (message.author.bot) return;
+      if (!this._enableTextCommands) return;
+
+      // Global Middleware execution for Messages
+      if (this._middleware) {
+        try {
+          const shouldContinue = await this._middleware(message, this);
+          if (!shouldContinue) return;
+        } catch (error) {
+          console.error(`[djs-next] Middleware error (Message):`, error);
+          return;
+        }
+      }
+
+      let content = message.content.trim();
+      let matchedPrefix = '';
+      let isCommand = false;
+
+      // 1. Check Mention Prefix
+      const mentionRegex = new RegExp(`^<@!?${this.user?.id}>\\s*`);
+      const canUseMention = this._enableMentionPrefix === true || (Array.isArray(this._enableMentionPrefix) && this._enableMentionPrefix.includes(message.author.id));
+      
+      if (canUseMention && mentionRegex.test(content)) {
+        matchedPrefix = content.match(mentionRegex)![0];
+        isCommand = true;
+      } else {
+        // 2. Check Standard Prefixes
+        const sortedPrefs = [...this._prefixes].sort((a, b) => b.length - a.length);
+        
+        for (const p of sortedPrefs) {
+          if (content.startsWith(p)) {
+            matchedPrefix = p;
+            isCommand = true;
+            break;
+          }
+        }
+
+        // 3. Check No Prefix
+        const canUseNoPrefix = this._enableNoPrefix === true || (Array.isArray(this._enableNoPrefix) && this._enableNoPrefix.includes(message.author.id));
+        if (!isCommand && canUseNoPrefix) {
+          isCommand = true;
+          matchedPrefix = '';
+        }
+      }
+
+      if (!isCommand) return;
+
+      const args = content.slice(matchedPrefix.length).trim().split(/ +/g);
+      const commandName = args.shift()?.toLowerCase();
+      if (!commandName) return;
+
+      // Find the command
+      let command = this.commands.get(commandName);
+      if (!command) {
+        // Check aliases
+        command = this.commands.find(c => c.aliases?.includes(commandName) || false);
+      }
+
+      if (!command || !command.executeText) return;
+
+      if (!(await this.handlePreconditions(command, message, commandName))) return;
+
+      // Execute Text Command
+      try {
+        await command.executeText(message, args, this);
+      } catch (error) {
+        await this.handleCommandError(error, commandName, message);
+      }
+    });
   }
 
   public async start(token: string): Promise<void> {
@@ -187,15 +230,17 @@ export class DJSNextClient<DB = any> extends Client {
 
     this.config = await loadConfig();
 
-    // Fallback options to config
+    // Fallback options to config, then to default 'src' folders
     this._guildId = this._guildId || this.config.devGuildId;
-    if (!this._commandsDir && this.config.directories?.commands) this._commandsDir = path.resolve(process.cwd(), this.config.directories.commands);
-    if (!this._eventsDir && this.config.directories?.events) this._eventsDir = path.resolve(process.cwd(), this.config.directories.events);
-    if (!this._componentsDir && this.config.directories?.components) this._componentsDir = path.resolve(process.cwd(), this.config.directories.components);
-    if (!this._tasksDir && this.config.directories?.tasks) this._tasksDir = path.resolve(process.cwd(), this.config.directories.tasks);
-    if (!this._localesDir && this.config.directories?.locales) this._localesDir = path.resolve(process.cwd(), this.config.directories.locales);
+    
+    if (!this._commandsDir) this._commandsDir = path.resolve(process.cwd(), this.config.directories?.commands || 'src/commands');
+    if (!this._eventsDir) this._eventsDir = path.resolve(process.cwd(), this.config.directories?.events || 'src/events');
+    if (!this._componentsDir) this._componentsDir = path.resolve(process.cwd(), this.config.directories?.components || 'src/components');
+    if (!this._tasksDir) this._tasksDir = path.resolve(process.cwd(), this.config.directories?.tasks || 'src/tasks');
+    if (!this._localesDir) this._localesDir = path.resolve(process.cwd(), this.config.directories?.locales || 'src/locales');
 
-    if (this._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
+    // Only load if the directories actually exist
+    if (fs.existsSync(this._localesDir)) loadLocales(this._localesDir, this.config.defaultLocale);
 
     // Load middleware from root
     if (!this._middleware) {
@@ -218,17 +263,18 @@ export class DJSNextClient<DB = any> extends Client {
       }
     }
 
-    if (this._eventsDir) await loadEvents(this, this._eventsDir);
-    if (this._componentsDir) this.components = await loadComponents(this._componentsDir);
-    if (this._tasksDir) await loadTasks(this, this._tasksDir);
-
-    if (this._commandsDir) {
-      if (!this._clientId) throw new Error("[djs-next] You must provide a clientId to deploy commands.");
-      this.commands = await loadAndDeployCommands(this._commandsDir, token, this._clientId, this._guildId);
-    }
+    if (fs.existsSync(this._eventsDir)) await loadEvents(this, this._eventsDir);
+    if (fs.existsSync(this._componentsDir)) this.components = await loadComponents(this._componentsDir);
+    if (fs.existsSync(this._tasksDir)) await loadTasks(this, this._tasksDir);
 
     await this.login(token);
     console.log(`[djs-next] Bot is ready and logged in as ${this.user?.tag}!`);
+
+    // Load and deploy commands AFTER login so we can automatically use this.user.id
+    if (fs.existsSync(this._commandsDir)) {
+      this._clientId = this._clientId || this.user!.id;
+      this.commands = await loadAndDeployCommands(this._commandsDir, token, this._clientId, this._guildId);
+    }
   }
 
   public enableDevTools(prefix: 'dnxt' | 'nxt' = 'dnxt'): void {
@@ -280,4 +326,167 @@ export class DJSNextClient<DB = any> extends Client {
       console.warn(`[djs-next] chokidar not installed. HMR is disabled. Please run "npm install chokidar" to use this feature.`);
     }
   }
+
+  private async handleCommandError(error: any, commandKey: string, context: Interaction | Message) {
+    console.error(`[djs-next] Error executing command/component: "${commandKey}"`, error);
+    const djs = require('discord.js');
+    if (this.config.responses?.errorBoundary === null) {
+      // Developer explicitly opted out of error boundary user messages
+    } else {
+      try {
+        const errorContent = this.config.responses?.errorBoundary || `### ⚠️ Execution Error\n> The framework encountered a fatal error while executing \`${commandKey}\`.`;
+        const codeBlock = `\`\`\`js\n${String(error.stack || error.message).substring(0, 1500)}\n\`\`\``;
+
+        if ('commandName' in context || 'customId' in context) {
+          const container = new djs.ContainerBuilder()
+            .setAccentColor(0xED4245)
+            .addTextDisplayComponents(new djs.TextDisplayBuilder().setContent(errorContent))
+            .addSeparatorComponents(new djs.SeparatorBuilder())
+            .addTextDisplayComponents(new djs.TextDisplayBuilder().setContent(codeBlock));
+            
+          const payload = { components: [container], flags: 32768, ephemeral: true };
+          const i = context as Interaction;
+          if (i.isRepliable()) {
+            if (i.replied || i.deferred) await i.followUp(payload);
+            else await i.reply(payload);
+          }
+        } else {
+          const embed = new djs.EmbedBuilder()
+            .setColor(0xED4245)
+            .setDescription(`${errorContent}\n\n${codeBlock}`);
+            
+          const m = context as Message;
+          await m.reply({ embeds: [embed] });
+        }
+      } catch (e) {
+        // Fallback ignore if channel is dead
+      }
+    }
+
+    if (this.config.errorLogChannelId) {
+      try {
+        const channel = await this.channels.fetch(this.config.errorLogChannelId);
+        if (channel && channel.isTextBased()) {
+          const userId = 'user' in context ? context.user.id : context.author.id;
+          await (channel as any).send(`🚨 **Global Error Boundary Caught Exception**\n**Context:** \`${commandKey}\`\n**User:** <@${userId}>\n\`\`\`js\n${String(error.stack || error.message).substring(0, 1900)}\n\`\`\``);
+        }
+      } catch (e) {
+        console.error(`[djs-next] Failed to send error to log channel:`, e);
+      }
+    }
+  }
+
+  private async handlePreconditions(command: FileCommand | FileComponent, context: Interaction | Message, commandKey: string): Promise<boolean> {
+    const userId = 'user' in context ? context.user.id : context.author.id;
+    const isGuild = 'guild' in context && context.guild !== null;
+    const member = context.member as any;
+
+    const sendErr = async (msg: string | null) => {
+      if (msg === null) return;
+      if ('reply' in context && typeof context.reply === 'function') {
+        try {
+          if ('replied' in context && (context as any).isRepliable() && ((context as any).replied || (context as any).deferred)) {
+            await (context as any).followUp({ content: msg, ephemeral: true });
+          } else {
+            await (context as any).reply({ content: msg, ephemeral: true, allowedMentions: { repliedUser: false } });
+          }
+        } catch(e) {}
+      }
+    };
+
+    if ('developerOnly' in command && command.developerOnly && !this._developers.includes(userId)) {
+      await sendErr(this.config.responses?.developerOnly !== undefined ? this.config.responses.developerOnly : 'Only developers can use this command.');
+      return false;
+    }
+    if ('guildOnly' in command && command.guildOnly && !isGuild) {
+      await sendErr(this.config.responses?.guildOnly !== undefined ? this.config.responses.guildOnly : 'This command can only be used in a server.');
+      return false;
+    }
+    if ('userPermissions' in command && command.userPermissions && member?.permissions) {
+      const missing = member.permissions.missing(command.userPermissions);
+      if (missing.length > 0) {
+        await sendErr(this.config.responses?.missingPerms !== undefined ? (this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace('{perms}', missing.join(', '))) : `You are missing permissions: \`${missing.join(', ')}\``);
+        return false;
+      }
+    }
+    if ('botPermissions' in command && command.botPermissions && context.guild?.members.me?.permissions) {
+      const missing = context.guild.members.me.permissions.missing(command.botPermissions);
+      if (missing.length > 0) {
+        await sendErr(this.config.responses?.missingPerms !== undefined ? (this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace('{perms}', missing.join(', '))) : `I am missing permissions to run this: \`${missing.join(', ')}\``);
+        return false;
+      }
+    }
+
+    let totalCooldown = 'cooldown' in command && command.cooldown ? command.cooldown * 1000 : 0;
+
+    if (command.preconditions) {
+      for (const pre of command.preconditions) {
+        const parts = pre.split(':');
+        const type = parts[0].toLowerCase();
+        const val = parts.slice(1).join(':');
+
+        if (type === 'owneronly' || type === 'developeronly') {
+          if (!this._developers.includes(userId)) {
+            await sendErr(this.config.responses?.developerOnly !== undefined ? this.config.responses.developerOnly : 'Only developers can use this command.');
+            return false;
+          }
+        } else if (type === 'guildonly') {
+          if (!isGuild) {
+            await sendErr(this.config.responses?.guildOnly !== undefined ? this.config.responses.guildOnly : 'This command can only be used in a server.');
+            return false;
+          }
+        } else if (type === 'requireperms') {
+          const perms = val.split(',').map(p => p.trim());
+          if (member?.permissions) {
+            const missing = member.permissions.missing(perms);
+            if (missing.length > 0) {
+              await sendErr(this.config.responses?.missingPerms !== undefined ? (this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace('{perms}', missing.join(', '))) : `You are missing permissions: \`${missing.join(', ')}\``);
+              return false;
+            }
+          }
+        } else if (type === 'cooldown') {
+          const match = val.match(/(\d+)(s|m|h)/);
+          if (match) {
+            let amount = parseInt(match[1]) * 1000;
+            if (match[2] === 'm') amount *= 60;
+            if (match[2] === 'h') amount *= 3600;
+            totalCooldown = Math.max(totalCooldown, amount);
+          }
+        }
+      }
+    }
+
+    if (totalCooldown > 0) {
+      const now = Date.now();
+      
+      if (this.config.cooldownAdapter) {
+        const lastUsed = await this.config.cooldownAdapter.get(commandKey, userId);
+        if (lastUsed) {
+          const expirationTime = lastUsed + totalCooldown;
+          if (now < expirationTime) {
+            const timeStr = `<t:${Math.round(expirationTime / 1000)}:R>`;
+            await sendErr(this.config.responses?.cooldown !== undefined ? (this.config.responses.cooldown === null ? null : this.config.responses.cooldown.replace('{time}', timeStr)) : `Please wait, you are on a cooldown. You can use it again ${timeStr}.`);
+            return false;
+          }
+        }
+        await this.config.cooldownAdapter.set(commandKey, userId, now);
+      } else {
+        if (!this.cooldowns.has(commandKey)) this.cooldowns.set(commandKey, new Collection());
+        const timestamps = this.cooldowns.get(commandKey)!;
+
+        if (timestamps.has(userId)) {
+          const expirationTime = timestamps.get(userId)! + totalCooldown;
+          if (now < expirationTime) {
+            const timeStr = `<t:${Math.round(expirationTime / 1000)}:R>`;
+            await sendErr(this.config.responses?.cooldown !== undefined ? (this.config.responses.cooldown === null ? null : this.config.responses.cooldown.replace('{time}', timeStr)) : `Please wait, you are on a cooldown. You can use it again ${timeStr}.`);
+            return false;
+          }
+        }
+        timestamps.set(userId, now);
+        setTimeout(() => timestamps.delete(userId), totalCooldown);
+      }
+    }
+
+    return true;
+  }
 }

package/src/index.ts

@@ -1,7 +1,10 @@
+import 'dotenv/config';
 export * from './client.js';
-export { DJSNextClientOptions, FileCommand, FileComponent, FileTask, Event as DJSNextEvent, DJSNextConfig } from './types.js';
+export { DJSNextClientOptions, FileCommand, FileComponent, FileTask, Event as DJSNextEvent, DJSNextConfig, CooldownAdapter } from './types.js';
 export * from './utils/paginate.js';
+export * from './utils/prompts.js';
 export * from './utils/configLoader.js';
 export * from './utils/i18n.js';
+export * from './utils/PaginationBuilder.js';
 // Re-export everything from discord.js so users don't need to install it explicitly
 export * from 'discord.js';