simple-discord-bot.js 0.1.4 → 0.2.0

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

@@ -51,12 +51,15 @@ class Permissions {
     }
 
     if (
-      (this.bitfield & PermissionFlags.Administrator) !== 0n
+      (this.bitfield &
+        PermissionFlags.Administrator) !== 0n
     ) {
       return true
     }
 
-    return (this.bitfield & flag) !== 0n
+    return (
+      (this.bitfield & flag) !== 0n
+    )
   }
 }
 
@@ -66,31 +69,76 @@ 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) {
-        this.handleCommandInteraction(data)
+        this.handleCommandInteraction(
+          data
+        )
+
         return
       }
 
       if (data.type === 3) {
-        this.handleComponentInteraction(data)
+        this.handleComponentInteraction(
+          data
+        )
+      }
+    })
+
+    this.on("rawReady", async data => {
+      this.user = data.user
+
+      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
+    })
+
     process.on("SIGINT", () => {
       if (this.stopping) return
 
       this.stopping = true
+
       this.destroy()
 
       setTimeout(() => {
@@ -99,101 +147,255 @@ class Client extends EventEmitter {
     })
   }
 
-  handleCommandInteraction(data) {
-    const command = this.commands.get(data.data.name)
+  isReady() {
+    return this.ready
+  }
 
-    if (!command) return
+  get uptime() {
+    if (!this.readyAt) {
+      return null
+    }
+
+    return Date.now() - this.readyAt
+  }
 
+  createInteraction(data, type) {
     const member = data.member
 
     const interaction = {
       id: data.id,
       token: data.token,
-      type: "command",
-      commandName: data.data.name,
-      user: member?.user || data.user,
+      type: type,
+
+      user:
+        member?.user ||
+        data.user,
 
       member: member
         ? {
             ...member,
-            permissions: new Permissions(
-              member.permissions
-            )
+
+            permissions:
+              new Permissions(
+                member.permissions
+              )
           }
         : null,
 
-      channelId: data.channel_id,
-      guildId: data.guild_id || null,
-      options: {},
-
-      reply: content => {
-        return this.replyToInteraction(data, content)
-      }
-    }
-
-    for (const option of data.data.options || []) {
-      interaction.options[option.name] = option.value
-    }
+      channelId:
+        data.channel_id,
 
-    command.handler(interaction)
-  }
-
-  handleComponentInteraction(data) {
-    const componentType = data.data.component_type
+      guildId:
+        data.guild_id ||
+        null,
 
-    let type = "selectMenu"
+      replied: false,
+      deferred: false,
 
-    if (componentType === 2) {
-      type = "button"
-    }
+      reply: async content => {
+        return this.replyToInteraction(
+          data,
+          content,
+          interaction
+        )
+      },
 
-    const interaction = {
-      id: data.id,
-      token: data.token,
-      type: type,
-      componentType: componentType,
-      customId: data.data.custom_id,
+      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: {}
+          }
+        )
 
-      user: data.member?.user || data.user,
+        interaction.deferred = true
 
-      member: data.member
-        ? {
-            ...data.member,
-            permissions: new Permissions(
-              data.member.permissions
-            )
-          }
-        : null,
+        return true
+      },
 
-      channelId: data.channel_id,
-      guildId: data.guild_id || null,
-      values: data.data.values || [],
+      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
+        )
+      },
 
-      reply: content => {
-        return this.replyToInteraction(data, content)
+      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
       }
     }
 
-    this.emit("interaction", interaction)
+    return interaction
   }
 
-  replyToInteraction(data, content) {
+  formatInteractionContent(content) {
     const messageData = {}
 
     if (typeof content === "string") {
-      messageData.content = content
+      messageData.content =
+        content
     } else if (
       content &&
       typeof content.toJSON === "function"
     ) {
-      messageData.embeds = [content.toJSON()]
+      messageData.embeds = [
+        content.toJSON()
+      ]
     } else if (
       content &&
       typeof content === "object"
     ) {
-      Object.assign(messageData, content)
+      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"
+      )
+
+    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
+      )
+    }
+  }
+
+  handleComponentInteraction(data) {
+    const componentType =
+      data.data.component_type
+
+    let type = "selectMenu"
+
+    if (componentType === 2) {
+      type = "button"
+    }
+
+    const interaction =
+      this.createInteraction(
+        data,
+        type
+      )
+
+    interaction.componentType =
+      componentType
+
+    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`,
@@ -201,31 +403,149 @@ class Client extends EventEmitter {
         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: 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

@@ -44,10 +44,13 @@ class Gateway {
         }
 
         if (packet.t === "READY") {
-          this.client.user = packet.d.user
-          this.client.emit("ready", packet.d)
-        }
+  this.client.user = packet.d.user
+  this.client.applicationId =
+    packet.d.application?.id ||
+    packet.d.user?.id
 
+  this.client.emit("rawReady", packet.d)
+}
         if (packet.t === "MESSAGE_CREATE") {
           this.client.emit("rawMessage", packet.d)
         }

package/index.js

@@ -2,10 +2,14 @@ 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,
   ButtonBuilder,
-  SelectMenuBuilder
-}
+  SelectMenuBuilder,
+  ActionRowBuilder,
+  DiscordAPIError: API.DiscordAPIError
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-discord-bot.js",
-  "version": "0.1.4",
+  "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