djs-next 1.0.0-dev.1

package/src/client.ts

@@ -0,0 +1,283 @@
+import { Client, Collection, Interaction } from 'discord.js';
+import { DJSNextClientOptions, FileCommand, FileComponent, DJSNextConfig } from './types.js';
+import { loadAndDeployCommands } from './handlers/commandHandler.js';
+import { loadEvents } from './handlers/eventHandler.js';
+import { loadComponents } from './handlers/componentHandler.js';
+import { loadTasks } from './handlers/taskHandler.js';
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+
+import { loadConfig } from './utils/configLoader.js';
+import { loadLocales, translate } from './utils/i18n.js';
+import { handleDNXT } from './plugins/dnxt.js';
+
+export class DJSNextClient<DB = any> extends Client {
+  public commands: Collection<string, FileCommand>;
+  public components: Collection<string, FileComponent>;
+  public cooldowns: Collection<string, Collection<string, number>>;
+  public config: DJSNextConfig = {};
+  public t = translate;
+  public db!: DB;
+  
+  private _commandsDir?: string;
+  private _eventsDir?: string;
+  private _componentsDir?: string;
+  private _tasksDir?: string;
+  private _localesDir?: string;
+  private _clientId?: string;
+  private _guildId?: string;
+  private _developers: string[];
+  private _middleware?: (interaction: Interaction, client: Client) => Promise<boolean> | boolean;
+
+  constructor(options: DJSNextClientOptions) {
+    super(options);
+    this.commands = new Collection();
+    this.components = new Collection();
+    this.cooldowns = new Collection();
+    
+    this._commandsDir = options.commandsDir ? path.resolve(process.cwd(), options.commandsDir) : undefined;
+    this._eventsDir = options.eventsDir ? path.resolve(process.cwd(), options.eventsDir) : undefined;
+    this._componentsDir = options.componentsDir ? path.resolve(process.cwd(), options.componentsDir) : undefined;
+    this._tasksDir = options.tasksDir ? path.resolve(process.cwd(), options.tasksDir) : undefined;
+    this._clientId = options.clientId;
+    this._guildId = options.guildId;
+    this._developers = options.developers || [];
+    this._middleware = options.middleware;
+
+    this.attachCoreListeners();
+  }
+
+  private attachCoreListeners() {
+    this.on('interactionCreate', async (interaction: Interaction) => {
+      // 1. Global Middleware execution
+      if (this._middleware) {
+        try {
+          const shouldContinue = await this._middleware(interaction, this);
+          if (!shouldContinue) return; // Middleware halted execution
+        } catch (error) {
+          console.error(`[djs-next] Middleware error:`, error);
+          return;
+        }
+      }
+
+      // 2. Chat Input Commands Execution
+      if (interaction.isChatInputCommand()) {
+        let commandKey = interaction.commandName;
+        const group = interaction.options.getSubcommandGroup(false);
+        const sub = interaction.options.getSubcommand(false);
+
+        if (group) commandKey += ` ${group}`;
+        if (sub) commandKey += ` ${sub}`;
+
+        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);
+        }
+
+        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);
+        }
+      }
+
+      // 3. Autocomplete Routing
+      if (interaction.isAutocomplete()) {
+        let commandKey = interaction.commandName;
+        const group = interaction.options.getSubcommandGroup(false);
+        const sub = interaction.options.getSubcommand(false);
+
+        if (group) commandKey += ` ${group}`;
+        if (sub) commandKey += ` ${sub}`;
+
+        const command = this.commands.get(commandKey);
+        if (command && command.autocomplete) {
+          try {
+            await command.autocomplete(interaction, this);
+          } catch (error) {
+            console.error(`[djs-next] Error executing autocomplete for: "${commandKey}"`, error);
+          }
+        }
+      }
+
+      // 4. Component Routing (Buttons, Modals, Menus)
+      if (interaction.isMessageComponent() || interaction.isModalSubmit()) {
+        // Skip pagination built-in buttons
+        if (interaction.customId === 'djs_prev' || interaction.customId === 'djs_next') return;
+
+        let component = this.components.get(interaction.customId);
+        let params: Record<string, string> = {};
+
+        if (!component) {
+          for (const [key, comp] of this.components) {
+            if (!key.includes('[')) continue;
+            // Escape regex chars except brackets
+            const escapedKey = key.replace(/[.*+?^${}()|\\-]/g, '\\$&');
+            // Transform \[id\] into (?<id>.+)
+            const regexStr = '^' + escapedKey.replace(/\\\[([^\]]+)\\\]/g, '(?<$1>.+)') + '$';
+            const match = interaction.customId.match(new RegExp(regexStr));
+            if (match) {
+              component = comp;
+              if (match.groups) params = match.groups;
+              break;
+            }
+          }
+        }
+        if (component) {
+          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);
+          }
+        }
+      }
+    });
+  }
+
+  public async start(token: string): Promise<void> {
+    if (!token) throw new Error("[djs-next] A token must be provided to start the bot.");
+
+    this.config = await loadConfig();
+
+    // Fallback options to config
+    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._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
+
+    // Load middleware from root
+    if (!this._middleware) {
+      const exts = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'];
+      const cwd = process.cwd();
+      for (const ext of exts) {
+        const mwPath = path.join(cwd, `middleware${ext}`);
+        if (fs.existsSync(mwPath)) {
+          try {
+            const mwModule = await import(pathToFileURL(mwPath).href);
+            this._middleware = mwModule.default?.middleware || mwModule.middleware || mwModule.default || mwModule;
+            if (this._middleware) {
+              console.log(`[djs-next] Loaded global middleware.`);
+              break;
+            }
+          } catch (err) {
+            console.error(`[djs-next] Error loading middleware file ${mwPath}:`, err);
+          }
+        }
+      }
+    }
+
+    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);
+    }
+
+    await this.login(token);
+    console.log(`[djs-next] Bot is ready and logged in as ${this.user?.tag}!`);
+  }
+
+  public enableDevTools(prefix: 'dnxt' | 'nxt' = 'dnxt'): void {
+    if (prefix !== 'dnxt' && prefix !== 'nxt') {
+      throw new Error(`[djs-next] Developer Tools prefix must be either 'dnxt' or 'nxt'. Received: ${prefix}`);
+    }
+
+    this.on('messageCreate', async (message) => {
+      await handleDNXT(message, this, prefix);
+    });
+
+    console.log(`[djs-next] 🛠️ Developer Tools enabled. Use "${prefix}" in chat. Ensure MessageContent intent is enabled!`);
+  }
+
+  public async enableHMR(): Promise<void> {
+    try {
+      const chokidar = await import('chokidar');
+      console.log(`[djs-next] 🔄 HMR Enabled. Watching for file changes...`);
+
+      const watcher = chokidar.watch([
+        this._commandsDir, 
+        this._eventsDir, 
+        this._componentsDir, 
+        this._localesDir
+      ].filter(Boolean) as string[], { ignoreInitial: true });
+
+      watcher.on('change', async (filePath) => {
+        console.log(`[djs-next] ♻️ File changed: ${filePath}. Reloading...`);
+        // We will just naively re-run the loaders. 
+        // For events, we need to remove all listeners first to avoid memory leaks.
+        this.removeAllListeners();
+        this.commands.clear();
+        this.components.clear();
+        
+        // Re-attach core listener
+        this.attachCoreListeners();
+
+        // Reload
+        if (this._eventsDir) await loadEvents(this, this._eventsDir);
+        if (this._componentsDir) this.components = await loadComponents(this._componentsDir);
+        if (this._commandsDir && this._clientId) {
+           this.commands = await loadAndDeployCommands(this._commandsDir, this.token!, this._clientId, this._guildId);
+        }
+        if (this._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
+        
+        console.log(`[djs-next] ✅ Hot Reload complete.`);
+      });
+    } catch (e) {
+      console.warn(`[djs-next] chokidar not installed. HMR is disabled. Please run "npm install chokidar" to use this feature.`);
+    }
+  }
+}

package/src/handlers/commandHandler.ts

@@ -0,0 +1,139 @@
+import { Collection, REST, Routes } from 'discord.js';
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { FileCommand } from '../types.js';
+import { getAllFiles } from './utils.js';
+
+interface CommandNode {
+  name: string;
+  description: string;
+  options: any[];
+  execute?: Function;
+  children: Map<string, CommandNode>;
+}
+
+export async function loadAndDeployCommands(
+  commandsDir: string, 
+  token: string, 
+  clientId: string,
+  guildId?: string
+): Promise<Collection<string, FileCommand>> {
+  const flatCommands = new Collection<string, FileCommand>();
+  
+  if (!fs.existsSync(commandsDir)) {
+    console.warn(`[djs-next] Commands directory "${commandsDir}" does not exist.`);
+    return flatCommands;
+  }
+
+  const commandFiles = getAllFiles(commandsDir);
+  const rootNodes = new Map<string, CommandNode>();
+
+  function getOrCreateNode(pathParts: string[]): CommandNode {
+    let currentMap = rootNodes;
+    let currentNode: CommandNode | undefined;
+
+    for (const part of pathParts) {
+      if (!currentMap.has(part)) {
+        currentMap.set(part, {
+          name: part,
+          description: `${part} command`, // Fallback description
+          options: [],
+          children: new Map()
+        });
+      }
+      currentNode = currentMap.get(part)!;
+      currentMap = currentNode.children;
+    }
+    return currentNode!;
+  }
+
+  for (const file of commandFiles) {
+    const relativePath = path.relative(commandsDir, file);
+    const parsed = path.parse(relativePath);
+    
+    // Normalize path separators
+    const dirParts = parsed.dir ? parsed.dir.split(path.sep) : [];
+    const name = parsed.name;
+    
+    const pathParts = [...dirParts];
+    if (name !== 'index') {
+      pathParts.push(name);
+    }
+
+    if (pathParts.length === 0) continue;
+    if (pathParts.length > 3) {
+      console.warn(`[djs-next] Command path too deep (Discord allows max 3 levels): ${relativePath}`);
+      continue;
+    }
+
+    const module = await import(pathToFileURL(file).href);
+    const commandData: FileCommand = module.default || module.command || module;
+    if (commandData) commandData.filepath = file;
+
+    const node = getOrCreateNode(pathParts);
+    if (commandData.description) node.description = commandData.description;
+    if (commandData.options) node.options = commandData.options;
+    if (commandData.execute) {
+      node.execute = commandData.execute;
+      // Map entire FileCommand object to a space-separated string (e.g. "economy balance")
+      flatCommands.set(pathParts.join(' '), commandData);
+    }
+  }
+
+  // Build JSON payloads for Discord
+  function buildCommandJSON(node: CommandNode, depth: number): any {
+    const json: any = {
+      name: node.name,
+      description: node.description,
+    };
+
+    if (node.children.size > 0) {
+      json.options = [];
+      for (const [_, childNode] of node.children) {
+        const childJson = buildCommandJSON(childNode, depth + 1);
+        
+        // 1 = SUB_COMMAND, 2 = SUB_COMMAND_GROUP
+        if (depth === 0) {
+          childJson.type = childNode.children.size > 0 ? 2 : 1;
+        } else if (depth === 1) {
+          childJson.type = 1;
+        }
+        
+        json.options.push(childJson);
+      }
+    } else if (node.options && node.options.length > 0) {
+      json.options = node.options;
+    }
+    
+    return json;
+  }
+
+  const commandsData = Array.from(rootNodes.values()).map(node => buildCommandJSON(node, 0));
+
+  // Deploy commands
+  const rest = new REST({ version: '10' }).setToken(token);
+
+  try {
+    console.log(`[djs-next] Started refreshing ${commandsData.length} File-System application (/) commands.`);
+
+    let data: any;
+    if (guildId) {
+      data = await rest.put(
+        Routes.applicationGuildCommands(clientId, guildId),
+        { body: commandsData },
+      );
+    } else {
+      data = await rest.put(
+        Routes.applicationCommands(clientId),
+        { body: commandsData },
+      );
+    }
+
+    console.log(`[djs-next] Successfully reloaded ${data.length} File-System application (/) commands.`);
+  } catch (error) {
+    console.error(`[djs-next] Failed to deploy commands:`, error);
+  }
+
+  return flatCommands;
+}

package/src/handlers/componentHandler.ts

@@ -0,0 +1,31 @@
+import { Collection } from 'discord.js';
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { FileComponent } from '../types.js';
+import { getAllFiles } from './utils.js';
+
+export async function loadComponents(componentsDir: string): Promise<Collection<string, FileComponent>> {
+  const components = new Collection<string, FileComponent>();
+  
+  if (!fs.existsSync(componentsDir)) return components;
+
+  const files = getAllFiles(componentsDir);
+
+  for (const file of files) {
+    const module = await import(pathToFileURL(file).href);
+    const componentData: FileComponent = module.default || module.component || module;
+    if (componentData) componentData.filepath = file;
+
+    if (!componentData || !componentData.execute) continue;
+
+    // Infer customId from filename if not explicitly provided
+    const parsed = path.parse(file);
+    const customId = componentData.customId || parsed.name;
+
+    components.set(customId, componentData);
+  }
+
+  console.log(`[djs-next] Successfully loaded ${components.size} components.`);
+  return components;
+}

package/src/handlers/eventHandler.ts

@@ -0,0 +1,37 @@
+import { Client } from 'discord.js';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import { Event } from '../types.js';
+import { getAllFiles } from './utils.js';
+
+export async function loadEvents(client: Client, eventsDir: string) {
+  if (!fs.existsSync(eventsDir)) {
+    console.warn(`[djs-next] Events directory "${eventsDir}" does not exist.`);
+    return;
+  }
+
+  const eventFiles = getAllFiles(eventsDir);
+  let loadedEvents = 0;
+
+  for (const file of eventFiles) {
+    const eventModule = await import(pathToFileURL(file).href);
+    const eventData: Event<any> = eventModule.default?.event || eventModule.event || eventModule.default || eventModule;
+    if (eventData) eventData.filepath = file;
+
+    if (!eventData || !eventData.name || !eventData.execute) {
+      console.warn(`[djs-next] The event at ${file} is missing a required "name" or "execute" property.`);
+      continue;
+    }
+
+    if (eventData.once) {
+      client.once(eventData.name, (...args) => eventData.execute(client, ...args));
+    } else {
+      client.on(eventData.name, (...args) => eventData.execute(client, ...args));
+    }
+    loadedEvents++;
+  }
+
+  if (loadedEvents > 0) {
+    console.log(`[djs-next] Successfully loaded ${loadedEvents} events.`);
+  }
+}

package/src/handlers/taskHandler.ts

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { Client } from 'discord.js';
+import { FileTask } from '../types.js';
+import { getAllFiles } from './utils.js';
+
+export async function loadTasks(client: Client, tasksDir: string) {
+  if (!fs.existsSync(tasksDir)) return;
+
+  const files = getAllFiles(tasksDir);
+  let loaded = 0;
+
+  for (const file of files) {
+    const module = await import(pathToFileURL(file).href);
+    const taskData: FileTask = module.default || module.task || module;
+    if (taskData) taskData.filepath = file;
+
+    if (!taskData || !taskData.interval || !taskData.execute) continue;
+
+    const intervalId = setInterval(async () => {
+      try {
+        await taskData.execute(client);
+      } catch (error) {
+        console.error(`[djs-next] Background Task error at ${file}:`, error);
+      }
+    }, taskData.interval);
+
+    if (!(client as any)._activeTasks) (client as any)._activeTasks = new Map();
+    (client as any)._activeTasks.set(file, intervalId);
+
+    loaded++;
+  }
+
+  if (loaded > 0) {
+    console.log(`[djs-next] Successfully scheduled ${loaded} background tasks.`);
+  }
+}

package/src/handlers/utils.ts

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Recursively gets all files in a directory
+ */
+export function getAllFiles(dirPath: string, arrayOfFiles: string[] = []): string[] {
+  const files = fs.readdirSync(dirPath);
+
+  files.forEach(file => {
+    const fullPath = path.join(dirPath, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
+    } else {
+      if (file.endsWith('.js') || file.endsWith('.ts') || file.endsWith('.mjs') || file.endsWith('.cjs')) {
+        // Skip TypeScript declaration files
+        if (!file.endsWith('.d.ts')) {
+          arrayOfFiles.push(fullPath);
+        }
+      }
+    }
+  });
+
+  return arrayOfFiles;
+}

package/src/index.ts

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