feat (command): support deferred responses and follow up messages

Author: cryptoAlgorithm

Sources/DiscordKitBot/ApplicationCommand/CommandData.swift

@@ -9,14 +9,15 @@ import Foundation
 import DiscordKitCore
 
 /// Provides methods to get parameters of and respond to application command interactions
-public struct CommandData {
+public class CommandData {
     internal init(
         optionValues: [OptionData],
-        rest: DiscordREST, token: String, interactionID: Snowflake
+        rest: DiscordREST, applicationID: String, interactionID: Snowflake, token: String
     ) {
         self.rest = rest
         self.token = token
         self.interactionID = interactionID
+        self.applicationID = applicationID
 
         self.optionValues = Self.unwrapOptionDatas(optionValues)
     }
@@ -27,9 +28,15 @@ public struct CommandData {
     /// instance gets deallocated.
     private weak var rest: DiscordREST?
 
+    /// The ID of this bot application
+    private let applicationID: String
+
     /// Values of options in this command
     private let optionValues: [String: OptionData]
 
+    /// If this reply has already been deferred
+    fileprivate var replyDeferred = false
+
     // MARK: Parameters for executing callbacks
     /// The token to use when carrying out actions with this interaction
     let token: String
@@ -82,14 +89,40 @@ public extension CommandData {
 
 // MARK: - Callback APIs
 public extension CommandData {
+    /// Wrapper function to send an interaction response with the current interaction's ID and token
+    private func sendResponse(_ response: InteractionResponse) async throws {
+        try await rest?.sendInteractionResponse(response, interactionID: interactionID, token: token)
+    }
+
     /// Reply to this interaction with a plain text response
+    ///
+    /// If a prior call to ``deferReply()`` was made, this function automatically
+    /// calls ``followUp(_:)`` instead.
     func reply(_ content: String) async throws {
-        try await rest?.sendInteractionResponse(
+        if replyDeferred {
+            _ = try await followUp(content)
+            return
+        }
+        try await sendResponse(
             .init(
                 type: .interactionReply,
                 data: .message(.init(content: content))
-            ),
-            interactionID: interactionID, token: token
+            )
         )
     }
+
+    /// Send a follow up response to this interaction
+    ///
+    /// By default, this creates a second reply to this interaction, appearing as a
+    /// reply in clients. However, if a call to ``deferReply()`` was made, this
+    /// edits the loading message with the content provided.
+    func followUp(_ content: String) async throws -> Message {
+        try await rest!.sendInteractionFollowUp(.init(content: content), applicationID: applicationID, token: token)
+    }
+
+    /// Defer the reply to this interaction - the user sees a loading state
+    func deferReply() async throws {
+        try await sendResponse(.init(type: .deferredInteractionReply, data: nil))
+        replyDeferred = true
+    }
 }

Sources/DiscordKitBot/Client.swift

@@ -114,7 +114,7 @@ extension Client {
             Task {
                 await handler(.init(
                     optionValues: commandData.options ?? [],
-                    rest: rest, token: token, interactionID: id
+                    rest: rest, applicationID: applicationID!, interactionID: id, token: token
                 ))
             }
         }

Sources/DiscordKitBot/REST/APICommand.swift

@@ -80,4 +80,11 @@ public extension DiscordREST {
     func sendInteractionResponse(_ response: InteractionResponse, interactionID: Snowflake, token: String) async throws {
         try await postReq(path: "interactions/\(interactionID)/\(token)/callback", body: response)
     }
+
+    /// Send a follow up response to an interaction
+    ///
+    /// > POST: `/webhooks/{application.id}/{interaction.token}`
+    func sendInteractionFollowUp(_ message: NewMessage, applicationID: Snowflake, token: String) async throws -> Message {
+        try await postReq(path: "webhooks/\(applicationID)/\(token)", body: message)
+    }
 }

Sources/DiscordKitCore/Objects/Data/Interaction.swift

@@ -196,7 +196,7 @@ public struct MessageInteraction: Codable {
 
 // MARK: - Interaction Response
 public struct InteractionResponse: Encodable {
-    public init(type: InteractionResponse.ResponseType, data: InteractionResponse.ResponseData) {
+    public init(type: InteractionResponse.ResponseType, data: InteractionResponse.ResponseData?) {
         self.type = type
         self.data = data
     }
@@ -246,5 +246,5 @@ public struct InteractionResponse: Encodable {
     }
 
     public let type: ResponseType
-    public let data: ResponseData
+    public let data: ResponseData?
 }