simple-discord-bot.js 0.1.3 → 0.2.0

package/README.md

@@ -0,0 +1,354 @@
+simple-discord-bot.js
+
+""npm version" (https://img.shields.io/npm/v/simple-discord-bot.js.svg)" (https://www.npmjs.com/package/simple-discord-bot.js)
+""npm downloads" (https://img.shields.io/npm/dm/simple-discord-bot.js.svg)" (https://www.npmjs.com/package/simple-discord-bot.js)
+""License" (https://img.shields.io/npm/l/simple-discord-bot.js.svg)" (https://www.npmjs.com/package/simple-discord-bot.js)
+""Node.js" (https://img.shields.io/badge/Node.js-18%2B-brightgreen.svg)" (https://nodejs.org/)
+
+A simple and lightweight Discord bot library for Node.js
+
+Built to make Discord bot development easier while keeping the API simple and beginner friendly
+
+---
+
+✨ Features
+
+- ⚡ Lightweight
+- 🧩 Simple API
+- 🤖 Discord bot support
+- 💬 Message events
+- ⚙️ Slash commands
+- 📝 Slash command options
+- 🎨 EmbedBuilder
+- 🔐 Permission checking
+- 💓 Gateway heartbeat
+- 🛑 Clean bot shutdown
+- 📦 Available through npm
+- 🟢 Easy to learn
+
+---
+
+📦 Installation
+
+Install the latest version with npm
+
+npm install simple-discord-bot.js
+
+---
+
+🚀 Quick Start
+
+Create a simple bot in just a few lines
+
+const { Client } = require("simple-discord-bot.js")
+
+const client = new Client()
+
+client.command("ping", interaction => {
+  interaction.reply("Pong!")
+}, {
+  description: "Replies with Pong!"
+})
+
+client.on("ready", () => {
+  console.log("Bot is online!")
+})
+
+client.login("YOUR_BOT_TOKEN")
+
+Start your bot
+
+node index.js
+
+---
+
+⚙️ Slash Commands
+
+Create commands with "client.command()"
+
+client.command("hello", interaction => {
+  interaction.reply("Hello!")
+}, {
+  description: "Says hello"
+})
+
+---
+
+🧩 Command Options
+
+Commands can have options
+
+client.command("say", interaction => {
+  interaction.reply(interaction.options.message)
+}, {
+  description: "Make the bot say something",
+  options: [
+    {
+      name: "message",
+      description: "The message to send",
+      type: 3,
+      required: true
+    }
+  ]
+})
+
+The option can then be accessed with
+
+interaction.options.message
+
+---
+
+🎨 Embeds
+
+Create beautiful Discord embeds with "EmbedBuilder"
+
+const { EmbedBuilder } = require("simple-discord-bot.js")
+
+const embed = new EmbedBuilder()
+  .setTitle("Hello")
+  .setDescription("This is an embed!")
+  .setColor("5865F2")
+  .setFooter("Made with SimpleDiscord.js")
+  .setTimestamp()
+
+interaction.reply(embed)
+
+Embed Methods
+
+Title
+
+.setTitle("Hello")
+
+Description
+
+.setDescription("This is my description")
+
+Color
+
+Hex colors are supported
+
+.setColor("FF0000")
+
+URL
+
+.setURL("https://example.com")
+
+Footer
+
+.setFooter("Made with SimpleDiscord.js")
+
+Footer Icon
+
+.setFooter(
+  "Made with SimpleDiscord.js",
+  "https://example.com/icon.png"
+)
+
+Author
+
+.setAuthor("SimpleBot")
+
+Author Icon
+
+.setAuthor(
+  "SimpleBot",
+  "https://example.com/icon.png"
+)
+
+Thumbnail
+
+.setThumbnail("https://example.com/image.png")
+
+Image
+
+.setImage("https://example.com/image.png")
+
+Timestamp
+
+.setTimestamp()
+
+---
+
+🔐 Permissions
+
+Check Discord permissions easily
+
+client.command("admin", interaction => {
+  if (!interaction.member?.permissions.has("Administrator")) {
+    return interaction.reply("You need Administrator")
+  }
+
+  interaction.reply("You have Administrator permission!")
+}, {
+  description: "Administrator only command"
+})
+
+---
+
+💬 Messages
+
+Listen for messages
+
+client.on("message", message => {
+  console.log(message.content)
+})
+
+Reply to messages
+
+message.reply("Hello!")
+
+---
+
+📡 Events
+
+SimpleDiscord.js currently supports:
+
+Event| Description
+"ready"| Bot is ready
+"message"| A message was created
+"error"| Gateway error
+"disconnect"| Bot disconnected
+
+Example
+
+client.on("ready", () => {
+  console.log("Bot is online!")
+})
+
+---
+
+🛠️ API
+
+Client
+
+const { Client } = require("simple-discord-bot.js")
+
+const client = new Client()
+
+"client.login(token)"
+
+Connect your bot to Discord
+
+client.login("YOUR_BOT_TOKEN")
+
+"client.command(name, handler, options)"
+
+Create a slash command
+
+client.command(
+  "ping",
+  interaction => {
+    interaction.reply("Pong!")
+  },
+  {
+    description: "Replies with Pong!"
+  }
+)
+
+"client.destroy()"
+
+Disconnect the bot
+
+client.destroy()
+
+---
+
+📊 Current Status
+
+SimpleDiscord.js is currently in early development
+
+Current version:
+
+0.1.2
+
+The API may change as the library develops
+
+---
+
+🗺️ Roadmap
+
+✅ Completed
+
+- [x] Discord Gateway connection
+- [x] Gateway heartbeat
+- [x] Bot login
+- [x] Clean shutdown
+- [x] Ready event
+- [x] Message events
+- [x] Message replies
+- [x] Slash commands
+- [x] Slash command options
+- [x] Permission checking
+- [x] EmbedBuilder
+- [x] npm publishing
+
+🚧 Planned
+
+- [ ] Embed fields
+- [ ] Buttons
+- [ ] Select menus
+- [ ] More interaction types
+- [ ] Channel objects
+- [ ] Guild objects
+- [ ] User objects
+- [ ] Message editing
+- [ ] Message deletion
+- [ ] More permission helpers
+- [ ] Better error handling
+- [ ] Automatic reconnection
+- [ ] Gateway resume support
+- [ ] More Discord API features
+
+---
+
+📚 Why SimpleDiscord.js?
+
+Discord libraries can become complicated when you're just starting
+
+SimpleDiscord.js focuses on keeping things straightforward
+
+Instead of learning a huge API you can start with:
+
+const { Client } = require("simple-discord-bot.js")
+
+const client = new Client()
+
+client.command("ping", interaction => {
+  interaction.reply("Pong!")
+})
+
+client.login("YOUR_BOT_TOKEN")
+
+Simple
+
+Lightweight
+
+Beginner friendly
+
+---
+
+📦 npm
+
+Install the package from npm
+
+npm install simple-discord-bot.js
+
+---
+
+🤝 Contributing
+
+Contributions and suggestions are welcome
+
+If you find a bug or have an idea for a feature you can open an issue or submit a pull request
+
+---
+
+📄 License
+
+MIT License
+
+---
+
+Made with ❤️ and JavaScript
+
+simple-discord-bot.js

package/api.js

@@ -1,5 +1,18 @@
 const https = require("https")
 
+class DiscordAPIError extends Error {
+  constructor(message, options = {}) {
+    super(message)
+
+    this.name = "DiscordAPIError"
+    this.code = options.code || null
+    this.status = options.status || null
+    this.method = options.method || null
+    this.path = options.path || null
+    this.errors = options.errors || null
+  }
+}
+
 class API {
   constructor(token) {
     this.token = token
@@ -7,7 +20,10 @@ class API {
 
   request(method, path, body = null) {
     return new Promise((resolve, reject) => {
-      const data = body ? JSON.stringify(body) : null
+      const data =
+        body !== null
+          ? JSON.stringify(body)
+          : null
 
       const headers = {
         Authorization: `Bot ${this.token}`,
@@ -15,7 +31,8 @@ class API {
       }
 
       if (data) {
-        headers["Content-Length"] = Buffer.byteLength(data)
+        headers["Content-Length"] =
+          Buffer.byteLength(data)
       }
 
       const req = https.request({
@@ -31,25 +48,57 @@ class API {
         })
 
         res.on("end", () => {
+          let parsed
+
           try {
-            resolve(JSON.parse(result))
+            parsed =
+              result
+                ? JSON.parse(result)
+                : null
           } catch {
-            resolve(result)
+            parsed = result
           }
+
+          if (
+            res.statusCode < 200 ||
+            res.statusCode >= 300
+          ) {
+            const message =
+              parsed?.message ||
+              "Discord API request failed."
+
+            const error =
+              new DiscordAPIError(
+                message,
+                {
+                  code: parsed?.code,
+                  status: res.statusCode,
+                  method,
+                  path,
+                  errors: parsed?.errors
+                }
+              )
+
+            reject(error)
+            return
+          }
+
+          resolve(parsed)
         })
       })
 
-      req.on("error", reject)
-
-      if (data) {
-        req.write(data)
-      }
+      req.on("error", error => {
+        reject(error)
+      })
 
-      req.end()
+      req.end(data || undefined)
     })
   }
 
-  registerCommands(applicationId, commands) {
+  registerCommands(
+    applicationId,
+    commands
+  ) {
     return this.request(
       "PUT",
       `/applications/${applicationId}/commands`,
@@ -58,4 +107,7 @@ class API {
   }
 }
 
+API.DiscordAPIError =
+  DiscordAPIError
+
 module.exports = API

package/client.js

@@ -46,15 +46,20 @@ class Permissions {
   has(permission) {
     const flag = PermissionFlags[permission]
 
-    if (flag === undefined) {
+    if (!flag) {
       return false
     }
 
-    if ((this.bitfield & PermissionFlags.Administrator) !== 0n) {
+    if (
+      (this.bitfield &
+        PermissionFlags.Administrator) !== 0n
+    ) {
       return true
     }
 
-    return (this.bitfield & flag) !== 0n
+    return (
+      (this.bitfield & flag) !== 0n
+    )
   }
 }
 
@@ -64,113 +69,483 @@ class Client extends EventEmitter {
 
     this.token = null
     this.user = null
+    this.applicationId = null
     this.api = null
     this.gateway = new Gateway(this)
     this.commands = new Map()
+
     this.stopping = false
+    this.ready = false
+    this.readyAt = null
 
     this.on("rawMessage", data => {
-      const message = new Message(this, data)
-      this.emit("message", message)
+      const message =
+        new Message(this, data)
+
+      this.emit(
+        "message",
+        message
+      )
     })
 
     this.on("rawInteraction", data => {
-      if (data.type !== 2) return
+      if (data.type === 2) {
+        this.handleCommandInteraction(
+          data
+        )
+
+        return
+      }
+
+      if (data.type === 3) {
+        this.handleComponentInteraction(
+          data
+        )
+      }
+    })
+
+    this.on("rawReady", async data => {
+      this.user = data.user
 
-      const command = this.commands.get(data.data.name)
+      this.applicationId =
+        data.application?.id ||
+        data.user?.id
+
+      try {
+        await this.syncCommands()
+
+        this.ready = true
+        this.readyAt = Date.now()
+
+        this.emit(
+          "ready",
+          data
+        )
+      } catch (error) {
+        this.emit(
+          "error",
+          error
+        )
+      }
+    })
+
+    this.on("disconnect", () => {
+      this.ready = false
+      this.readyAt = null
+    })
 
-      if (!command) return
+    process.on("SIGINT", () => {
+      if (this.stopping) return
 
-      const member = data.member
+      this.stopping = true
 
-      const interaction = {
-        id: data.id,
-        token: data.token,
+      this.destroy()
 
-        commandName: data.data.name,
+      setTimeout(() => {
+        process.exit(0)
+      }, 1000)
+    })
+  }
 
-        user: member?.user || data.user,
+  isReady() {
+    return this.ready
+  }
 
-        member: member ? {
-          ...member,
+  get uptime() {
+    if (!this.readyAt) {
+      return null
+    }
 
-          permissions: new Permissions(member.permissions)
-        } : null,
+    return Date.now() - this.readyAt
+  }
 
-        channelId: data.channel_id,
+  createInteraction(data, type) {
+    const member = data.member
 
-        guildId: data.guild_id || null,
+    const interaction = {
+      id: data.id,
+      token: data.token,
+      type: type,
 
-        options: {},
+      user:
+        member?.user ||
+        data.user,
 
-        reply: content => {
-          const messageData = {}
+      member: member
+        ? {
+            ...member,
 
-          if (typeof content === "string") {
-            messageData.content = content
-          } else if (
-            content &&
-            typeof content.toJSON === "function"
-          ) {
-            messageData.embeds = [content.toJSON()]
-          } else if (content && typeof content === "object") {
-            Object.assign(messageData, content)
+            permissions:
+              new Permissions(
+                member.permissions
+              )
           }
+        : null,
+
+      channelId:
+        data.channel_id,
+
+      guildId:
+        data.guild_id ||
+        null,
+
+      replied: false,
+      deferred: false,
 
-          return this.api.request(
-            "POST",
-            `/interactions/${data.id}/${data.token}/callback`,
-            {
-              type: 4,
-              data: messageData
-            }
+      reply: async content => {
+        return this.replyToInteraction(
+          data,
+          content,
+          interaction
+        )
+      },
+
+      deferReply: async () => {
+        if (
+          interaction.replied ||
+          interaction.deferred
+        ) {
+          throw new Error(
+            "This interaction has already been responded to."
           )
         }
+
+        await this.api.request(
+          "POST",
+          `/interactions/${data.id}/${data.token}/callback`,
+          {
+            type: 5,
+            data: {}
+          }
+        )
+
+        interaction.deferred = true
+
+        return true
+      },
+
+      editReply: async content => {
+        if (
+          !interaction.replied &&
+          !interaction.deferred
+        ) {
+          throw new Error(
+            "You must reply or defer the interaction first."
+          )
+        }
+
+        const messageData =
+          this.formatInteractionContent(
+            content
+          )
+
+        return this.api.request(
+          "PATCH",
+          `/webhooks/${this.applicationId}/${data.token}/messages/@original`,
+          messageData
+        )
+      },
+
+      deleteReply: async () => {
+        if (
+          !interaction.replied &&
+          !interaction.deferred
+        ) {
+          throw new Error(
+            "You must reply or defer the interaction first."
+          )
+        }
+
+        await this.api.request(
+          "DELETE",
+          `/webhooks/${this.applicationId}/${data.token}/messages/@original`
+        )
+
+        return true
       }
+    }
+
+    return interaction
+  }
+
+  formatInteractionContent(content) {
+    const messageData = {}
+
+    if (typeof content === "string") {
+      messageData.content =
+        content
+    } else if (
+      content &&
+      typeof content.toJSON === "function"
+    ) {
+      messageData.embeds = [
+        content.toJSON()
+      ]
+    } else if (
+      content &&
+      typeof content === "object"
+    ) {
+      Object.assign(
+        messageData,
+        content
+      )
+    }
+
+    return messageData
+  }
+
+  handleCommandInteraction(data) {
+    const command =
+      this.commands.get(
+        data.data.name
+      )
+
+    if (!command) return
+
+    const interaction =
+      this.createInteraction(
+        data,
+        "command"
+      )
 
-      for (const option of data.data.options || []) {
-        interaction.options[option.name] = option.value
+    interaction.commandName =
+      data.data.name
+
+    interaction.options = {}
+
+    for (
+      const option of
+        data.data.options || []
+    ) {
+      interaction.options[
+        option.name
+      ] = option.value
+    }
+
+    try {
+      const result =
+        command.handler(
+          interaction
+        )
+
+      if (result?.catch) {
+        result.catch(error => {
+          this.emit(
+            "error",
+            error
+          )
+        })
       }
+    } catch (error) {
+      this.emit(
+        "error",
+        error
+      )
+    }
+  }
 
-      command.handler(interaction)
-    })
+  handleComponentInteraction(data) {
+    const componentType =
+      data.data.component_type
 
-    process.on("SIGINT", () => {
-      if (this.stopping) return
+    let type = "selectMenu"
 
-      this.stopping = true
+    if (componentType === 2) {
+      type = "button"
+    }
 
-      console.log("Stopping bot...")
+    const interaction =
+      this.createInteraction(
+        data,
+        type
+      )
 
-      this.destroy()
+    interaction.componentType =
+      componentType
 
-      setTimeout(() => {
-        process.exit(0)
-      }, 1000)
+    interaction.customId =
+      data.data.custom_id
+
+    interaction.values =
+      data.data.values || []
+
+    this.emit(
+      "interaction",
+      interaction
+    )
+  }
+
+  replyToInteraction(
+    data,
+    content,
+    interaction = null
+  ) {
+    if (
+      interaction?.replied ||
+      interaction?.deferred
+    ) {
+      return Promise.reject(
+        new Error(
+          "This interaction has already been responded to."
+        )
+      )
+    }
+
+    const messageData =
+      this.formatInteractionContent(
+        content
+      )
+
+    return this.api.request(
+      "POST",
+      `/interactions/${data.id}/${data.token}/callback`,
+      {
+        type: 4,
+        data: messageData
+      }
+    ).then(result => {
+      if (interaction) {
+        interaction.replied = true
+      }
+
+      return result
     })
   }
 
+  async syncCommands() {
+    if (!this.applicationId) {
+      throw new Error(
+        "Application ID is not available."
+      )
+    }
+
+    const commands = []
+
+    for (
+      const entry of
+        this.commands.values()
+    ) {
+      commands.push(
+        entry.command
+      )
+    }
+
+    const result =
+      await this.api.registerCommands(
+        this.applicationId,
+        commands
+      )
+
+    if (!Array.isArray(result)) {
+      throw new Error(
+        "Failed to register slash commands: " +
+        JSON.stringify(result)
+      )
+    }
+
+    return result
+  }
+
   login(token) {
     this.token = token
     this.api = new API(token)
 
-    return this.gateway.connect(token)
+    return this.gateway.connect(
+      token
+    )
   }
 
   destroy() {
     this.gateway.destroy()
-    this.emit("disconnect")
+
+    this.ready = false
+    this.readyAt = null
+
+    this.emit(
+      "disconnect"
+    )
   }
 
-  command(name, handler, options = {}) {
-    this.commands.set(name, {
-      command: {
-        name: name,
-        description: options.description || "No description",
-        options: options.options || []
-      },
-      handler
-    })
+  command(
+    name,
+    handler,
+    options = {}
+  ) {
+    this.commands.set(
+      name,
+      {
+        command: {
+          name: name,
+
+          description:
+            options.description ||
+            "No description",
+
+          options:
+            options.options ||
+            []
+        },
+
+        handler: handler
+      }
+    )
+
+    return this
+  }
+
+  async removeCommand(name) {
+    const command =
+      this.commands.get(name)
+
+    if (!command) {
+      return false
+    }
+
+    if (!this.applicationId) {
+      throw new Error(
+        "Bot must be logged in before removing a Discord slash command."
+      )
+    }
+
+    const commands =
+      await this.api.request(
+        "GET",
+        `/applications/${this.applicationId}/commands`
+      )
+
+    if (!Array.isArray(commands)) {
+      throw new Error(
+        "Failed to retrieve Discord application commands."
+      )
+    }
+
+    const discordCommand =
+      commands.find(
+        command =>
+          command.name === name
+      )
+
+    if (discordCommand) {
+      await this.api.request(
+        "DELETE",
+        `/applications/${this.applicationId}/commands/${discordCommand.id}`
+      )
+    }
+
+    this.commands.delete(name)
+
+    return true
+  }
+
+  getCommand(name) {
+    return (
+      this.commands.get(name) ||
+      null
+    )
+  }
+
+  hasCommand(name) {
+    return this.commands.has(name)
   }
 }
 

package/gateway.js

@@ -13,11 +13,13 @@ class Gateway {
     )
 
     this.ws.on("open", () => {
+      console.log("Connected to Discord Gateway")
+
       this.ws.send(JSON.stringify({
         op: 2,
         d: {
           token: token,
-          intents: 33281,
+          intents: 33281 | 32768,
           properties: {
             os: "android",
             browser: "SimpleDiscord.js",
@@ -28,23 +30,36 @@ class Gateway {
     })
 
     this.ws.on("message", data => {
-      const packet = JSON.parse(data)
+      try {
+        const packet = JSON.parse(data)
 
-      if (packet.op === 10) {
-        this.startHeartbeat(packet.d.heartbeat_interval)
-      }
+        if (packet.op === 10) {
+          console.log("Gateway connected")
+          this.startHeartbeat(packet.d.heartbeat_interval)
+        }
 
-      if (packet.t === "READY") {
-        this.client.user = packet.d.user
-        this.client.emit("ready", packet.d)
-      }
+        if (packet.op === 9) {
+          console.error("Discord rejected the Gateway connection")
+          return
+        }
 
-      if (packet.t === "MESSAGE_CREATE") {
-        this.client.emit("rawMessage", packet.d)
-      }
+        if (packet.t === "READY") {
+  this.client.user = packet.d.user
+  this.client.applicationId =
+    packet.d.application?.id ||
+    packet.d.user?.id
 
-      if (packet.t === "INTERACTION_CREATE") {
-        this.client.emit("rawInteraction", packet.d)
+  this.client.emit("rawReady", packet.d)
+}
+        if (packet.t === "MESSAGE_CREATE") {
+          this.client.emit("rawMessage", packet.d)
+        }
+
+        if (packet.t === "INTERACTION_CREATE") {
+          this.client.emit("rawInteraction", packet.d)
+        }
+      } catch (error) {
+        this.client.emit("error", error)
       }
     })
 
@@ -57,6 +72,8 @@ class Gateway {
       this.ws = null
       this.client.emit("disconnect")
     })
+
+    return this.ws
   }
 
   startHeartbeat(interval) {
@@ -84,6 +101,7 @@ class Gateway {
 
     if (this.ws) {
       this.ws.close(1000, "Bot stopped")
+      this.ws = null
     }
   }
 }

package/index.js

@@ -1,7 +1,15 @@
 const Client = require("./client")
 const EmbedBuilder = require("./structures/EmbedBuilder")
+const ButtonBuilder = require("./structures/ButtonBuilder")
+const SelectMenuBuilder = require("./structures/SelectMenuBuilder")
+const ActionRowBuilder = require("./structures/ActionRowBuilder")
+const API = require("./api")
 
 module.exports = {
   Client,
-  EmbedBuilder
+  EmbedBuilder,
+  ButtonBuilder,
+  SelectMenuBuilder,
+  ActionRowBuilder,
+  DiscordAPIError: API.DiscordAPIError
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-discord-bot.js",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "A simple Discord bot library",
   "main": "index.js",
   "license": "MIT",

package/structures/ActionRowBuilder.js

@@ -0,0 +1,42 @@
+class ActionRowBuilder {
+  constructor() {
+    this.data = {
+      type: 1,
+      components: []
+    }
+  }
+
+  addComponents(...components) {
+    for (const component of components) {
+      if (!component) continue
+
+      if (typeof component.toJSON === "function") {
+        this.data.components.push(
+          component.toJSON()
+        )
+      } else if (
+        typeof component === "object"
+      ) {
+        this.data.components.push(
+          component
+        )
+      }
+    }
+
+    return this
+  }
+
+  setComponents(...components) {
+    this.data.components = []
+
+    return this.addComponents(
+      ...components
+    )
+  }
+
+  toJSON() {
+    return this.data
+  }
+}
+
+module.exports = ActionRowBuilder

package/structures/ButtonBuilder.js

@@ -0,0 +1,50 @@
+class ButtonBuilder {
+  constructor() {
+    this.data = {
+      type: 2
+    }
+  }
+
+  setCustomId(customId) {
+    this.data.custom_id = customId
+    return this
+  }
+
+  setLabel(label) {
+    this.data.label = label
+    return this
+  }
+
+  setStyle(style) {
+    const styles = {
+      primary: 1,
+      secondary: 2,
+      success: 3,
+      danger: 4,
+      link: 5
+    }
+
+    if (typeof style === "string") {
+      style = styles[style.toLowerCase()]
+    }
+
+    this.data.style = style
+    return this
+  }
+
+  setURL(url) {
+    this.data.url = url
+    return this
+  }
+
+  setDisabled(disabled = true) {
+    this.data.disabled = disabled
+    return this
+  }
+
+  toJSON() {
+    return this.data
+  }
+}
+
+module.exports = ButtonBuilder

package/structures/EmbedBuilder.js

@@ -82,6 +82,40 @@ class EmbedBuilder {
     return this
   }
 
+  addField(name, value, inline = false) {
+    if (!this.data.fields) {
+      this.data.fields = []
+    }
+
+    this.data.fields.push({
+      name: name,
+      value: value,
+      inline: inline
+    })
+
+    return this
+  }
+
+  addFields(...fields) {
+    for (const field of fields) {
+      if (
+        !field ||
+        typeof field.name !== "string" ||
+        typeof field.value !== "string"
+      ) {
+        continue
+      }
+
+      this.addField(
+        field.name,
+        field.value,
+        field.inline || false
+      )
+    }
+
+    return this
+  }
+
   toJSON() {
     return this.data
   }

package/structures/Message.js

@@ -1,22 +1,53 @@
 class Message {
   constructor(client, data) {
     this.client = client
-
     this.id = data.id
-    this.content = data.content
+    this.content = data.content || ""
     this.channelId = data.channel_id
-    this.guildId = data.guild_id
-    this.author = data.author
+    this.guildId = data.guild_id || null
+    this.author = data.author || null
   }
 
-  reply(content) {
-    return this.client.api.request(
+  async reply(content) {
+    const data = await this.client.api.request(
       "POST",
       `/channels/${this.channelId}/messages`,
       {
         content: content
       }
     )
+
+    if (!data || !data.id) {
+      throw new Error(
+        "Discord did not return a valid message: " +
+        JSON.stringify(data)
+      )
+    }
+
+    return new Message(this.client, data)
+  }
+
+  async edit(content) {
+    const data = await this.client.api.request(
+      "PATCH",
+      `/channels/${this.channelId}/messages/${this.id}`,
+      {
+        content: content
+      }
+    )
+
+    this.content = data.content || content
+
+    return this
+  }
+
+  async delete() {
+    await this.client.api.request(
+      "DELETE",
+      `/channels/${this.channelId}/messages/${this.id}`
+    )
+
+    return true
   }
 }
 

package/structures/SelectMenuBuilder.js

@@ -0,0 +1,68 @@
+class SelectMenuBuilder {
+  constructor() {
+    this.data = {
+      type: 3,
+      options: []
+    }
+  }
+
+  setCustomId(customId) {
+    this.data.custom_id = customId
+    return this
+  }
+
+  setPlaceholder(placeholder) {
+    this.data.placeholder = placeholder
+    return this
+  }
+
+  addOptions(...options) {
+    for (const option of options) {
+      if (!option || !option.label || !option.value) {
+        continue
+      }
+
+      const data = {
+        label: option.label,
+        value: option.value
+      }
+
+      if (option.description) {
+        data.description = option.description
+      }
+
+      if (option.emoji) {
+        data.emoji = option.emoji
+      }
+
+      if (option.default) {
+        data.default = true
+      }
+
+      this.data.options.push(data)
+    }
+
+    return this
+  }
+
+  setMinValues(min) {
+    this.data.min_values = min
+    return this
+  }
+
+  setMaxValues(max) {
+    this.data.max_values = max
+    return this
+  }
+
+  setDisabled(disabled = true) {
+    this.data.disabled = disabled
+    return this
+  }
+
+  toJSON() {
+    return this.data
+  }
+}
+
+module.exports = SelectMenuBuilder