restforce 5.2.4 → 6.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfdaff5160d8845afd9c6ed3c384c7edf7d9ecb2593d562bae4d9a4812904137
-  data.tar.gz: 8510146b906c8f7f0869a467db96d9bd3416446338a9d237d8c2e633c911cc35
+  metadata.gz: 06ba6ff782797da12181fade1eb6d25cec0da4395a0880080d684a6c8d0c928e
+  data.tar.gz: 17854adb01066aa6d09c784adeecee764b530afff0083297162c0d2633fac38f
 SHA512:
-  metadata.gz: 592471696b0c585cb73bc26cca75267cfc7a2f3543f86449edd4e3ffc5401975cd4ded7cc7a20b63b5854434c06e6e63c48e0f49bf51839b8b8bee15e02113e8
-  data.tar.gz: 71c9272a0799c6e899bbdd56a0380b6ae5b7112d11e56fb3860a10ca0ba0b1dfb9cf58bb25b0bf59ad8f8b38f50360f5f8ccbed4090afa194a67a19a7ae28318
+  metadata.gz: 8cb18b0f488c6e793b2c1a64e54e982f08b1739522ae3bb3a5f7dd8837ffe62c05506365731f9040b25dd396b7ad5f3aff143dd9476fd0f2be475bf23623547f
+  data.tar.gz: 7445f7337587cc19c61743abe80dad16c3d1b2c10527691d6e33edb65a023dcd4afb32db9a569405c43a7878c3cba32fb2426dd50264d7b56cfc95e5bdb2d203

data/.github/dependabot.yml

@@ -4,16 +4,7 @@ updates:
   directory: "/"
   schedule:
     interval: daily
-  open-pull-requests-limit: 10
-  ignore:
-  - dependency-name: rubocop
-    versions:
-    - 1.10.0
-    - 1.11.0
-    - 1.12.0
-    - 1.12.1
-    - 1.9.0
-  - dependency-name: webmock
-    versions:
-    - 3.12.0
-    - 3.12.1
+- package-ecosystem: 'github-actions'
+  directory: '/'
+  schedule:
+    interval: 'daily'

data/.github/workflows/build.yml

@@ -0,0 +1,23 @@
+name: 'Build'
+on: push
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby_version: ['2.7', '3.0', '3.1', '3.2.0-preview1']
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Setup Ruby ${{ matrix.ruby_version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ${{ matrix.ruby_version }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Lint Ruby files
+        run: bundle exec rubocop
+      - name: Run RSpec tests
+        run: bundle exec rspec

data/.github/workflows/faraday.yml

@@ -0,0 +1,27 @@
+name: 'Test against supported Faraday minor versions'
+on: push
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        # Normally, we only test the most recent patch version for any given minor version.
+        # For v2.0.x, we test v2.0.0 and v2.0.1 because v2.0.0 has a special behaviour where
+        # the Net::HTTP adapter is not included. See
+        # https://github.com/lostisland/faraday/blob/main/UPGRADING.md#faraday-20.
+        faraday_version: ['1.1.0', '1.2.0', '1.3.1', '1.4.1', '1.5.1', '1.6.0', '1.7.2', '1.8.0', '1.9.3', '1.10.0', '2.0.0', '2.0.1', '2.1.0', '2.2.0', '2.3.0', '2.4.0']
+    env:
+      FARADAY_VERSION: ~> ${{ matrix.faraday_version }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Setup Ruby ${{ matrix.ruby_version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: 3.1
+      - name: Install dependencies
+        run: bundle install
+      - name: Run RSpec tests
+        run: bundle exec rspec

data/.rubocop.yml

@@ -8,7 +8,7 @@ AllCops:
     - .*/**/*
     - vendor/**/*
   NewCops: enable
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
 
 # Limit lines to 90 characters.
 Layout/LineLength:

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# 6.0.0.rc.1 (Aug 4 2022)
+
+*This version is a release candidate. Once we have gathered feedback from users and are confident that it works as expected, we will release a final `v6.0.0` version.*
+
+__This version contains breaking changes. For help with upgrading, see [`UPGRADING.md`](https://github.com/restforce/restforce/blob/v6.0.0.rc.1/UPGRADING.md).__
+
+* __⚠️  Drop support for Ruby 2.6__, since [Ruby 2.6 has reached its end-of-life](https://www.ruby-lang.org/en/downloads/) (@timrogers)
+* __⚠️  Drop compatability with `faraday` versions before `v1.1.0`__ (@timrogers)
+* Add support for `faraday` versions `v2.0.0` onwards (@timrogers)
+
+# 5.3.1 (Jul 19 2022)
+
+* Handle the `EXCEEDED_ID_LIMIT` error returned by the Salesforce API (@timrogers, @yashshah1)
+
+# 5.3.0 (May 30, 2022)
+
+* Add support for Faraday v1.9.x and v1.10.0 (@magni-, @timrogers)
+* Follow redirects during authentication to support Lightning URLs (e.g. `*.lightning.force.com` instead of `*.my.salesforce.com`) (@nhocki)
+
 # 5.2.4 (Mar 16, 2022)
 
 * Fix `Restforce::Collection#size` for Salesforce APIs that use the `size` property to return the total number of results, instead of `totalSize` (@kwong-yw)

data/Gemfile

@@ -3,6 +3,10 @@
 source 'https://rubygems.org'
 gemspec
 
+faraday_version = ENV.fetch('FARADAY_VERSION', '~> 1.8.0')
+
+# Enable us to explicitly pick a Faraday version when running tests
+gem 'faraday', faraday_version
 gem 'faye' unless RUBY_PLATFORM == 'java'
 gem 'guard-rspec'
 gem 'guard-rubocop'
@@ -12,6 +16,8 @@ gem 'rspec', '~> 3.11.0'
 gem 'rspec-collection_matchers', '~> 1.2.0'
 gem 'rspec-its', '~> 1.3.0'
 gem 'rspec_junit_formatter', '~> 0.5.1'
-gem 'rubocop', '~> 1.26.0'
+gem 'rubocop', '~> 1.32.0'
 gem 'simplecov', '~> 0.21.2'
-gem 'webmock', '~> 3.14.0'
+gem 'webmock', '~> 3.16.0'
+
+gem 'faraday-typhoeus', '~> 0.2.1' unless faraday_version.start_with?("~> 1")

data/README.md

@@ -1,7 +1,7 @@
 # Restforce
 
-[![CircleCI](https://circleci.com/gh/restforce/restforce.svg?style=svg)](https://circleci.com/gh/restforce/restforce) [![Code Climate](https://codeclimate.com/github/restforce/restforce.png)](https://codeclimate.com/github/restforce/restforce) [![Dependency Status](https://gemnasium.com/restforce/restforce.png)](https://gemnasium.com/restforce/restforce)
-![](https://img.shields.io/gem/dt/restforce.svg)
+[![CircleCI](https://circleci.com/gh/restforce/restforce.svg?style=svg)](https://circleci.com/gh/restforce/restforce)
+![Downloads](https://img.shields.io/gem/dt/restforce.svg)
 
 Restforce is a ruby gem for the [Salesforce REST api](http://www.salesforce.com/us/developer/docs/api_rest/index.htm).
 
@@ -27,7 +27,7 @@ Features include:
 
 Add this line to your application's Gemfile:
 
-    gem 'restforce', '~> 5.2.4'
+    gem 'restforce', '~> 5.3.1'
 
 And then execute:
 
@@ -293,6 +293,8 @@ client.find('Account', '1234', 'Some_External_Id_Field__c')
 # => #<Restforce::SObject Id="001D000000INjVe" Name="Test" LastModifiedBy="005G0000002f8FHIAY" ... >
 ```
 
+`find` raises an error if nothing is found.
+
 ### select
 
 `select` allows the fetching of a specific list of fields from a single object.  It requires an `external_id` lookup, but is often much faster than an arbitrary query.

data/UPGRADING.md

@@ -1,3 +1,32 @@
+# Upgrading from Restforce 5.x to 6.x
+
+__There are two breaking changes introduced in Restforce 6.x__. In this guide, you'll learn about these changes and what you should check in your code to make sure that it will work with the latest version of the library.
+
+## Versions of `faraday` before `v1.1.0` are no longer supported
+
+__Likelyhood of impact__: Moderate
+
+Restforce uses a gem called [`faraday`](https://github.com/lostisland/faraday) to make HTTP requests to Salesforce. 
+
+Up until now, Restforce has supported Faraday versions between v0.9.0 and v1.10.0. 
+
+In Restforce 6.x, we drop support for Faraday versions before v1.1.0, and add support for Faraday v2.x.
+
+This will allow you to use the latest versions of Faraday and benefit from security patches, new features, etc., but you may need to adapt your code. The impact of this change will depend on your project:
+
+* If Restforce is the only part of your project using Faraday - that is, your own code doesn't use Faraday and none of your other gems use Faraday - then you shouldn't need to do anything special. Just upgrade Restforce, and everything should be handled automatically.
+* If your own code uses Faraday or another gem you use depends on Faraday, and you're currently using a Faraday version before v1.1.0, you will need to upgrade your Faraday version. If possible, you should upgrade to the latest version (v2.4.0 at the time of writing). This may require you to adapt your code (see [here](https://github.com/lostisland/faraday/blob/main/UPGRADING.md) for Faraday's instructions) or upgrade other gems you depend on.
+
+## Ruby 2.6 is no longer supported
+
+__Likelyhood of impact__: Moderate
+
+Ruby 2.6 is no longer officially supported as an active version of the Ruby language. That means that it will not receive patches and security fixes.
+
+Accordingly, we've dropped support for Ruby 2.6 and earlier in the Restforce library. The gemspec now specifies that only 2.7 onwards is supported, and this will be enforced by RubyGems.
+
+Before you update to Restforce 6.x, you'll need to switch to Ruby 2.7 or later. The current version of Ruby at the time of wriing is 3.1.
+
 # Upgrading from Restforce 4.x to 5.x
 
 __There are three breaking changes introduced in Restforce 5.x__. In this guide, you'll learn about these changes and what you should check in your code to make sure that it will work with the latest version of the library.

data/lib/restforce/concerns/api.rb

@@ -429,6 +429,7 @@ module Restforce
       # field   - External ID field to use (default: nil).
       #
       # Returns the Restforce::SObject sobject record.
+      # Raises NotFoundError if nothing is found.
       def find(sobject, id, field = nil)
         url = if field
                 "sobjects/#{sobject}/#{field}/#{ERB::Util.url_encode(id)}"

data/lib/restforce/concerns/connection.rb

@@ -43,7 +43,7 @@ module Restforce
           # Caches GET requests.
           builder.use Restforce::Middleware::Caching, cache, options if cache
           # Follows 30x redirects.
-          builder.use FaradayMiddleware::FollowRedirects
+          builder.use Faraday::FollowRedirects::Middleware
           # Raises errors for 40x responses.
           builder.use Restforce::Middleware::RaiseError
           # Parses returned JSON response into a hash.

data/lib/restforce/config.rb

@@ -91,29 +91,31 @@ module Restforce
       end
     end
 
-    option :api_version, default: lambda { ENV['SALESFORCE_API_VERSION'] || '26.0' }
+    option :api_version, default: lambda { ENV.fetch('SALESFORCE_API_VERSION', '26.0') }
 
     # The username to use during login.
-    option :username, default: lambda { ENV['SALESFORCE_USERNAME'] }
+    option :username, default: lambda { ENV.fetch('SALESFORCE_USERNAME', nil) }
 
     # The password to use during login.
-    option :password, default: lambda { ENV['SALESFORCE_PASSWORD'] }
+    option :password, default: lambda { ENV.fetch('SALESFORCE_PASSWORD', nil) }
 
     # The security token to use during login.
-    option :security_token, default: lambda { ENV['SALESFORCE_SECURITY_TOKEN'] }
+    option :security_token, default: lambda {
+                                       ENV.fetch('SALESFORCE_SECURITY_TOKEN', nil)
+                                     }
 
     # The OAuth client id
-    option :client_id, default: lambda { ENV['SALESFORCE_CLIENT_ID'] }
+    option :client_id, default: lambda { ENV.fetch('SALESFORCE_CLIENT_ID', nil) }
 
     # The OAuth client secret
-    option :client_secret, default: lambda { ENV['SALESFORCE_CLIENT_SECRET'] }
+    option :client_secret, default: lambda { ENV.fetch('SALESFORCE_CLIENT_SECRET', nil) }
 
     # The private key for JWT authentication
     option :jwt_key
 
     # Set this to true if you're authenticating with a Sandbox instance.
     # Defaults to false.
-    option :host, default: lambda { ENV['SALESFORCE_HOST'] || 'login.salesforce.com' }
+    option :host, default: lambda { ENV.fetch('SALESFORCE_HOST', 'login.salesforce.com') }
 
     option :oauth_token
     option :refresh_token
@@ -139,7 +141,7 @@ module Restforce
     # Faraday adapter to use. Defaults to Faraday.default_adapter.
     option :adapter, default: lambda { Faraday.default_adapter }
 
-    option :proxy_uri, default: lambda { ENV['SALESFORCE_PROXY_URI'] }
+    option :proxy_uri, default: lambda { ENV.fetch('SALESFORCE_PROXY_URI', nil) }
 
     # A Proc that is called with the response body after a successful authentication.
     option :authentication_callback

data/lib/restforce/error_code.rb

@@ -145,6 +145,8 @@ module Restforce
 
     class ErrorInMailer < ResponseError; end
 
+    class ExceededIdLimit < ResponseError; end
+
     class ExceededMaxSemijoinSubselects < ResponseError; end
 
     class FailedActivation < ResponseError; end
@@ -484,6 +486,7 @@ module Restforce
       "ENTITY_IS_LOCKED" => EntityIsLocked,
       "ENVIRONMENT_HUB_MEMBERSHIP_CONFLICT" => EnvironmentHubMembershipConflict,
       "ERROR_IN_MAILER" => ErrorInMailer,
+      "EXCEEDED_ID_LIMIT" => ExceededIdLimit,
       "EXCEEDED_MAX_SEMIJOIN_SUBSELECTS" => ExceededMaxSemijoinSubselects,
       "FAILED_ACTIVATION" => FailedActivation,
       "FIELD_CUSTOM_VALIDATION_EXCEPTION" => FieldCustomValidationException,

data/lib/restforce/file_part.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
-begin
+case Faraday::VERSION
+when /\A1\.[0-8]\./
+  # Faraday 1.x versions before 1.9 - not matched by
+  # the previous clause - use `FilePart` (which must be explicitly
+  # required)
   require 'faraday/file_part'
-rescue LoadError
-  require 'faraday/upload_io'
+when /\A[12]\./
+  # Later 1.x versions from 1.9 onwards automatically include the
+  # `faraday-multipart` gem, which includes `Faraday::FilePart`
+  require 'faraday/multipart'
+else
+  raise "Unexpected Faraday version #{Faraday::VERSION} - not sure how to set up " \
+        "multipart support"
 end
-
 module Restforce
   if defined?(::Faraday::FilePart)
     FilePart = Faraday::FilePart

data/lib/restforce/middleware/authentication.rb

@@ -49,6 +49,7 @@ module Restforce
       @connection ||= Faraday.new(faraday_options) do |builder|
         builder.use Faraday::Request::UrlEncoded
         builder.use Restforce::Middleware::Mashify, nil, @options
+        builder.use Faraday::FollowRedirects::Middleware
         builder.response :json
 
         if Restforce.log?

data/lib/restforce/middleware/caching.rb

@@ -1,30 +1,155 @@
 # frozen_string_literal: true
 
+#
+# Taken from `lib/faraday_middleware/response/caching.rb` in the `faraday_middleware`
+# gem (<https://github.com/lostisland/faraday_middleware/blob/784b4f8/lib/faraday_middleware/response/caching.rb>).
+#
+# Includes some small modifications to allow the cache to be cleared in
+# `#without_caching` mode, replicating traditional Restforce behaviour.
+#
+# Copyright (c) 2011 Erik Michaels-Ober, Wynn Netherland, et al.
+# Licensed under the MIT License.
+#
+require 'faraday'
+require 'forwardable'
+require 'digest/sha1'
+
 module Restforce
-  class Middleware::Caching < FaradayMiddleware::Caching
-    def call(env)
-      expire(cache_key(env)) unless use_cache?
-      super
+  # Public: Caches GET responses and pulls subsequent ones from the cache.
+  class Middleware::Caching < Faraday::Middleware
+    attr_reader :cache
+
+    # Internal: List of status codes that can be cached:
+    # * 200 - 'OK'
+    # * 203 - 'Non-Authoritative Information'
+    # * 300 - 'Multiple Choices'
+    # * 301 - 'Moved Permanently'
+    # * 302 - 'Found'
+    # * 404 - 'Not Found'
+    # * 410 - 'Gone'
+    CACHEABLE_STATUS_CODES = [200, 203, 300, 301, 302, 404, 410].freeze
+
+    extend Forwardable
+    def_delegators :'Faraday::Utils', :parse_query, :build_query
+
+    # Public: initialize the middleware.
+    #
+    # cache   - An object that responds to read and write (default: nil).
+    # options - An options Hash (default: {}):
+    #           :ignore_params - String name or Array names of query
+    #                                    params that should be ignored when forming
+    #                                    the cache key (default: []).
+    #           :write_options - Hash of settings that should be passed as the
+    #                                    third options parameter to the cache's #write
+    #                                    method. If not specified, no options parameter
+    #                                    will be passed.
+    #           :full_key      - Boolean - use full URL as cache key:
+    #                                    (url.host + url.request_uri)
+    #           :status_codes  - Array of http status code to be cache
+    #                                    (default: CACHEABLE_STATUS_CODE)
+    #
+    # Yields if no cache is given. The block should return a cache object.
+    def initialize(app, cache = nil, options = {})
+      super(app)
+      if cache.is_a?(Hash) && block_given?
+        options = cache
+        cache = nil
+      end
+      @cache = cache || yield
+      @options = options
     end
 
-    def expire(key)
-      cache&.delete(key)
+    def call(env)
+      # Taken from `Restforce::Middleware::Caching` implementation
+      # before we switched away from the `faraday_middleware` gem.
+      # See https://github.com/restforce/restforce/blob/a08b9d6c5e277bd7111ffa7ed50465dd49c05fab/lib/restforce/middleware/caching.rb.
+      cache&.delete(cache_key(env)) unless use_cache?
+
+      if env[:method] == :get
+        if env[:parallel_manager]
+          # callback mode
+          cache_on_complete(env)
+        else
+          # synchronous mode
+          key = cache_key(env)
+          unless (response = cache.read(key)) && response
+            response = @app.call(env)
+            store_response_in_cache(key, response)
+          end
+          finalize_response(response, env)
+        end
+      else
+        @app.call(env)
+      end
     end
 
-    # We don't want to cache requests for different clients, so append the
-    # oauth token to the cache key.
     def cache_key(env)
-      super(env) + hashed_auth_header(env)
+      url = env[:url].dup
+      if url.query && params_to_ignore.any?
+        params = parse_query url.query
+        params.reject! { |k,| params_to_ignore.include? k }
+        url.query = params.any? ? build_query(params) : nil
+      end
+      url.normalize!
+      digest = full_key? ? url.host + url.request_uri : url.request_uri
+      Digest::SHA1.hexdigest(digest)
     end
 
-    def use_cache?
-      @options[:use_cache]
+    def params_to_ignore
+      @params_to_ignore ||= Array(@options[:ignore_params]).map(&:to_s)
+    end
+
+    def full_key?
+      @full_key ||= @options[:full_key]
     end
 
-    def hashed_auth_header(env)
-      Digest::SHA1.hexdigest(
-        env[:request_headers][Restforce::Middleware::Authorization::AUTH_HEADER]
-      )
+    def custom_status_codes
+      @custom_status_codes ||= begin
+        codes = CACHEABLE_STATUS_CODES & Array(@options[:status_codes]).map(&:to_i)
+        codes.any? ? codes : CACHEABLE_STATUS_CODES
+      end
+    end
+
+    def cache_on_complete(env)
+      key = cache_key(env)
+      if (cached_response = cache.read(key))
+        finalize_response(cached_response, env)
+      else
+        # response.status is nil at this point
+        # any checks need to be done inside on_complete block
+        @app.call(env).on_complete do |response_env|
+          store_response_in_cache(key, response_env.response)
+          response_env
+        end
+      end
+    end
+
+    def store_response_in_cache(key, response)
+      return unless custom_status_codes.include?(response.status)
+
+      if @options[:write_options]
+        cache.write(key, response, @options[:write_options])
+      else
+        cache.write(key, response)
+      end
+    end
+
+    def finalize_response(response, env)
+      response = response.dup if response.frozen?
+      env[:response] = response
+      unless env[:response_headers]
+        env.update response.env
+        # FIXME: omg hax
+        response.instance_variable_set('@env', env)
+      end
+      response
+    end
+
+    # Taken from `Restforce::Middleware::Caching` implementation
+    # before we switched away from the `faraday_middleware` gem.
+    # See https://github.com/restforce/restforce/blob/a08b9d6c5e277bd7111ffa7ed50465dd49c05fab/lib/restforce/middleware/caching.rb.
+    def use_cache?
+      @options[:use_cache]
     end
   end
 end

data/lib/restforce/middleware/json_request.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+#
+# Adapted from `lib/faraday/request/json.rb` in the `faraday`
+# gem (<https://github.com/lostisland/faraday/blob/5366029282968d59980a182258f8c2b0212721c8/lib/faraday/request/json.rb>).
+#
+# We use this because we want to support Faraday 1.x and Faraday 2.x.
+# Faraday 2.x has the JSON middlewares included, but Faraday 1.x doesn't,
+# forcing you to use the `faraday_middleware` gem. This approach allows us
+# to support both.
+#
+# Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+# Licensed under the MIT License.
+#
+require 'json'
+
+module Restforce
+  # Request middleware that encodes the body as JSON.
+  #
+  # Processes only requests with matching Content-type or those without a type.
+  # If a request doesn't have a type but has a body, it sets the Content-type
+  # to JSON MIME-type.
+  #
+  # Doesn't try to encode bodies that already are in string form.
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Middleware::JsonRequest < Faraday::Middleware
+    # rubocop:enable Style/ClassAndModuleChildren
+
+    # This is the only line that differs substantively from the version in
+    # Faraday. In Faraday, this refers to a Faraday constant.
+    CONTENT_TYPE = 'Content-Type'
+
+    MIME_TYPE = 'application/json'
+    MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+
+    #
+    # Taken from `lib/faraday/middleware.rb` in the `faraday`
+    # gem (<https://github.com/lostisland/faraday/blob/08b7d4d/lib/faraday/middleware.rb>),
+    # with a tiny adaptation to refer to the `@app` instance
+    # variable rather than expecting an `attr_reader` to exist.
+    #
+    # In Faraday versions before v1.2.0, `#call`  is missing.
+    #
+    # Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+    # Licensed under the MIT License.
+    #
+    def call(env)
+      on_request(env) if respond_to?(:on_request)
+      @app.call(env).on_complete do |environment|
+        on_complete(environment) if respond_to?(:on_complete)
+      end
+    end
+
+    def on_request(env)
+      match_content_type(env) do |data|
+        env[:body] = encode(data)
+      end
+    end
+
+    private
+
+    def encode(data)
+      ::JSON.generate(data)
+    end
+
+    def match_content_type(env)
+      return unless process_request?(env)
+
+      env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+      yield env[:body] unless env[:body].respond_to?(:to_str)
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
+    end
+
+    def body?(env)
+      (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+    end
+
+    def request_type(env)
+      type = env[:request_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end
+end
+
+Faraday::Request.register_middleware(json: Restforce::Middleware::JsonRequest)

data/lib/restforce/middleware/json_response.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+#
+# Adapted from `lib/faraday/response/json.rb` in the `faraday`
+# gem (<https://github.com/lostisland/faraday/blob/5366029/lib/faraday/response/json.rb>).
+#
+# Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+# Licensed under the MIT License.
+#
+
+require 'json'
+
+module Restforce
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Middleware::JsonResponse < Faraday::Middleware
+    # rubocop:enable Style/ClassAndModuleChildren
+
+    # This is the only line that differs substantively from the version in
+    # Faraday. In Faraday, this refers to a Faraday constant.
+    CONTENT_TYPE = 'Content-Type'
+
+    def initialize(app = nil, parser_options: nil, content_type: /\bjson$/,
+                   preserve_raw: false)
+      super(app)
+      @parser_options = parser_options
+      @content_types = Array(content_type)
+      @preserve_raw = preserve_raw
+    end
+
+    #
+    # Taken from `lib/faraday/middleware.rb` in the `faraday`
+    # gem (<https://github.com/lostisland/faraday/blob/08b7d4d/lib/faraday/middleware.rb>),
+    # with a tiny adaptation to refer to the `@app` instance
+    # variable rather than expecting an `attr_reader` to exist.
+    #
+    # In Faraday versions before v1.2.0, `#call`  is missing.
+    #
+    # Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+    # Licensed under the MIT License.
+    #
+    def call(env)
+      on_request(env) if respond_to?(:on_request)
+      @app.call(env).on_complete do |environment|
+        on_complete(environment) if respond_to?(:on_complete)
+      end
+    end
+
+    def on_complete(env)
+      process_response(env) if parse_response?(env)
+    end
+
+    private
+
+    def process_response(env)
+      env[:raw_body] = env[:body] if @preserve_raw
+      env[:body] = parse(env[:body])
+    rescue StandardError, SyntaxError => e
+      raise Faraday::ParsingError.new(e, env[:response])
+    end
+
+    def parse(body)
+      ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+    end
+
+    def parse_response?(env)
+      process_response_type?(env) &&
+        env[:body].respond_to?(:to_str)
+    end
+
+    def process_response_type?(env)
+      type = response_type(env)
+      @content_types.empty? || @content_types.any? do |pattern|
+        pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
+      end
+    end
+
+    def response_type(env)
+      type = env[:response_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Restforce::Middleware::JsonResponse)