fenixenbot.js/src/FenixenBot.js

Libreria Creacion De Bots De Discord

const Discord = require("discord.js");
const handleEvent = require("./Handlers/EventsHandler");
const handleCommands = require("./Handlers/CommandHandler");
const handlePrefixCommands = require("./Handlers/PrrefixCommandsHandler");
const handleButtons = require("./Handlers/ButtonHandler");
const { Yaml } = require("../src/Utils/LoadYmlFile");
const path = require("path");
const Color = require("../src/Utils/Color");
const reload = require("../src/Utils/Reload");
const registerSlashCommands = require("./Registers/registerSlashCommands");
const { commands, prefixCommands } = require("./Utils/commands");
const Canvas = require("./Utils/Canvas");
const {MongoConnect} = require("./libs/MongoConnect");
const MSchema = require("./Schema/MongoSchema");
const RMSchemas = require("./Registers/RegisterMSchemas");
const  SequelizeConnect  = require("./libs/SequelizeConnect");
const SSchema = require("./Schema/SequelizeSchema");
const RegisterSSchemas = require("./Registers/RegisterSSchemas");

Object.entries(Discord).forEach(([key, value]) => {
  global[key] = value;
});

global.Discord = require("discord.js");

let yml = () => ({});

function FenixenBot(options) {
  if (!options || !options.token) {
    throw new Error(
        Color.red,
        "El token es obligatorio para inicializar FenixenBot.",
        Color.reset
    );
  }

  const {
    token,
    intents,
    partials,
    setupClient,
    eventHandler,
    commandsHandler,
    buttonsHandler,
    clientId,
    prefixCommandsHandler,
    prefix,
    nameBot,
    mongoConnect,
    mongoSchemas,
    sequelizeConnect,
    sequelizeSchemas,
  } = options;

  const defaultIntents = [
    Discord.GatewayIntentBits.Guilds,
    Discord.GatewayIntentBits.GuildMessages,
    Discord.GatewayIntentBits.MessageContent,
    Discord.GatewayIntentBits.GuildMembers,
    Discord.GatewayIntentBits.GuildVoiceStates,
    Discord.GatewayIntentBits.GuildPresences,
  ];

  const defaultPartials = [
    Discord.Partials.Message,
    Discord.Partials.Channel,
    Discord.Partials.Reaction,
  ];


  const client = new Discord.Client({
    intents: intents || defaultIntents,
    partials: partials || defaultPartials,
  });
  client.token = token;

  if(sequelizeConnect) {
    SequelizeConnect(sequelizeConnect);
    client.sequelize = SequelizeConnect(sequelizeConnect);
  }

  if(mongoConnect) {
    MongoConnect(mongoConnect);
    client.mongo = mongoConnect;
  }
  if(sequelizeConnect) {
    client.sequelize = SequelizeConnect(sequelizeConnect);
  }


  if (commandsHandler) {
    const commandsPath = path.resolve(commandsHandler);
    handleCommands(client, commandsPath);
  }
  if (eventHandler) {
    const eventsPath = path.resolve(eventHandler);
    handleEvent(client, eventsPath);
  }

  if (buttonsHandler) {
    const buttonsPath = path.resolve(buttonsHandler);
    handleButtons(client, buttonsPath);
  }

  if (prefixCommandsHandler) {
    const prefixCommandsPath = path.resolve(prefixCommandsHandler);
    handlePrefixCommands(client, prefixCommandsPath);
  }

  if (typeof setupClient === "function") {
    setupClient(client);
  }

  reload(
      client,
      clientId,
      Discord,
      commandsHandler,
      eventHandler,
      buttonsHandler,
      prefixCommandsHandler,
      token,
      nameBot
  );


  client.on("interactionCreate", async (interaction) => {
    if (!interaction.isButton()) {
      return;
    }

    const button = client.buttons.get(interaction.customId);
    if (!button) {
      console.warn(`Botón no encontrado: ${interaction.customId}`);
      return interaction.reply({
        content: 'Botón no reconocido.',
        flags: 64,
      });
    }

    try {
      await button.execute(interaction, client);
    } catch (error) {
      console.error('Error al ejecutar botón:', error);
      await interaction.reply({
        content: '¡Hubo un error al ejecutar este botón!',
        flags: 64,
      });
    }
  })

  client.on("interactionCreate", async (interaction) => {
    if (!interaction.isCommand()) return;

    const command = client.commands.get(interaction.commandName);

    if (!command) return;

    try {
      await command.execute(interaction);
    } catch (error) {
      console.error(
          Color.red,
          "Error al ejecutar comando:",
          Color.reset,
          error
      );
      await interaction.reply({
        content: "¡Hubo un error al ejecutar este comando!",
        ephemeral: true,
      });
    }
  });

  client.once("ready", async () => {
    if (sequelizeConnect) {
      client.sequelize = await SequelizeConnect(sequelizeConnect);
      const resolvedSequelizeSchemasPath = sequelizeSchemas ? path.resolve(sequelizeSchemas) : path.join(process.cwd(), "ModelsDB_Sequelize");
      client.models = await RegisterSSchemas(resolvedSequelizeSchemasPath, client.sequelize);
    }
    if (mongoConnect) {
      const resolvedSchemasPath = mongoSchemas
          ? path.resolve(mongoSchemas)
          : path.join(process.cwd(), "ModelsDB");
      client.models = RMSchemas(resolvedSchemasPath);
    }
    try {
      setTimeout(async () => {
        const allCommands = Array.from(client.commands.values());
        if (allCommands.length > 0) {
          await registerSlashCommands(token, clientId, allCommands);
        } else {
          console.warn(`${Color.yellow}No se encontraron comandos para registrar${Color.reset}`);
        }
      }, 1000);
    } catch (error) {
      console.error(
          Color.red,
          "Error al registrar comandos slash:",
          Color.reset,
          error
      );
    }
  });



  client.on("messageCreate", async (message) => {
    if (message.author.bot) return;
    if (!message.content.startsWith(prefix)) return;

    const args = message.content.slice(prefix.length).trim().split(/ +/);
    const commandName = args.shift().toLowerCase();

    const command =
        client.prefixCommands.get(commandName) ||
        client.prefixCommands.find(
            (cmd) => cmd.aliases && cmd.aliases.includes(commandName)
        );

    if (!command) return;

    try {
      command.execute(message, args);
    } catch (error) {
      console.error(
          `${Color.red}Error al ejecutar comando de prefijo:${Color.reset}`,
          error
      );
      message.reply("¡Hubo un error al ejecutar este comando de prefijo!");
    }
  });

  client.login(token);



  return client;
}

function registerEvents(client, eventDefinitions) {
  for (const eventDef of eventDefinitions) {
    client.on(eventDef.event, eventDef.execute.bind(null, client));
    console.log(
        Color.green,
        `Evento registrado: ${eventDef.event}`,
        Color.reset
    );
  }
}

function event(eventOptions) {
  const { name, event, execute, once } = eventOptions;
  if (!name) {
    throw new Error(
        Color.red,
        "El nombre del evento es obligatorio.",
        Color.reset
    );
  }
  if (!event) {
    throw new Error(
        Color.red,
        "El nombre del evento de Discord es obligatorio.",
        Color.reset
    );
  }
  if (typeof execute !== "function") {
    throw new Error(
        Color.red,
        `La función 'execute' es obligatoria para el evento ${Color.yellow}'${name}'.`,
        Color.reset
    );
  }
  return { name, event, execute, once };
}
function Button({ customId, execute }) {
  if (!customId || typeof execute !== "function") {
    throw new Error("Debes proporcionar 'customId' y una función 'execute'");
  }

  return {
    data: { customId },
    execute,
  };
}

module.exports = {
  FenixenBot,
  commands,
  prefixCommands,
  registerEvents,
  Yaml,
  event,
  Color,
  registerSlashCommands,
  Canvas,
  MSchema,
  Button,
  SSchema,
};