grape-slack-bot 1.8.2 → 2.0.1

data/lib/slack_bot/api_client.rb

@@ -16,116 +16,217 @@ module SlackBot
       data["error"]
     end
 
+    def rate_limited?
+      response.status == 429 || (data["ok"] == false && data["error"] == "rate_limited")
+    end
+
+    def retry_after
+      response.headers["Retry-After"]&.to_i || 60
+    end
+
+    def slack_error?
+      !ok? && error.present?
+    end
+
+    def authentication_error?
+      slack_error? && %w[invalid_auth account_inactive].include?(error)
+    end
+
     def data
       JSON.parse(response.body)
+    rescue JSON::ParserError => e
+      SlackBot::Logger.error("Failed to parse Slack API response: #{e.message}")
+      {"ok" => false, "error" => "invalid_json_response"}
     end
   end
 
   class ApiClient
+    # Slack API base URL
+    SLACK_API_BASE_URL = "https://slack.com/api/"
+    # Request timeout in seconds
+    REQUEST_TIMEOUT = 30
+    # Connection timeout in seconds
+    CONNECTION_TIMEOUT = 10
+    TOKEN_FORMAT = /\Axox[bpa]-/
+
     attr_reader :client
-    def initialize(authorization_token: ENV["SLACK_BOT_API_TOKEN"])
-      authorization_token_available = !authorization_token.nil? && authorization_token.is_a?(String) && !authorization_token.empty?
-      raise "Slack bot API token is not set" if !authorization_token_available
 
-      @client =
-        Faraday.new do |conn|
-          conn.request :url_encoded
-          conn.adapter Faraday.default_adapter
-          conn.url_prefix = "https://slack.com/api/"
-          conn.headers["Content-Type"] = "application/json; charset=utf-8"
-          conn.headers["Authorization"] = "Bearer #{authorization_token}"
-        end
+    def initialize(authorization_token: ENV["SLACK_BOT_API_TOKEN"])
+      validate_authorization_token!(authorization_token)
+      @client = build_client(authorization_token)
     end
 
     def views_open(trigger_id:, view:)
-      ApiResponse.new { client.post("views.open", {trigger_id: trigger_id, view: view}.to_json) }
+      ApiResponse.new do
+        client.post("views.open", {trigger_id: trigger_id, view: view}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def views_update(view_id:, view:)
-      ApiResponse.new { client.post("views.update", {view_id: view_id, view: view}.to_json) }
+      ApiResponse.new do
+        client.post("views.update", {view_id: view_id, view: view}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_post_message(channel:, text:, blocks:)
-      ApiResponse.new { client.post("chat.postMessage", {channel: channel, text: text, blocks: blocks}.to_json) }
+      ApiResponse.new do
+        client.post("chat.postMessage", {channel: channel, text: text, blocks: blocks}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_update(channel:, ts:, text:, blocks:)
-      ApiResponse.new { client.post("chat.update", {channel: channel, ts: ts, text: text, blocks: blocks}.to_json) }
+      ApiResponse.new do
+        client.post("chat.update", {channel: channel, ts: ts, text: text, blocks: blocks}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_delete(channel:, ts:)
-      ApiResponse.new { client.post("chat.delete", {channel: channel, ts: ts}.to_json) }
+      ApiResponse.new do
+        client.post("chat.delete", {channel: channel, ts: ts}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_unfurl(channel:, ts:, unfurls:, source: nil, unfurl_id: nil, user_auth_blocks: nil, user_auth_message: nil, user_auth_required: nil, user_auth_url: nil)
-      ApiResponse.new { client.post("chat.unfurl", {
-        channel: channel,
-        ts: ts,
-        unfurls: unfurls,
-        source: source,
-        unfurl_id: unfurl_id,
-        user_auth_blocks: user_auth_blocks,
-        user_auth_message: user_auth_message,
-        user_auth_required: user_auth_required,
-        user_auth_url: user_auth_url
-      }.to_json) }
+      ApiResponse.new do
+        client.post("chat.unfurl", {
+          channel: channel,
+          ts: ts,
+          unfurls: unfurls,
+          source: source,
+          unfurl_id: unfurl_id,
+          user_auth_blocks: user_auth_blocks,
+          user_auth_message: user_auth_message,
+          user_auth_required: user_auth_required,
+          user_auth_url: user_auth_url
+        }.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_schedule_message(channel:, text:, post_at:, blocks: nil)
-      ApiResponse.new { client.post("chat.scheduleMessage", {channel: channel, text: text, post_at: post_at, blocks: blocks}.to_json) }
+      ApiResponse.new do
+        client.post("chat.scheduleMessage", {channel: channel, text: text, post_at: post_at, blocks: blocks}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def scheduled_messages_list(channel: nil, cursor: nil, latest: nil, limit: nil, oldest: nil, team_id: nil)
-      ApiResponse.new { client.post("scheduled_messages.list", {
-        channel: channel,
-        cursor: cursor,
-        latest: latest,
-        limit: limit,
-        oldest: oldest,
-        team_id: team_id
-      }.to_json) }
+      ApiResponse.new do
+        client.post("scheduled_messages.list", {
+          channel: channel,
+          cursor: cursor,
+          latest: latest,
+          limit: limit,
+          oldest: oldest,
+          team_id: team_id
+        }.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_delete_scheduled_message(channel:, scheduled_message_id:)
-      ApiResponse.new { client.post("chat.deleteScheduledMessage", {channel: channel, scheduled_message_id: scheduled_message_id}.to_json) }
+      ApiResponse.new do
+        client.post("chat.deleteScheduledMessage", {channel: channel, scheduled_message_id: scheduled_message_id}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_get_permalink(channel:, message_ts:)
-      ApiResponse.new { client.post("chat.getPermalink", {channel: channel, message_ts: message_ts}.to_json) }
+      ApiResponse.new do
+        client.post("chat.getPermalink", {channel: channel, message_ts: message_ts}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def users_info(user_id:)
-      ApiResponse.new { client.post("users.info", {user: user_id}.to_json) }
+      ApiResponse.new do
+        client.post("users.info", {user: user_id}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def views_publish(user_id:, view:)
-      ApiResponse.new { client.post("views.publish", {user_id: user_id, view: view}.to_json) }
+      ApiResponse.new do
+        client.post("views.publish", {user_id: user_id, view: view}.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def users_list(cursor: nil, limit: 200, include_locale: nil, team_id: nil)
-      args = {}
-      args[:cursor] = cursor if cursor
-      args[:limit] = limit if limit
-      args[:include_locale] = include_locale if include_locale
-      args[:team_id] = team_id if team_id
-      ApiResponse.new { client.post("users.list", args.to_json) }
+      args = compact_payload(cursor: cursor, limit: limit, include_locale: include_locale, team_id: team_id)
+      ApiResponse.new do
+        client.post("users.list", args.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
     end
 
     def chat_post_ephemeral(channel:, user:, text:, as_user: nil, attachments: nil, blocks: nil, icon_emoji: nil, icon_url: nil, link_names: nil, parse: nil, thread_ts: nil, username: nil)
-      args = {}
-      args[:channel] = channel
-      args[:user] = user
-      args[:text] = text if text
-      args[:as_user] = as_user if as_user
-      args[:attachments] = attachments if attachments
-      args[:blocks] = blocks if blocks
-      args[:icon_emoji] = icon_emoji if icon_emoji
-      args[:icon_url] = icon_url if icon_url
-      args[:link_names] = link_names if link_names
-      args[:parse] = parse if parse
-      args[:thread_ts] = thread_ts if thread_ts
-      args[:username] = username if username
-      ApiResponse.new { client.post("chat.postEphemeral", args.to_json) }
+      args = compact_payload(
+        channel: channel,
+        user: user,
+        text: text,
+        as_user: as_user,
+        attachments: attachments,
+        blocks: blocks,
+        icon_emoji: icon_emoji,
+        icon_url: icon_url,
+        link_names: link_names,
+        parse: parse,
+        thread_ts: thread_ts,
+        username: username
+      )
+      ApiResponse.new do
+        client.post("chat.postEphemeral", args.to_json)
+      rescue Faraday::Error => e
+        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
+      end
+    end
+
+    private
+
+    def validate_authorization_token!(authorization_token)
+      raise SlackBot::Errors::SlackApiError.new("Slack bot API token is not set") unless valid_authorization_token?(authorization_token)
+      return if authorization_token.start_with?("test_") || authorization_token.match?(TOKEN_FORMAT)
+
+      raise SlackBot::Errors::SlackApiError.new("Invalid Slack API token format")
+    end
+
+    def valid_authorization_token?(authorization_token)
+      authorization_token.is_a?(String) && !authorization_token.empty?
+    end
+
+    def build_client(authorization_token)
+      Faraday.new do |conn|
+        conn.request :url_encoded
+        conn.adapter Faraday.default_adapter
+        conn.url_prefix = SLACK_API_BASE_URL
+        conn.headers["Content-Type"] = "application/json; charset=utf-8"
+        conn.headers["Authorization"] = "Bearer #{authorization_token}"
+        conn.options.timeout = REQUEST_TIMEOUT
+        conn.options.open_timeout = CONNECTION_TIMEOUT
+      end
+    end
+
+    def compact_payload(**payload)
+      payload.compact
     end
   end
 end

data/lib/slack_bot/args.rb

@@ -44,6 +44,8 @@ module SlackBot
       self.args = @parser.new(raw_args).call&.with_indifferent_access || {}
     end
 
+    attr_reader :raw_args
+
     def to_s
       @builder.new(args).call
     end

data/lib/slack_bot/callback.rb

@@ -37,7 +37,8 @@ module SlackBot
       create(id: id, class_name: class_name, user: user, channel_id: channel_id, payload: payload, config: config, expires_in: expires_in, user_scope: user_scope)
     end
 
-    attr_reader :id, :data, :args, :config, :expires_in, :user_scope
+    attr_reader :data, :args, :config, :expires_in, :user_scope
+    attr_accessor :id
     def initialize(id: nil, class_name: nil, user: nil, channel_id: nil, payload: nil, config: nil, expires_in: nil, user_scope: nil, view_id: nil)
       @id = id
       @data = {
@@ -50,7 +51,7 @@ module SlackBot
       @args = SlackBot::Args.new
       @config = config || SlackBot::Config.current_instance
       @expires_in = expires_in || CALLBACK_RECORD_EXPIRES_IN
-      @user_scope = user_scope.nil? ? true : user_scope
+      @user_scope = user_scope.nil? || user_scope
     end
 
     def reload
@@ -102,18 +103,34 @@ module SlackBot
       @data[:user_id] = user&.id
     end
 
+    def class_name
+      data[:class_name]
+    end
+
     def class_name=(class_name)
       @data[:class_name] = class_name
     end
 
+    def channel_id
+      data[:channel_id]
+    end
+
     def channel_id=(channel_id)
       @data[:channel_id] = channel_id
     end
 
+    def payload
+      data[:payload]
+    end
+
     def payload=(payload)
       @data[:payload] = payload
     end
 
+    def view_id
+      data[:view_id]
+    end
+
     def view_id=(view_id)
       @data[:view_id] = view_id
     end
@@ -138,6 +155,10 @@ module SlackBot
       super
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      data.key?(method_name.to_sym) || (data[:payload].is_a?(Hash) && data[:payload].key?(method_name.to_s)) || super
+    end
+
     def read_view_callback_id
       return if view_id.blank?
 
@@ -159,13 +180,17 @@ module SlackBot
     end
 
     def storage_key
-      raise "User is required for scoped callback" if user.blank?
+      if user.blank?
+        raise SlackBot::Errors::SlackApiError.new("User is required for scoped callback")
+      end
 
       "#{CALLBACK_KEY_PREFIX}:u#{user.id}:#{id}"
     end
 
     def view_storage_key
-      raise "User is required for scoped callback" if user.blank?
+      if user.blank?
+        raise SlackBot::Errors::SlackApiError.new("User is required for scoped callback")
+      end
 
       "#{CALLBACK_KEY_PREFIX}:u#{user.id}:#{view_id}"
     end

data/lib/slack_bot/callback_storage.rb

@@ -1,15 +1,15 @@
 module SlackBot
   class CallbackStorage
     def read(*_args, **_kwargs)
-      raise "Not implemented"
+      raise SlackBot::Errors::NotImplementedError.new("CallbackStorage#read must be implemented by subclass")
     end
 
     def write(*_args, **_kwargs)
-      raise "Not implemented"
+      raise SlackBot::Errors::NotImplementedError.new("CallbackStorage#write must be implemented by subclass")
     end
 
     def delete(*_args, **_kwargs)
-      raise "Not implemented"
+      raise SlackBot::Errors::NotImplementedError.new("CallbackStorage#delete must be implemented by subclass")
     end
   end
 end

data/lib/slack_bot/config.rb

@@ -80,11 +80,15 @@ module SlackBot
 
     def handler_class(class_name, klass)
       @handler_classes ||= {}
+      return if class_name.nil?
+
       @handler_classes[class_name.to_sym] = klass
     end
 
     def find_handler_class(class_name)
       @handler_classes ||= {}
+      return if class_name.nil?
+
       @handler_classes.fetch(class_name.to_sym)
     rescue KeyError
       raise SlackBot::Errors::HandlerClassNotFound.new(class_name, handler_classes: @handler_classes)

data/lib/slack_bot/errors.rb

@@ -62,5 +62,25 @@ module SlackBot
 
     class PublishViewError < SlackResponseError
     end
+
+    class CallbackUserMismatchError < SlackBot::Error
+    end
+
+    class InvalidPayloadError < SlackBot::Error
+    end
+
+    class SlackApiError < SlackBot::Error
+    end
+
+    class UnknownActionTypeError < SlackBot::Error
+      attr_reader :action_type
+      def initialize(action_type)
+        @action_type = action_type
+        super("Unknown action type: #{action_type}")
+      end
+    end
+
+    class NotImplementedError < SlackBot::Error
+    end
   end
 end