slack-ruby-client 0.11.0 → 2.7.0

data/lib/slack/web/api/helpers/files.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module Slack
+  module Web
+    module Api
+      module Helpers
+        module Files
+          #
+          # Uses Slack APIs new sequential file upload flow. This replaces the files.upload method
+          # @see https://api.slack.com/changelog/2024-04-a-better-way-to-upload-files-is-here-to-stay
+          # @see https://api.slack.com/messaging/files#uploading_files
+          #
+          # @option params [string] :filename
+          #   Name of the file being uploaded.
+          # @option params [string] :content
+          #   File contents via a POST variable.
+          # @option params [Array<Hash>] :files
+          #   Array of file objects with :filename, :content, and optionally :title, :alt_txt, :snippet_type.
+          # @option params [string] :alt_txt
+          #   Description of image for screen-reader.
+          # @option params [string] :snippet_type
+          #   Syntax type of the snippet being uploaded.
+          # @option params [string] :title
+          #   Title of file.
+          # @option params [string] :channel_id
+          #   Channel ID where the file will be shared. If not specified the file will be private.
+          # @option params [string] :channel
+          #   Channel where the file will be shared, alias of channel_id. If not specified the file will be private.
+          # @option params [string] :channels
+          #   Comma-separated string of channel IDs where the file will be shared. If not specified the file will be private.
+          # @option params [string] :initial_comment
+          #   The message text introducing the file in specified channels.
+          # @option params [string] :thread_ts
+          #   Provide another message's ts value to upload this file as a reply.
+          #   Never use a reply's ts value; use its parent instead.
+          #   Also make sure to provide only one channel when using 'thread_ts'.
+          def files_upload_v2(params = {})
+            files_to_upload = if params[:files] && params[:files].is_a?(Array)
+                                params[:files]
+                              else
+                                [params.slice(:filename, :content, :title, :alt_txt, :snippet_type)]
+                              end
+
+            files_to_upload.each_with_index do |file, index|
+              %i[filename content].each do |param|
+                raise ArgumentError, "Required argument :#{param} missing in file (#{index})" if file[param].nil?
+              end
+            end
+
+            channel_params = %i[channel channels channel_id].map { |param| params[param] }.compact
+            raise ArgumentError, 'Only one of :channel, :channels, or :channel_id is required' if channel_params.size > 1
+
+            complete_upload_request_params = params.slice(:initial_comment, :thread_ts)
+
+            if params[:channels]
+              complete_upload_request_params[:channels] = Array(params[:channels]).map do |channel|
+                conversations_id(channel: channel)['channel']['id']
+              end.uniq.join(',')
+            elsif params[:channel]
+              complete_upload_request_params[:channel_id] = conversations_id(
+                channel: params[:channel]
+              )['channel']['id']
+            elsif params[:channel_id]
+              complete_upload_request_params[:channel_id] = params[:channel_id]
+            end
+
+            uploaded_files = files_to_upload.map do |file|
+              content = file[:content]
+              title = file[:title] || file[:filename]
+
+              upload_url_request_params = file.slice(:filename, :alt_txt, :snippet_type)
+              upload_url_request_params[:length] = content.bytesize
+
+              get_upload_url_response = files_getUploadURLExternal(upload_url_request_params)
+              upload_url = get_upload_url_response[:upload_url]
+              file_id = get_upload_url_response[:file_id]
+
+              ::Faraday::Connection.new(upload_url, options) do |connection|
+                connection.request :multipart
+                connection.request :url_encoded
+                connection.use ::Slack::Web::Faraday::Response::WrapError
+                connection.response :logger, logger if logger
+                connection.adapter adapter
+              end.post do |request|
+                request.body = content
+              end
+
+              { id: file_id, title: title }
+            end
+
+            complete_upload_request_params[:files] = uploaded_files.to_json
+            files_completeUploadExternal(complete_upload_request_params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/web/api/helpers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/files'
+
+module Slack
+  module Web
+    module Api
+      module Helpers
+        include Files
+      end
+    end
+  end
+end

data/lib/slack/web/api/mixins/conversations.id.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative 'ids.id'
+
+module Slack
+  module Web
+    module Api
+      module Mixins
+        module Conversations
+          include Ids
+          #
+          # This method returns a channel ID given a channel name.
+          #
+          # @option options [channel] :channel
+          #   Channel to get ID for, prefixed with #.
+          # @option options [string] :team_id
+          #   The team id to search for channels in, required if token belongs to org-wide app.
+          #   This field will be ignored if the API call is sent using a workspace-level token.
+          # @option options [boolean] :id_exclude_archived
+          #   Set to true to exclude archived channels from the search
+          # @option options [integer] :id_limit
+          #   The page size used for conversations_list calls required to find the channel's ID
+          # @option options [string] :id_types
+          #   The types of conversations to use when searching for the ID. A comma-separated list
+          #   containing one or more of public_channel, private_channel, mpim, im
+          def conversations_id(options = {})
+            name = options[:channel]
+            raise ArgumentError, 'Required arguments :channel missing' if name.nil?
+
+            id_for(
+              key: :channel,
+              name: name,
+              prefix: '#',
+              enum_method: :conversations_list,
+              list_method: :channels,
+              options: {
+                team_id: options.fetch(:team_id, nil),
+                exclude_archived: options.fetch(:id_exclude_archived, nil),
+                limit: options.fetch(:id_limit, Slack::Web.config.conversations_id_page_size),
+                types: options.fetch(:id_types, nil)
+              }.compact
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/web/api/mixins/ids.id.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module Web
     module Api
@@ -5,16 +6,16 @@ module Slack
         module Ids
           private
 
-          def id_for(key, name, prefix, list_method, not_found_error)
+          def id_for(key:, name:, prefix:, enum_method:, list_method:, options: {})
             return { 'ok' => true, key.to_s => { 'id' => name } } unless name[0] == prefix
 
-            yield.tap do |list|
+            public_send(enum_method, **options) do |list|
               list.public_send(list_method).each do |li|
                 return Slack::Messages::Message.new('ok' => true, key.to_s => { 'id' => li.id }) if li.name == name[1..-1]
               end
             end
 
-            raise Slack::Web::Api::Errors::SlackError, not_found_error
+            raise Slack::Web::Api::Errors::SlackError, "#{key}_not_found"
           end
         end
       end

data/lib/slack/web/api/mixins/users.id.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'ids.id'
 
 module Slack
@@ -11,13 +12,26 @@ module Slack
           #
           # @option options [user] :user
           #   User to get ID for, prefixed with '@'.
+          # @option options [string] :team_id
+          #   The team id to search for users in, required if token belongs to org-wide app.
+          #   This field will be ignored if the API call is sent using a workspace-level token.
+          # @option options [integer] :id_limit
+          #   The page size used for users_list calls required to find the user's ID
           def users_id(options = {})
             name = options[:user]
-            throw ArgumentError.new('Required arguments :user missing') if name.nil?
+            raise ArgumentError, 'Required arguments :user missing' if name.nil?
 
-            id_for(:user, name, '@', :members, 'user_not_found') do
-              users_list
-            end
+            id_for(
+              key: :user,
+              name: name,
+              prefix: '@',
+              enum_method: :users_list,
+              list_method: :members,
+              options: {
+                team_id: options.fetch(:team_id, nil),
+                limit: options.fetch(:id_limit, Slack::Web.config.users_id_page_size)
+              }.compact
+            )
           end
         end
       end

data/lib/slack/web/api/mixins/users.search.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 if defined?(Picky)
   module Slack
     module Web
@@ -13,7 +14,8 @@ if defined?(Picky)
             #   Free-formed text to search for.
             def users_search(options = {})
               query = options[:user]
-              throw ArgumentError.new('Required arguments :user missing') if query.nil?
+              raise ArgumentError, 'Required arguments :user missing' if query.nil?
+
               index = Picky::Index.new(:users) do
                 category :name
                 category :first_name

data/lib/slack/web/api/mixins.rb

@@ -1,4 +1,4 @@
-require_relative 'mixins/channels.id'
+# frozen_string_literal: true
+require_relative 'mixins/conversations.id'
 require_relative 'mixins/users.id'
 require_relative 'mixins/users.search'
-require_relative 'mixins/groups.id'

data/lib/slack/web/api/options.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Slack
+  module Web
+    module Api
+      module Options
+        def encode_options_as_json(options, keys)
+          encoded_options = options.slice(*keys).transform_values do |value|
+            encode_json(value)
+          end
+          options.merge(encoded_options)
+        end
+
+        private
+
+        def encode_json(value)
+          if value.is_a?(String)
+            value
+          else
+            JSON.dump(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/web/api/templates/command.erb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
 # This file was auto-generated by lib/tasks/web.rake
 
+module Slack
+  module Cli
+    class App
 <% desc = group['desc'] || "#{group['name'].gsub(".", "_").camelize} methods." %>
 <% if desc.include?("'")  %>
-desc "<%= desc %>"
+      desc "<%= desc %>"
 <% else %>
-desc '<%= desc %>'
+      desc '<%= desc %>'
 <% end %>
-command '<%= group['name'].gsub(".", "_") %>' do |g|
+      command '<%= group['name'].gsub(".", "_") %>' do |g|
 <% names.sort.each_with_index do |(name, data), index| %>
 <% if index > 0 %>
 
@@ -14,22 +18,25 @@ command '<%= group['name'].gsub(".", "_") %>' do |g|
   <% short_desc = data["desc"].split("\n").first %>
   <% short_desc += ' (undocumented)' if data['undocumented'] %>
   <% if short_desc.include?("'")  %>
-  g.desc "<%= short_desc %>"
+        g.desc "<%= short_desc %>"
   <% else %>
-  g.desc '<%= short_desc %>'
+        g.desc '<%= short_desc %>'
   <% end %>
-  g.long_desc %( <%= data["desc"].split("\n").join(" ") %> )
-  g.command '<%= name %>' do |c|
+        g.long_desc %( <%= data["desc"].split("\n").join(" ") %> )
+        g.command '<%= name %>' do |c|
   <% data["args"].each do |arg_name, arg_v| %>
     <% if arg_v["desc"].include?("'") %>
-    c.flag '<%= arg_name %>', desc: "<%= arg_v["desc"].gsub('"', '\'') %>"
+          c.flag '<%= arg_name %>', desc: "<%= arg_v["desc"].gsub('"', '\'') %>"
     <% else %>
-    c.flag '<%= arg_name %>', desc: '<%= arg_v["desc"] %>'
+          c.flag '<%= arg_name %>', desc: '<%= arg_v["desc"] %>'
     <% end %>
   <% end %>
-    c.action do |_global_options, options, _args|
-      puts JSON.dump($client.<%=group['name'].gsub(".", "_") %>_<%= name %>(options))
+          c.action do |_global_options, options, _args|
+            puts JSON.dump(@client.<%=group['name'].gsub(".", "_") %>_<%= name %>(options))
+          end
+        end
+<% end %>
+      end
     end
   end
-<% end %>
 end

data/lib/slack/web/api/templates/endpoints.erb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # This file was auto-generated by lib/tasks/web.rake
 
 <% files.sort.each do |f| %>
@@ -8,9 +9,8 @@ module Slack
   module Web
     module Api
       module Endpoints
-        include Slack::Web::Api::Mixins::Channels
+        include Slack::Web::Api::Mixins::Conversations
         include Slack::Web::Api::Mixins::Users
-        include Slack::Web::Api::Mixins::Groups
 
 <% files.sort.each do |f| %>
         include <%= f.camelize %>

data/lib/slack/web/api/templates/errors.erb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# This file was auto-generated by lib/tasks/web.rake
+
+module Slack
+  module Web
+    module Api
+      module Errors
+        <% errors.each do |e| %>
+        class <%= e.camelize %> < SlackError; end
+        <% end %>
+
+        ERROR_CLASSES = {
+          <% errors.each do |e| %>
+          '<%= e %>' => <%= e.camelize %>,
+          <% end %>
+        }.freeze
+      end
+    end
+  end
+end

data/lib/slack/web/api/templates/method.erb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # This file was auto-generated by lib/tasks/web.rake
 
 module Slack
@@ -34,16 +35,35 @@ module Slack
 <% end %>
           def <%= group.gsub(".", "_") %>_<%= name %>(options = {})
 <% data['args'].select{ |k, v| v['required'] }.each do |arg_name, arg_v| %>
-            throw ArgumentError.new('Required arguments :<%= arg_name %> missing') if options[:<%= arg_name %>].nil?
+            raise ArgumentError, 'Required arguments :<%= arg_name %> missing' if options[:<%= arg_name %>].nil?
+<% end %>
+<% data['arg_groups']&.each do |arg_group| %>
+  <% next if arg_group['args'].size <= 1 %>
+<% arg_string = arg_group['args'].map { |arg_name| ":#{arg_name}" }.join(', ') %>
+<% if arg_group['mutually_exclusive'] %>
+            raise ArgumentError, 'Exactly one of <%= arg_string %> is required' unless <%= arg_group['args'].map { |arg_name| "options[:#{arg_name}].nil?" }.join(' ^ ') %>
+<% else %>
+            raise ArgumentError, 'At least one of <%= arg_string %> is required' if <%= arg_group['args'].map { |arg_name| "options[:#{arg_name}].nil?"}.join(' && ') %>
+<% end %>
 <% end %>
 <% if data['group'] == 'groups' && data['args']['channel'] && !data['args']['channel']['desc'].include?('Can be an encoded ID, or a name.') %>
             options = options.merge(channel: groups_id(options)['group']['id']) if options[:channel]
-<% elsif data['args']['channel'] && !data['args']['channel']['desc'].include?('Can be an encoded ID, or a name.') %>
-            options = options.merge(channel: channels_id(options)['channel']['id']) if options[:channel]
+<% elsif data['args']['channel'] && ['Can be an encoded ID, or a name.', 'encoded ID or channel name'].none? { |desc| data['args']['channel']['desc'].include?(desc) } %>
+            options = options.merge(channel: conversations_id(options)['channel']['id']) if options[:channel]
 <% end %>
 <% if data['args']['user'] %>
             options = options.merge(user: users_id(options)['user']['id']) if options[:user]
 <% end %>
+<% if data['undocumented'] %>
+            logger.warn('The <%= group %>.<%= name %> method is undocumented.')
+<% end %>
+<% if data['deprecated'] %>
+            logger.warn('<%= group %>.<%= name %>: <%= data['deprecation']['deprecation_warning']%> Alternative methods: <%= data['deprecation']['alternative_methods'].join(', ')%>.')
+<% end %>
+<% json_args = data['args'].map { |arg_name, arg_v| arg_name if arg_v['format'] == 'json' }.compact %>
+<% if json_args.any? %>
+            options = encode_options_as_json(options, %i[<%= json_args.join(' ') %>])
+<% end %>
 <% if data['args'].keys.include?('cursor') %>
             if block_given?
               Pagination::Cursor.new(self, :<%= group.gsub(".", "_") %>_<%= name %>, options).each do |page|

data/lib/slack/web/api/templates/method_spec.erb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # This file was auto-generated by lib/tasks/web.rake
 
 require 'spec_helper'
@@ -6,13 +7,49 @@ RSpec.describe Slack::Web::Api::Endpoints::<%= group.gsub(".", "_").camelize %>
   let(:client) { Slack::Web::Client.new }
 <% names.sort.each_with_index do |(name, data), index| %>
 <% next if data['mixin'] %>
+<% group_required_params = data['arg_groups']&.map { |grp| grp['args'].first if grp['args'].size > 1 } || [] %>
 <% required_params = data['args'].select{ |k, v| v['required'] } %>
-<% next if required_params.none? %>
+<% all_required_params = data['args'].select{ |k, v| v['required'] || group_required_params.include?(k) } %>
+<% json_params = data['args'].map { |arg_name, arg_v| arg_name if arg_v['format'] == 'json' }.compact %>
+<% next if all_required_params.none? && json_params.none? && data['arg_groups'].nil? %>
+<% method_name = [group.gsub(".", "_"), name].join('_') %>
+<% example_params = all_required_params.to_h { |var, opts| [var, opts['example']] } %>
   context '<%= group %>_<%= name %>' do
 <% required_params.each do |arg_name, arg_v| %>
     it 'requires <%= arg_name %>' do
-<% params_except_required = required_params.reject{ |name, _| name == arg_name  }.map{|var, opts| "#{var}: '#{opts['example']}'"}.join(', ') %>
-      expect { client.<%= group.gsub(".", "_") %>_<%= name %><%= params_except_required.empty? ? '' : "(#{params_except_required})" %> }.to raise_error ArgumentError, /Required arguments :<%= arg_name %> missing/
+<% params_except_required = example_params.reject { |name, _| name == arg_name  }.map { |name, val| "#{name}: %q[#{val}]" }.join(', ') %>
+      expect { client.<%= method_name %><%= params_except_required.empty? ? '' : "(#{params_except_required})" %> }.to raise_error ArgumentError, /Required arguments :<%= arg_name %> missing/
+    end
+<% end %>
+<% data['arg_groups']&.each do |arg_group| %>
+    <% next if arg_group['args'].size <= 1 %>
+    it 'requires one of <%= arg_group['args'].join(', ') %>' do
+<% params_except_required = example_params.reject { |name, _| arg_group['args'].include?(name)  }.map { |name, val| "#{name}: %q[#{val}]" }.join(', ') %>
+<% error_message = arg_group['mutually_exclusive'] ? 'Exactly' : 'At least' %>
+      expect { client.<%= method_name %><%= params_except_required.empty? ? '' : "(#{params_except_required})" %> }.to raise_error ArgumentError, /<%= error_message %> one of/
+<% (1..arg_group['args'].length).each do |n| %>
+<% arg_group['args'].combination(n) do |names| %>
+<% params = names.map { |name| "#{name}: %q[#{data['args'][name]['example']}]" }.join(', ') %>
+<% params = "#{params}, #{params_except_required}" unless params_except_required.empty? %>
+<% if n == 1 || !arg_group['mutually_exclusive'] %>
+
+      expect(client).to receive(:post).with('<%= group %>.<%= name %>', {<%= params %>})
+      client.<%= method_name %><%= "(#{params})" %>
+<% else %>
+
+      expect { client.<%= method_name %><%= "(#{params})" %> }.to raise_error ArgumentError, /<%= error_message %> one of/
+<% end %>
+<% end %>
+<% end %>
+    end
+<% end %>
+<% if json_params.any? %>
+<% example_json_params = json_params.to_h { |name| [name, {data: ['data']}] } %>
+<% params = example_params.merge(example_json_params).map { |name, val| val = val.is_a?(String) ? "%q[#{val}]" : val; "#{name}: #{val}" }.join(', ') %>
+<% expected_params = example_params.merge(example_json_params.transform_values { |v| JSON.dump(v) }).map { |name, val| val = "%q[#{val}]"; "#{name}: #{val}" }.join(', ') %>
+    it 'encodes <%= json_params.join(', ') %> as json' do
+      expect(client).to receive(:post).with('<%= group %>.<%= name %>', {<%= expected_params %>})
+      client.<%= method_name %>(<%= params %>)
     end
 <% end %>
   end

data/lib/slack/web/client.rb

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
 module Slack
   module Web
     class Client
       include Faraday::Connection
       include Faraday::Request
       include Api::Endpoints
+      include Api::Helpers
+      include Api::Options
 
       attr_accessor(*Config::ATTRIBUTES)
 
       def initialize(options = {})
         Slack::Web::Config::ATTRIBUTES.each do |key|
-          send("#{key}=", options[key] || Slack::Web.config.send(key))
+          send("#{key}=", options.fetch(key, Slack::Web.config.send(key)))
         end
         @logger ||= Slack::Config.logger || Slack::Logger.default
         @token ||= Slack.config.token

data/lib/slack/web/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module Web
     module Config
@@ -14,7 +15,10 @@ module Slack
         timeout
         open_timeout
         default_page_size
+        conversations_id_page_size
+        users_id_page_size
         default_max_retries
+        adapter
       ].freeze
 
       attr_accessor(*Config::ATTRIBUTES)
@@ -22,15 +26,18 @@ module Slack
       def reset
         self.endpoint = 'https://slack.com/api/'
         self.user_agent = "Slack Ruby Client/#{Slack::VERSION}"
-        self.ca_path = defined?(OpenSSL) ? OpenSSL::X509::DEFAULT_CERT_DIR : nil
-        self.ca_file = defined?(OpenSSL) ? OpenSSL::X509::DEFAULT_CERT_FILE : nil
+        self.ca_path = nil
+        self.ca_file = nil
         self.token = nil
         self.proxy = nil
         self.logger = nil
         self.timeout = nil
         self.open_timeout = nil
         self.default_page_size = 100
+        self.conversations_id_page_size = nil
+        self.users_id_page_size = nil
         self.default_max_retries = 100
+        self.adapter = ::Faraday.default_adapter
       end
     end
 

data/lib/slack/web/faraday/connection.rb

@@ -1,32 +1,23 @@
+# frozen_string_literal: true
 module Slack
   module Web
     module Faraday
       module Connection
+        include Slack::Web::Faraday::Options
+
         private
 
         def connection
-          options = {
-            headers: { 'Accept' => 'application/json; charset=utf-8' }
-          }
-
-          options[:headers]['User-Agent'] = user_agent if user_agent
-          options[:proxy] = proxy if proxy
-          options[:ssl] = { ca_path: ca_path, ca_file: ca_file } if ca_path || ca_file
-
-          request_options = {}
-          request_options[:timeout] = timeout if timeout
-          request_options[:open_timeout] = open_timeout if open_timeout
-          options[:request] = request_options if request_options.any?
-
-          ::Faraday::Connection.new(endpoint, options) do |connection|
-            connection.use ::Faraday::Request::Multipart
-            connection.use ::Faraday::Request::UrlEncoded
-            connection.use ::Faraday::Response::RaiseError
+          @connection ||= ::Faraday::Connection.new(endpoint, options) do |connection|
+            connection.headers['Accept'] = 'application/json; charset=utf-8'
+            connection.request :multipart
+            connection.request :url_encoded
             connection.use ::Slack::Web::Faraday::Response::RaiseError
-            connection.use ::FaradayMiddleware::Mashify, mash_class: Slack::Messages::Message
-            connection.use ::FaradayMiddleware::ParseJson
+            connection.response :mashify, mash_class: Slack::Messages::Message
+            connection.response :json, content_type: /\b*$/
+            connection.use ::Slack::Web::Faraday::Response::WrapError
             connection.response :logger, logger if logger
-            connection.adapter ::Faraday.default_adapter
+            connection.adapter adapter
           end
         end
       end

data/lib/slack/web/faraday/options.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Slack
+  module Web
+    module Faraday
+      module Options
+        def options
+          @options ||= begin
+            options = { headers: {} }
+            options[:headers]['User-Agent'] = user_agent if user_agent
+            options[:proxy] = proxy if proxy
+            options[:ssl] = { ca_path: ca_path, ca_file: ca_file } if ca_path || ca_file
+
+            request_options = {}
+            request_options[:timeout] = timeout if timeout
+            request_options[:open_timeout] = open_timeout if open_timeout
+            options[:request] = request_options if request_options.any?
+
+            options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/web/faraday/request.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module Web
     module Faraday
@@ -21,18 +22,22 @@ module Slack
         private
 
         def request(method, path, options)
-          options = options.merge(token: token)
           response = connection.send(method) do |request|
             case method
             when :get, :delete
               request.url(path, options)
             when :post, :put
               request.path = path
+              options.compact! if options.respond_to? :compact
               request.body = options unless options.empty?
             end
+            request.headers['Authorization'] = "Bearer #{token}" if token
+
             request.options.merge!(options.delete(:request)) if options.key?(:request)
           end
           response.body
+        rescue ::Faraday::ParsingError => e
+          raise Slack::Web::Api::Errors::ParsingError, e.response
         end
       end
     end

data/lib/slack/web/faraday/response/raise_error.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
 module Slack
   module Web
     module Faraday
       module Response
-        class RaiseError < ::Faraday::Response::Middleware
+        class RaiseError < ::Faraday::Middleware
           def on_complete(env)
-            if env.status == 429
-              raise Slack::Web::Api::Errors::TooManyRequestsError, env.response
-            elsif (body = env.body) && body['ok']
-              nil
-            else
-              raise Slack::Web::Api::Errors::SlackError.new(body['error'], env.response)
-            end
+            raise Slack::Web::Api::Errors::TooManyRequestsError, env.response if env.status == 429
+
+            return unless env.success?
+
+            body = env.body
+            return unless body
+            return if body['ok']
+
+            error_message = body['error'] || body['errors'].map { |message| message['error'] }.join(',')
+            error_class = Slack::Web::Api::Errors::ERROR_CLASSES[error_message]
+            error_class ||= Slack::Web::Api::Errors::SlackError
+            raise error_class.new(error_message, env.response)
           end
         end
       end