Client

The Client class (exported as ERXClient) is the entry point of syntx.js. It wraps a regular discord.js Client and adds a declarative layer for text commands, slash commands, events, and component interactions.

const { ERXClient } = require("syntx.js");

Constructor

new ERXClient(options);

Options

const { ERXClient, Intents } = require("syntx.js");

const client = new ERXClient({
  token: process.env.TOKEN,
  intents: [Intents.Guilds, Intents.GuildMessages, Intents.MessageContent],
  prefix: "!",
  clientId: "YOUR_APPLICATION_ID",
});

About intents

syntx.js re-exports a typed Intents helper so you don't have to import GatewayIntentBits from discord.js yourself.

const { Intents } = require("syntx.js");

Intents.Guilds; // a single intent
Intents.Fast; // Guilds, MessageContent, GuildMembers, GuildMessages; a sane default
Intents.All; // every intent there is

Properties

Methods

client.ready(callback)

Runs callback once, the first time the bot connects to Discord.

client.ready(() => {
  console.log(`Logged in as ${client.bot.user.tag}`);
});

client.start()

Logs the bot in and connects it to Discord. Call this last, after every command, event, and handler has been registered.

client.start();

client.kill()

Destroys the connection to Discord. Useful for graceful shutdowns or restart scripts.

client.kill();

client.setMaxListeners(max)

Raises the max listener limit on the underlying discord.js client. Helpful for larger bots that trigger Node's default "possible EventEmitter memory leak" warning.

client.setMaxListeners(20);

client.command({ name, alias, content })

Registers a prefix-based text command. content receives the raw discord.js Message.

client.command({
  name: "ping",
  alias: ["p"],
  content: (message) => {
    message.reply("Pong!");
  },
});

client.registerCommands()

Starts listening for messages and dispatches them to the handlers registered with command(). Call it once, after all your client.command() calls.

client.registerCommands();

client.slash({ data, execute, autocomplete })

Registers a slash command definition.

const { SlashCommand } = require("syntx.js");

client.slash({
  data: new SlashCommand({
    name: "ping",
    description: "Replies with the bot latency",
  }),
  execute: async (interaction) => {
    await interaction.reply(`Pong! ${client.bot.ws.ping}ms`);
  },
});

client.registerSlashCommands({ guildId, showLoad })

Publishes every command registered with slash() to Discord and starts listening for interactions.

await client.registerSlashCommands({ guildId: "123456789012345678", showLoad: true });

client.interaction({ id, content, separator })

Registers a handler for a button or select menu whose customId matches id. id supports {placeholder} segments for dynamic values, similar to a route pattern.

client.interaction({
  id: "delete-{messageId}",
  content: (interaction, { messageId }) => {
    interaction.reply(`Deleting message ${messageId}...`);
  },
});

client.modal({ id, run })

Registers a handler for a modal submission. Works like interaction(), but id always uses - as its separator.

client.modal({
  id: "feedback-{userId}",
  run: (interaction, { userId }) => {
    const text = interaction.fields.getTextInputValue("message");
    interaction.reply(`Thanks <@${userId}>, got: ${text}`);
  },
});

client.registerInteractions()

Attaches a single listener that dispatches button presses and select menu interactions to your interaction() handlers, and modal submissions to your modal() handlers, based on customId.

client.registerInteractions();

client.event(name, callback)

Listens to a discord.js event. name must match one of discord.js's Events values (for example "messageCreate", "guildMemberAdd", "interactionCreate").

client.event("messageCreate", (message) => {
  if (message.content === "ping") message.reply("pong");
});

client.presence({ time, activities, status })

Rotates the bot's status on an interval, starting once the bot is ready.

type accepts "playing", "streaming", "listening", "watching", or "competing".

client.presence({
  time: 15,
  status: "idle",
  activities: [
    { type: "watching", content: "the server" },
    { type: "listening", content: "/help" },
  ],
});

client.handler(paths, showLoad)

Auto-loads and registers files from folders you point it to; a faster alternative to calling command(), event(), slash(), modal(), and interaction() by hand for every file. Every .js file inside the given folder (including subfolders) is loaded and registered automatically.

client.handler(
  {
    commands: "./src/commands",
    events: "./src/events",
    slash: "./src/slash",
    interactions: "./src/interactions",
    modals: "./src/modals",
  },
  true,
);

The second argument (showLoad) is a plain boolean, not part of the first object; pass true to print a per-file load report to the console.

Each folder expects its files to export a specific shape:

Putting it all together

const { ERXClient, Intents } = require("syntx.js");

const client = new ERXClient({
  token: process.env.TOKEN,
  intents: Intents.Fast,
  prefix: "!",
  clientId: "YOUR_APPLICATION_ID",
});

client.ready(() => {
  console.log(`Logged in as ${client.bot.user.tag}`);
});

client.command({
  name: "ping",
  content: (message) => message.reply("Pong!"),
});

client.registerCommands();
client.start();

See SlashCommand to build slash commands, Database to store bot data, Embed to send rich embeds, and Poll to attach native polls to a message. For interactive UI, see Buttons, SelectMenus, Modal, and Display.