grape-slack-bot 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d79cd991f4efaa9ae3319b25d73e0addde71aa04d59369236225f1bb97e0b4e
-  data.tar.gz: 402ede62474860b3009c44107f7e54fba9de531c992315eba021bc84a3a2c21e
+  metadata.gz: 9361a3a86619e251da1df7649973cdd911619f2b55f18d5d622f8a1e6d5ee707
+  data.tar.gz: ebd8c29c0f6957bbaa0cf1fefbce369f7072b60d4b01cbae4037fa7a5fe3212b
 SHA512:
-  metadata.gz: c1bf71eedfc65e15481d6f06ed038bfd637f1ef0784c8040a482386f20087c98c53c435bd43f3b62eed9ac82482c36a35c70f87920e40372eefca45d2f783243
-  data.tar.gz: daaded041bc84bac15c0c20bc04709df914ab895b222244d05d1aef9f568e7b63ed1ce6475a0a027a8601bcf597a91cb1a97ef1a7e840456f49c3e5104e4549c
+  metadata.gz: 9f4bf3f86997214af675d7a21c40c4270fbb3e8c93093dbdacabf08da89a4ed054221e27345702e4e48da4c945ec12ef4291c7c46a412ee7a02d82fadd6e1db5
+  data.tar.gz: a2c0ea8a963da6d8aff07dca5bdb90c517e1ae44a64b34b5f1e70903279b33239f6182b1bd8ddef22de17d45c7eb0dda86f101d3ed0cfd4461ea080357e11db2

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 2.1.0 (2026-07-10)
+
+- Add `block_action` registration for message-level block action buttons outside modal callbacks
+- Add `user_session_resolver` and `event_dispatcher` configuration hooks for session lookup and background event dispatch
+- Acknowledge Slack event retries with an empty 200 response so duplicate deliveries do not run handlers twice
+- Skip `bot_message` event payloads at ingress to avoid handler loops from bot echoes
+- Retry Slack API requests once when rate limited, sleeping at most 3 seconds before the retry
+- Fix `scheduled_messages_list` to send the `channel` argument to the Slack API
+- Fix team verification when `SLACK_TEAM_ID` is unset so requests are rejected instead of matching any team
+- Raise `SlackBot::Errors::ConfigurationError` when required configuration is missing
+- Raise `SlackBot::Errors::BlockActionNotImplemented` when an unregistered block action is submitted
+- Require `faraday` `>= 2.14.3`
+
 ## 2.0.1 (2026-05-31)
 
 - Allow `grape` 3.x by expanding the runtime dependency to `< 4.0`

data/README.md

@@ -55,10 +55,18 @@ SlackBot::DevConsole.enabled = Rails.env.development?
 SlackBot::Config.configure do
   callback_storage Rails.cache
   callback_user_finder ->(id) { User.active.find_by(id: id) }
+  user_session_resolver ->(team_id, user_id) do
+    uid = OmniAuth::Strategies::SlackOpenid.generate_uid(team_id, user_id)
+    UserSession.find_by(uid: uid, provider: UserSession.slack_openid_provider)
+  end
+  event_dispatcher ->(handler:, params:, current_user:) do
+    SlackEventJob.perform_later(handler.name, params.deep_stringify_keys, current_user&.id)
+  end
 
   # Register event handlers
   event :app_home_opened, MySlackBot::AppHomeOpenedEvent
   interaction MySlackBot::AppHomeInteraction
+  block_action :approve_request, MySlackBot::ApproveRequestInteraction
 
   # Register slash command handlers
   slash_command_endpoint :game, MySlackBot::Game::MenuCommand do
@@ -74,11 +82,6 @@ class SlackBotApi < Grape::API
       SlackBot::Config.current_instance
     end
 
-    def resolve_user_session(team_id, user_id)
-      uid = OmniAuth::Strategies::SlackOpenid.generate_uid(team_id, user_id)
-      UserSession.find_by(uid: uid, provider: UserSession.slack_openid_provider)
-    end
-
     def current_user_session
       # NOTE: fetch_team_id and fetch_user_id are provided by SlackBot::GrapeHelpers
       @current_user_session ||=

data/grape-slack-bot.gemspec

@@ -23,19 +23,18 @@ Gem::Specification.new do |gem|
     "rubygems_mfa_required" => "true"
   }
 
-  gem.executables = Dir.glob("bin/*").map { |f| File.basename(f) }
-  gem.files = Dir.glob("lib/**/*.rb") + Dir.glob("bin/**/*") + Dir.glob("sig/**/*.rbs") + root_files
+  gem.files = Dir.glob("lib/**/*.rb") + Dir.glob("sig/**/*.rbs") + root_files
 
   gem.required_ruby_version = ">= 3"
   gem.require_paths = ["lib"]
 
   gem.add_runtime_dependency "rack", "~> 3.0"
   gem.add_runtime_dependency "grape", ">= 1.6", "< 4.0"
-  gem.add_runtime_dependency "faraday", "~> 2.0"
+  gem.add_runtime_dependency "faraday", ">= 2.14.3", "< 3.0"
   gem.add_runtime_dependency "activesupport", ">= 6.1", "< 9.0"
 
   gem.add_development_dependency "rspec", "~> 3"
-  gem.add_development_dependency "polyrun", "~> 1.4.2"
+  gem.add_development_dependency "polyrun", "~> 1.5.0"
   gem.add_development_dependency "webmock", "~> 3"
   gem.add_development_dependency "rake", "~> 13"
   gem.add_development_dependency "standard", "~> 1.52"
@@ -45,6 +44,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rubocop-rspec", "~> 3.8"
   gem.add_development_dependency "rubocop-thread_safety", "~> 0.7"
   gem.add_development_dependency "appraisal", "~> 2"
+  gem.add_development_dependency "bundler-audit", "~> 0.9"
   gem.add_development_dependency "memory_profiler", "~> 1"
   gem.add_development_dependency "rbs", "~> 3"
   gem.add_development_dependency "rack-test", "~> 2"

data/lib/slack_bot/api_client.rb

@@ -2,7 +2,23 @@ require "faraday"
 
 module SlackBot
   class ApiResponse
+    # Cap in-request sleep so rate-limit retries do not hold web workers for Slack's default Retry-After.
+    RATE_LIMIT_RETRY_SLEEP_SECONDS = 3
+
     attr_reader :response
+
+    def self.from_request(&block)
+      response = new(&block)
+      return response unless response.rate_limited?
+
+      Kernel.sleep(rate_limit_retry_sleep_seconds(response.retry_after))
+      new(&block)
+    end
+
+    def self.rate_limit_retry_sleep_seconds(retry_after)
+      [retry_after.to_i, RATE_LIMIT_RETRY_SLEEP_SECONDS].min
+    end
+
     def initialize(&block)
       @response = block.call
       SlackBot::DevConsole.log_output "#{self.class.name}: #{response.body}"
@@ -57,47 +73,27 @@ module SlackBot
     end
 
     def views_open(trigger_id:, view:)
-      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
+      perform_request { client.post("views.open", {trigger_id: trigger_id, view: view}.to_json) }
     end
 
     def views_update(view_id:, view:)
-      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
+      perform_request { client.post("views.update", {view_id: view_id, view: view}.to_json) }
     end
 
     def chat_post_message(channel:, text:, blocks:)
-      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
+      perform_request { client.post("chat.postMessage", {channel: channel, text: text, blocks: blocks}.to_json) }
     end
 
     def chat_update(channel:, ts:, text:, blocks:)
-      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
+      perform_request { client.post("chat.update", {channel: channel, ts: ts, text: text, blocks: blocks}.to_json) }
     end
 
     def chat_delete(channel:, ts:)
-      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
+      perform_request { client.post("chat.delete", {channel: channel, ts: ts}.to_json) }
     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 do
+      perform_request do
         client.post("chat.unfurl", {
           channel: channel,
           ts: ts,
@@ -109,73 +105,37 @@ module SlackBot
           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 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
+      perform_request { client.post("chat.scheduleMessage", {channel: channel, text: text, post_at: post_at, blocks: blocks}.to_json) }
     end
 
     def scheduled_messages_list(channel: nil, cursor: nil, latest: nil, limit: nil, oldest: nil, team_id: nil)
-      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
+      args = compact_payload(channel: channel, cursor: cursor, limit: limit, latest: latest, oldest: oldest, team_id: team_id)
+      perform_request { client.post("scheduled_messages.list", args.to_json) }
     end
 
     def chat_delete_scheduled_message(channel:, scheduled_message_id:)
-      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
+      perform_request { client.post("chat.deleteScheduledMessage", {channel: channel, scheduled_message_id: scheduled_message_id}.to_json) }
     end
 
     def chat_get_permalink(channel:, message_ts:)
-      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
+      perform_request { client.post("chat.getPermalink", {channel: channel, message_ts: message_ts}.to_json) }
     end
 
     def users_info(user_id:)
-      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
+      perform_request { client.post("users.info", {user: user_id}.to_json) }
     end
 
     def views_publish(user_id:, view:)
-      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
+      perform_request { client.post("views.publish", {user_id: user_id, view: view}.to_json) }
     end
 
     def users_list(cursor: nil, limit: 200, include_locale: nil, team_id: nil)
       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
+      perform_request { client.post("users.list", args.to_json) }
     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)
@@ -193,15 +153,19 @@ module SlackBot
         thread_ts: thread_ts,
         username: username
       )
-      ApiResponse.new do
-        client.post("chat.postEphemeral", args.to_json)
+      perform_request { client.post("chat.postEphemeral", args.to_json) }
+    end
+
+    private
+
+    def perform_request(&block)
+      ApiResponse.from_request do
+        block.call
       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)

data/lib/slack_bot/callback.rb

@@ -94,7 +94,7 @@ module SlackBot
     def user
       @user ||= begin
         user_id = data&.dig(:user_id)
-        config.callback_user_finder_method.call(user_id) if user_id.present?
+        config.callback_user_finder!.call(user_id) if user_id.present?
       end
     end
 
@@ -137,7 +137,7 @@ module SlackBot
 
     def handler_class=(handler_class)
       new_class_name = handler_class&.name
-      config.find_handler_class(class_name)
+      config.find_handler_class(new_class_name)
 
       self.class_name = new_class_name
     end
@@ -162,7 +162,7 @@ module SlackBot
     def read_view_callback_id
       return if view_id.blank?
 
-      config.callback_storage_instance.read(view_storage_key)
+      config.callback_storage!.read(view_storage_key)
     end
 
     private
@@ -196,18 +196,18 @@ module SlackBot
     end
 
     def read_data
-      config.callback_storage_instance.read(storage_key)
+      config.callback_storage!.read(storage_key)
     end
 
     def write_data(data, expires_in: nil)
       expires_in ||= CALLBACK_RECORD_EXPIRES_IN
-      config.callback_storage_instance.write(view_storage_key, id, expires_in: expires_in) if view_id.present?
-      config.callback_storage_instance.write(storage_key, data, expires_in: expires_in)
+      config.callback_storage!.write(view_storage_key, id, expires_in: expires_in) if view_id.present?
+      config.callback_storage!.write(storage_key, data, expires_in: expires_in)
     end
 
     def delete_data
-      config.callback_storage_instance.delete(view_storage_key) if view_id.present?
-      config.callback_storage_instance.delete(storage_key)
+      config.callback_storage!.delete(view_storage_key) if view_id.present?
+      config.callback_storage!.delete(storage_key)
     end
   end
 end

data/lib/slack_bot/config.rb

@@ -17,11 +17,45 @@ module SlackBot
       @callback_storage_instance = klass
     end
 
+    def callback_storage!
+      return @callback_storage_instance if @callback_storage_instance
+
+      raise SlackBot::Errors::ConfigurationError.new(
+        "callback_storage is not configured; call SlackBot::Config.configure { |config| config.callback_storage ... }"
+      )
+    end
+
     attr_reader :callback_user_finder_method
     def callback_user_finder(method_lambda)
       @callback_user_finder_method = method_lambda
     end
 
+    def callback_user_finder!
+      return @callback_user_finder_method if @callback_user_finder_method
+
+      raise SlackBot::Errors::ConfigurationError.new(
+        "callback_user_finder is not configured; call SlackBot::Config.configure { |config| config.callback_user_finder ... }"
+      )
+    end
+
+    attr_reader :user_session_resolver_method
+    def user_session_resolver(method_lambda)
+      @user_session_resolver_method = method_lambda
+    end
+
+    def user_session_resolver!
+      return @user_session_resolver_method if @user_session_resolver_method
+
+      raise SlackBot::Errors::ConfigurationError.new(
+        "user_session_resolver is not configured; call SlackBot::Config.configure { |config| config.user_session_resolver ... }"
+      )
+    end
+
+    attr_reader :event_dispatcher_method
+    def event_dispatcher(method_lambda)
+      @event_dispatcher_method = method_lambda
+    end
+
     def interaction(interaction_klass, handler_name: nil)
       handler_name ||= interaction_klass.name
       handler_class(handler_name, interaction_klass)
@@ -78,6 +112,17 @@ module SlackBot
       @menu_options[action_id.to_sym]
     end
 
+    def block_action(action_id, interaction_klass, handler_name: nil)
+      @block_actions ||= {}
+      @block_actions[action_id.to_sym] = interaction_klass
+      interaction(interaction_klass, handler_name: handler_name)
+    end
+
+    def find_block_action(action_id)
+      @block_actions ||= {}
+      @block_actions[action_id.to_sym]
+    end
+
     def handler_class(class_name, klass)
       @handler_classes ||= {}
       return if class_name.nil?
@@ -130,7 +175,10 @@ module SlackBot
     end
 
     def find_command_config(text)
-      route_key = text.scan(/^(#{routes.keys.join("|")})(?:\s|$)/).flatten.first
+      return if routes.blank?
+
+      route_pattern = routes.keys.map { |route_key| Regexp.escape(route_key) }.join("|")
+      route_key = text.scan(/^(#{route_pattern})(?:\s|$)/).flatten.first
       return if route_key.blank?
 
       routes[route_key]

data/lib/slack_bot/errors.rb

@@ -18,6 +18,12 @@ module SlackBot
     class MenuOptionsNotImplemented < SlackBot::Error
     end
 
+    class BlockActionNotImplemented < SlackBot::Error
+      def initialize
+        super("Block action is not implemented")
+      end
+    end
+
     class CallbackNotFound < SlackBot::Error
     end
 
@@ -82,5 +88,8 @@ module SlackBot
 
     class NotImplementedError < SlackBot::Error
     end
+
+    class ConfigurationError < SlackBot::Error
+    end
   end
 end

data/lib/slack_bot/grape_extension.rb

@@ -2,8 +2,14 @@ require "active_support"
 require "active_support/core_ext/object"
 require "active_support/security_utils"
 
+require_relative "grape_helpers/dispatch"
+require_relative "grape_helpers/interactions"
+
 module SlackBot
   module GrapeHelpers
+    include Dispatch
+    include Interactions
+
     # Slack recommends rejecting requests older than 5 minutes
     TIMESTAMP_TOLERANCE_SECONDS = 300
     # Minimum length for Slack signing secret (Slack's requirement)
@@ -27,15 +33,20 @@ module SlackBot
       verify_signature_match!(slack_signing_secret, timestamp, slack_signature)
     end
 
-    def verify_slack_team!
-      slack_team_id = ENV.fetch("SLACK_TEAM_ID")
-      if slack_team_id == fetch_team_id
+    def verify_slack_team!(team_id = nil)
+      slack_team_id = ENV["SLACK_TEAM_ID"]
+      requested_team_id = team_id || fetch_team_id
+      if slack_team_id.present? && slack_team_id == requested_team_id
         true
       else
         raise SlackBot::Errors::TeamAuthenticationError.new("Team is not authorized")
       end
     end
 
+    def interaction_team_id(payload)
+      payload.dig("team", "id") || payload["team_id"] || payload.dig("user", "team_id")
+    end
+
     def verify_direct_message_channel!
       if params[:channel_name] == "directmessage"
         true
@@ -52,15 +63,8 @@ module SlackBot
       raise SlackBot::Errors::UserAuthenticationError.new("User is not authorized")
     end
 
-    def events_callback(params)
-      verify_slack_team!
-
-      SlackBot::DevConsole.log_input "SlackApi::Events#events_callback: #{params.inspect}"
-      handler = config.find_event_handler(params[:event][:type].to_sym)
-      return false if handler.blank?
-
-      event = handler.new(params: params, current_user: current_user)
-      event.call
+    def slack_request_retry?
+      slack_request_header("x-slack-retry-num", "X-Slack-Retry-Num").present?
     end
 
     def url_verification(params)
@@ -68,23 +72,6 @@ module SlackBot
       {challenge: params[:challenge]}
     end
 
-    def validate_callback_user!(callback, user)
-      if callback.user_id != user.id
-        raise SlackBot::Errors::CallbackUserMismatchError.new("Callback user is not equal to action user")
-      end
-    end
-
-    def handle_block_actions_view(view:, user:, params:)
-      callback = find_callback!(view: view, user: user)
-      log_callback_check(callback, user)
-      validate_callback_user!(callback, user)
-
-      interaction_klass = callback_interaction_klass(callback)
-      return false if interaction_klass.blank?
-
-      interaction_klass.new(current_user: user, params: params, callback: callback, config: config).call
-    end
-
     private
 
     def slack_request_header(*names)
@@ -131,22 +118,6 @@ module SlackBot
       body_content
     end
 
-    def find_callback!(view:, user:)
-      callback = SlackBot::Callback.find(view&.dig("callback_id"), user: user, config: config)
-      raise SlackBot::Errors::CallbackNotFound.new if callback.blank?
-
-      callback
-    end
-
-    def log_callback_check(callback, user)
-      SlackBot::DevConsole.log_check "SlackApi::Interactions##{__method__}: #{callback.id} #{callback.payload} #{callback.user_id} #{user&.id}"
-    end
-
-    def callback_interaction_klass(callback)
-      handler_class_obj = callback.handler_class
-      handler_class_obj&.interaction_klass if handler_class_obj&.respond_to?(:interaction_klass)
-    end
-
     def parse_interaction_payload!(raw_payload)
       JSON.parse(raw_payload)
     rescue JSON::ParserError => e
@@ -212,14 +183,10 @@ module SlackBot
       base.resource :interactions do
         post do
           payload = parse_interaction_payload!(params[:payload])
+          verify_slack_team!(interaction_team_id(payload))
           action_user = resolve_action_user(payload)&.user
 
-          result = case payload["type"]
-          when "block_actions", "view_submission"
-            handle_block_actions_view(view: payload["view"], user: action_user, params: params)
-          else
-            raise SlackBot::Errors::UnknownActionTypeError.new(payload["type"])
-          end
+          result = route_interaction(payload: payload, user: action_user, params: params)
 
           return blank_slack_response! if result.blank? || result == false
 
@@ -231,6 +198,8 @@ module SlackBot
     def self.add_events_resource!(base)
       base.resource :events do
         post do
+          return blank_slack_response! if slack_request_retry?
+
           result = case params[:type]
           when "url_verification"
             url_verification(params)
@@ -252,6 +221,7 @@ module SlackBot
         get do
           SlackBot::DevConsole.log_input "SlackApi::MenuOptions#get: #{params.inspect}"
 
+          verify_slack_team!
           menu_options_klass = config.find_menu_options(params[:action_id])
           raise SlackBot::Errors::MenuOptionsNotImplemented.new if menu_options_klass.blank?
 

data/lib/slack_bot/grape_helpers/dispatch.rb

@@ -0,0 +1,54 @@
+module SlackBot
+  module GrapeHelpers
+    module Dispatch
+      def events_callback(params)
+        verify_slack_team!
+
+        event = params[:event]
+        return false if event.blank?
+        return false if bot_message_event?(event)
+
+        SlackBot::DevConsole.log_input "SlackApi::Events#events_callback: #{params.inspect}"
+        handler = event_handler_for(params)
+        return false if handler.blank?
+
+        run_event_handler(handler, params)
+      end
+
+      def resolve_user_session(team_id, user_id)
+        return if team_id.blank? || user_id.blank?
+
+        config.user_session_resolver!.call(team_id, user_id)
+      rescue SlackBot::Errors::ConfigurationError
+        nil
+      end
+
+      def resolve_event_user(params)
+        resolve_user_session(params[:team_id] || params["team_id"], fetch_user_id)&.user
+      end
+
+      def dispatch_event(handler:, params:, current_user:)
+        config.event_dispatcher_method.call(handler: handler, params: params, current_user: current_user)
+        false
+      end
+
+      private
+
+      def bot_message_event?(event)
+        (event[:subtype] || event["subtype"]) == "bot_message"
+      end
+
+      def event_handler_for(params)
+        event_type = params[:event][:type] || params[:event]["type"]
+        config.find_event_handler(event_type.to_sym)
+      end
+
+      def run_event_handler(handler, params)
+        current_user = resolve_event_user(params)
+        return dispatch_event(handler: handler, params: params, current_user: current_user) if config.event_dispatcher_method
+
+        handler.new(params: params, current_user: current_user).call
+      end
+    end
+  end
+end

data/lib/slack_bot/grape_helpers/interactions.rb

@@ -0,0 +1,65 @@
+module SlackBot
+  module GrapeHelpers
+    module Interactions
+      def route_interaction(payload:, user:, params:)
+        case payload["type"]
+        when "view_submission"
+          handle_block_actions_view(view: payload["view"], user: user, params: params)
+        when "block_actions"
+          if payload["view"].present?
+            handle_block_actions_view(view: payload["view"], user: user, params: params)
+          else
+            handle_block_actions_message(payload: payload, user: user, params: params)
+          end
+        else
+          raise SlackBot::Errors::UnknownActionTypeError.new(payload["type"])
+        end
+      end
+
+      def handle_block_actions_message(payload:, user:, params:)
+        action_id = payload.dig("actions", 0, "action_id")
+        return false if action_id.blank?
+
+        interaction_klass = config.find_block_action(action_id)
+        raise SlackBot::Errors::BlockActionNotImplemented.new if interaction_klass.blank?
+
+        interaction_klass.new(current_user: user, params: params, config: config).call
+      end
+
+      def validate_callback_user!(callback, user)
+        if callback.user_id != user.id
+          raise SlackBot::Errors::CallbackUserMismatchError.new("Callback user is not equal to action user")
+        end
+      end
+
+      def handle_block_actions_view(view:, user:, params:)
+        callback = find_callback!(view: view, user: user)
+        log_callback_check(callback, user)
+        validate_callback_user!(callback, user)
+
+        interaction_klass = callback_interaction_klass(callback)
+        return false if interaction_klass.blank?
+
+        interaction_klass.new(current_user: user, params: params, callback: callback, config: config).call
+      end
+
+      private
+
+      def find_callback!(view:, user:)
+        callback = SlackBot::Callback.find(view&.dig("callback_id"), user: user, config: config)
+        raise SlackBot::Errors::CallbackNotFound.new if callback.blank?
+
+        callback
+      end
+
+      def log_callback_check(callback, user)
+        SlackBot::DevConsole.log_check "SlackApi::Interactions##{__method__}: #{callback.id} #{callback.payload} #{callback.user_id} #{user&.id}"
+      end
+
+      def callback_interaction_klass(callback)
+        handler_class_obj = callback.handler_class
+        handler_class_obj&.interaction_klass if handler_class_obj&.respond_to?(:interaction_klass)
+      end
+    end
+  end
+end

data/lib/slack_bot/interaction.rb

@@ -9,20 +9,28 @@ module SlackBot
 
     include SlackBot::Concerns::ViewKlass
 
+    def self.api_client
+      @api_client ||= SlackBot::ApiClient.new
+    end
+
+    def self.api_client=(client)
+      @api_client = client
+    end
+
     def self.open_modal(callback:, trigger_id:, view:)
       view = modal_payload(callback, view)
-      response = SlackBot::ApiClient.new.views_open(trigger_id: trigger_id, view: view)
+      response = api_client.views_open(trigger_id: trigger_id, view: view)
       build_view_reply(response: response, callback: callback, payload: view, error_class: SlackBot::Errors::OpenModalError)
     end
 
     def self.update_modal(callback:, view_id:, view:)
       view = modal_payload(callback, view)
-      response = SlackBot::ApiClient.new.views_update(view_id: view_id, view: view)
+      response = api_client.views_update(view_id: view_id, view: view)
       build_view_reply(response: response, callback: callback, payload: view, error_class: SlackBot::Errors::UpdateModalError)
     end
 
     def self.publish_view(user_id:, view:, callback: nil, metadata: nil)
-      response = SlackBot::ApiClient.new.views_publish(user_id: user_id, view: publish_payload(callback, metadata, view))
+      response = api_client.views_publish(user_id: user_id, view: publish_payload(callback, metadata, view))
       build_view_reply(response: response, callback: callback, payload: view, error_class: SlackBot::Errors::PublishViewError)
     end
 

data/lib/slack_bot/logger.rb

@@ -1,5 +1,33 @@
 module SlackBot
   class Logger
+    class << self
+      def info(...)
+        logger_backend.info(...)
+      end
+
+      def error(...)
+        logger_backend.error(...)
+      end
+
+      def warn(...)
+        logger_backend.warn(...)
+      end
+
+      def debug(...)
+        logger_backend.debug(...)
+      end
+
+      private
+
+      def logger_backend
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger
+        else
+          @logger_backend ||= new
+        end
+      end
+    end
+
     def info(*args, **kwargs)
       puts args.inspect if args.any?
       puts kwargs.inspect if kwargs.any?

data/lib/slack_bot/pager.rb

@@ -12,11 +12,11 @@ module SlackBot
     end
 
     def total_count
-      source_cursor.count
+      @total_count ||= source_cursor.count
     end
 
     def pages_count
-      (source_cursor.count.to_f / limit).ceil
+      (total_count.to_f / limit).ceil
     end
 
     def offset

data/lib/slack_bot.rb

@@ -25,5 +25,5 @@ require "slack_bot/pager"
 require "slack_bot/grape_extension"
 
 module SlackBot
-  VERSION = "2.0.1".freeze
+  VERSION = "2.1.0".freeze
 end

data/sig/slack_bot.rbs

@@ -23,6 +23,9 @@ module SlackBot
     class MenuOptionsNotImplemented < Error
     end
 
+    class BlockActionNotImplemented < Error
+    end
+
     class CallbackNotFound < Error
     end
 
@@ -74,6 +77,9 @@ module SlackBot
 
     class NotImplementedError < Error
     end
+
+    class ConfigurationError < Error
+    end
   end
 
   class Config
@@ -82,9 +88,18 @@ module SlackBot
 
     attr_reader callback_storage_instance: untyped
     def callback_storage: (untyped klass) -> void
+    def callback_storage!: () -> untyped
 
     attr_reader callback_user_finder_method: Proc
     def callback_user_finder: (Proc method_lambda) -> void
+    def callback_user_finder!: () -> Proc
+
+    attr_reader user_session_resolver_method: Proc
+    def user_session_resolver: (Proc method_lambda) -> void
+    def user_session_resolver!: () -> Proc
+
+    attr_reader event_dispatcher_method: Proc
+    def event_dispatcher: (Proc method_lambda) -> void
 
     def interaction: (Class interaction_klass, ?handler_name: String?) -> void
     def event_handlers: () -> Hash[Symbol, Class]
@@ -98,6 +113,9 @@ module SlackBot
     def menu_options: (Symbol action_id, Class klass) -> void
     def find_menu_options: (Symbol action_id) -> Class?
 
+    def block_action: (Symbol action_id, Class interaction_klass, ?handler_name: String?) -> void
+    def find_block_action: (Symbol action_id) -> Class?
+
     def handler_class: (String class_name, Class klass) -> void
     def find_handler_class: (String class_name) -> Class
   end
@@ -157,9 +175,12 @@ module SlackBot
   class ApiResponse
     attr_reader response: Faraday::Response
 
+    def self.from_request: () { () -> Faraday::Response } -> ApiResponse
     def initialize: () { () -> Faraday::Response } -> void
     def ok?: () -> bool
     def error: () -> String?
+    def rate_limited?: () -> bool
+    def retry_after: () -> Integer
     def data: () -> Hash[String, untyped]
   end
 
@@ -301,12 +322,19 @@ module SlackBot
     def fetch_team_id: () -> String?
     def fetch_user_id: () -> String?
     def verify_slack_signature!: () -> bool
-    def verify_slack_team!: () -> bool
+    def verify_slack_team!: (?String? team_id) -> bool
+    def interaction_team_id: (Hash[String, untyped] payload) -> String?
     def verify_direct_message_channel!: () -> bool
     def verify_current_user!: () -> bool
+    def slack_request_retry?: () -> bool
+    def resolve_user_session: (String? team_id, String? user_id) -> untyped?
+    def resolve_event_user: (Hash[String, untyped] params) -> untyped?
     def events_callback: (Hash[String, untyped] params) -> untyped
     def url_verification: (Hash[String, untyped] params) -> Hash[String, String]
     def handle_block_actions_view: (view: Hash[String, untyped]?, user: untyped, params: Hash[String, untyped]) -> untyped
+    def handle_block_actions_message: (payload: Hash[String, untyped], user: untyped, params: Hash[String, untyped]) -> untyped
+    def dispatch_event: (handler: Class, params: Hash[String, untyped], current_user: untyped) -> bool
+    def route_interaction: (payload: Hash[String, untyped], user: untyped, params: Hash[String, untyped]) -> untyped
   end
 
   module GrapeExtension

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape-slack-bot
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -47,16 +47,22 @@ dependencies:
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.14.3
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.14.3
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -97,14 +103,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 1.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -231,6 +237,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: memory_profiler
   requirement: !ruby/object:Gem::Requirement
@@ -299,6 +319,8 @@ files:
 - lib/slack_bot/errors.rb
 - lib/slack_bot/event.rb
 - lib/slack_bot/grape_extension.rb
+- lib/slack_bot/grape_helpers/dispatch.rb
+- lib/slack_bot/grape_helpers/interactions.rb
 - lib/slack_bot/interaction.rb
 - lib/slack_bot/logger.rb
 - lib/slack_bot/menu_options.rb