Fix critical bugs from code review

- Fix rate limit handling by checking 429 before isSuccess
- Fix InputBlock dispatch_action coding key (was dispatch_action_config)
- Fix InputBlock element decoding using superDecoder
- Fix DatePickerElement initialDate to String (YYYY-MM-DD format)
- Fix TextContextElement to support configurable type field
- Remove unused decoder from URLSessionNetworkClient
- Add formatDate helper to DatePickerElement for proper date formatting
- Add markdown static helper to TextContextElement

Author: diegotl

Sources/SlackKit/Client/SlackWebhookClient.swift

@@ -86,19 +86,18 @@ public final actor SlackWebhookClient {
         // Send the request
         let response = try await networkClient.post(url: webhookURL, body: body)
 
+        // Check for rate limiting (must check before isSuccess)
+        if response.statusCode == 429 {
+            let retryAfter = extractRetryAfter(from: response) ?? 60
+            throw SlackError.rateLimitExceeded(retryAfter: retryAfter)
+        }
+
         // Check for HTTP errors
         guard response.isSuccess else {
             let bodyString = String(data: response.data, encoding: .utf8)
             throw SlackError.invalidResponse(statusCode: response.statusCode, body: bodyString)
         }
 
-        // Check for rate limiting
-        if response.statusCode == 429 {
-            if let retryAfter = extractRetryAfter(from: response) {
-                throw SlackError.rateLimitExceeded(retryAfter: retryAfter)
-            }
-        }
-
         // Decode the response
         // Slack webhooks return "ok" as plain text on success
         if let bodyString = String(data: response.data, encoding: .utf8),

Sources/SlackKit/Client/URLSessionNetworkClient.swift

@@ -8,18 +8,11 @@ import Foundation
 /// A URLSession-based implementation of NetworkClient
 public actor URLSessionNetworkClient: NetworkClient {
     private let session: URLSession
-    private let decoder: JSONDecoder
 
     /// Initializes a new URLSession network client
-    /// - Parameters:
-    ///   - session: The URLSession to use for requests (defaults to shared)
-    ///   - decoder: The JSONDecoder to use for decoding responses (defaults to standard)
-    public init(
-        session: URLSession = .shared,
-        decoder: JSONDecoder = JSONDecoder()
-    ) {
+    /// - Parameter session: The URLSession to use for requests (defaults to shared)
+    public init(session: URLSession = .shared) {
         self.session = session
-        self.decoder = decoder
     }
 
     public func post(url: URL, body: Data) async throws -> HTTPResponse {

Sources/SlackKit/Models/Blocks/ContextBlock.swift

@@ -71,11 +71,19 @@ public protocol ContextElement: BlockElement {}
 
 /// A text element for context blocks
 public struct TextContextElement: ContextElement {
-    public let type: String = "plain_text"
+    public let type: String  // Can be "plain_text" or "mrkdwn"
     public var text: String
 
-    public init(text: String) {
+    public init(text: String, type: String = "plain_text") {
         self.text = text
+        self.type = type
+    }
+
+    /// Creates a markdown text context element
+    /// - Parameter markdown: The markdown text
+    /// - Returns: A TextContextElement with markdown type
+    public static func markdown(_ markdown: String) -> TextContextElement {
+        TextContextElement(text: markdown, type: "mrkdwn")
     }
 
     enum CodingKeys: String, CodingKey {

Sources/SlackKit/Models/Blocks/InputBlock.swift

@@ -54,7 +54,7 @@ public struct InputBlock: Block {
         case blockID = "block_id"
         case label
         case element
-        case dispatchAction = "dispatch_action_config"
+        case dispatchAction = "dispatch_action"
         case hint
         case optional
     }
@@ -73,21 +73,23 @@ public struct InputBlock: Block {
         // Decode element polymorphically
         if let elementContainer = try? container.nestedContainer(keyedBy: CodingKeys.self, forKey: .element) {
             let elementType = try elementContainer.decode(String.self, forKey: .type)
+            let elementDecoder = try container.superDecoder(forKey: .element)
+
             switch elementType {
             case "plain_text_input":
-                element = try PlainTextInputElement(from: decoder)
+                element = try PlainTextInputElement(from: elementDecoder)
             case "static_select":
-                element = try StaticSelectElement(from: decoder)
+                element = try StaticSelectElement(from: elementDecoder)
             case "datepicker":
-                element = try DatePickerElement(from: decoder)
+                element = try DatePickerElement(from: elementDecoder)
             case "multi_static_select":
-                element = try MultiStaticSelectElement(from: decoder)
+                element = try MultiStaticSelectElement(from: elementDecoder)
             case "multi_users_select":
-                element = try MultiUsersSelectElement(from: decoder)
+                element = try MultiUsersSelectElement(from: elementDecoder)
             case "multi_conversations_select":
-                element = try MultiConversationsSelectElement(from: decoder)
+                element = try MultiConversationsSelectElement(from: elementDecoder)
             case "multi_channels_select":
-                element = try MultiChannelsSelectElement(from: decoder)
+                element = try MultiChannelsSelectElement(from: elementDecoder)
             default:
                 throw DecodingError.dataCorruptedError(
                     forKey: .element,

Sources/SlackKit/Models/Elements/DatePickerElement.swift

@@ -7,19 +7,19 @@ public struct DatePickerElement: BlockElement {
     public let type: String = "datepicker"
     public var actionID: String?
     public var placeholder: TextObject
-    public var initialDate: Int?
+    public var initialDate: String?
     public var confirm: ConfirmationDialog?
 
     /// Initializes a new date picker element
     /// - Parameters:
     ///   - actionID: An identifier for the action
     ///   - placeholder: The placeholder text
-    ///   - initialDate: The initial date as a Unix timestamp
+    ///   - initialDate: The initial date in YYYY-MM-DD format
     ///   - confirm: An optional confirmation dialog
     public init(
         actionID: String? = nil,
         placeholder: TextObject,
-        initialDate: Int? = nil,
+        initialDate: String? = nil,
         confirm: ConfirmationDialog? = nil
     ) {
         self.actionID = actionID
@@ -28,6 +28,18 @@ public struct DatePickerElement: BlockElement {
         self.confirm = confirm
     }
 
+    /// Creates a date string in YYYY-MM-DD format from a Date
+    /// - Parameter date: The date to format
+    /// - Returns: A string in YYYY-MM-DD format
+    public static func formatDate(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.calendar = Calendar(identifier: .iso8601)
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        return formatter.string(from: date)
+    }
+
     enum CodingKeys: String, CodingKey {
         case type
         case actionID = "action_id"

Tests/SlackKitTests/ClientTests/SlackWebhookClientTests.swift

@@ -115,6 +115,32 @@ struct SlackWebhookClientTests {
         }
     }
 
+    @Test("Handle rate limit response")
+    func handleRateLimitResponse() async throws {
+        // Arrange
+        let webhookURL = URL(string: "https://hooks.slack.com/services/T/B/C")!
+        let mockClient = MockNetworkClient()
+        let slackClient = SlackWebhookClient(webhookURL: webhookURL, networkClient: mockClient)
+
+        // Mock a 429 response without body hints
+        let responseData = #"{"error": "rate_limited"}"#.data(using: .utf8)!
+        await mockClient.addResponse(statusCode: 429, data: responseData)
+
+        // Act & Assert
+        let message = Message(text: "Test")
+        do {
+            _ = try await slackClient.send(message)
+            #expect(false, "Expected rate limit error")
+        } catch let error as SlackError {
+            switch error {
+            case .rateLimitExceeded(let retryAfter):
+                #expect(retryAfter == 60)
+            default:
+                #expect(false, "Unexpected error: \(error)")
+            }
+        }
+    }
+
     @Test("Send message with attachments")
     func sendMessageWithAttachments() async throws {
         // Arrange

Tests/SlackKitTests/IntegrationTests/SlackKitIntegrationTests.swift

@@ -546,7 +546,7 @@ struct SlackKitIntegrationTests {
                     text: .plainText("Select a date:"),
                     accessory: DatePickerElement(
                         placeholder: .plainText("Pick a date"),
-                        initialDate: Int(Date().timeIntervalSince1970)
+                        initialDate: DatePickerElement.formatDate(Date())
                     )
                 )
             ]

Tests/SlackKitTests/ModelTests/BlockTests.swift

@@ -200,6 +200,18 @@ struct BlockTests {
         #expect(json.contains("\"value\":\"opt1\""))
     }
 
+    @Test("Format DatePicker initial date")
+    func formatDatePickerInitialDate() throws {
+        // Arrange
+        let epoch = Date(timeIntervalSince1970: 0)
+
+        // Act
+        let formatted = DatePickerElement.formatDate(epoch)
+
+        // Assert
+        #expect(formatted == "1970-01-01")
+    }
+
     @Test("Encode Attachment with fields")
     func encodeAttachmentWithFields() throws {
         // Arrange