restforce 4.2.1 → 6.0.0

data/lib/restforce/collection.rb

@@ -12,12 +12,12 @@ module Restforce
     end
 
     # Yield each value on each page.
-    def each
+    def each(&block)
       @raw_page['records'].each { |record| yield Restforce::Mash.build(record, @client) }
 
       np = next_page
       while np
-        np.current_page.each { |record| yield record }
+        np.current_page.each(&block)
         np = np.next_page
       end
     end
@@ -27,12 +27,35 @@ module Restforce
       @raw_page['records'].size
     end
 
-    # Return the size of the Collection without making any additional requests.
+    # Return the number of items in the Collection without making any additional
+    # requests and going through all of the pages of results, one by one. Instead,
+    # we can rely on the total count of results which Salesforce returns.
+    #
+    # Most of the Salesforce API returns this in the `totalSize` attribute. For
+    # some reason, the [List View Results](https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/resources_listviewresults.htm)
+    # endpoint (and maybe others?!) uses the `size` attribute.
     def size
-      @raw_page['totalSize']
+      @raw_page['totalSize'] || @raw_page['size']
     end
     alias length size
 
+    def count(*args)
+      # By default, `Enumerable`'s `#count` uses `#each`, which means going through all
+      # of the pages of results, one by one. Instead, we can use `#size` which we have
+      # already overridden to work in a smarter, more efficient way. This only works for
+      # the simple version of `#count` with no arguments. When called with an argument or
+      # a block, you need to know what the items in the collection actually are, so we
+      # call `super` and end up iterating through each item in the collection.
+      return size unless block_given? || !args.empty?
+
+      super
+    end
+
+    # Returns true if the size of the Collection is zero.
+    def empty?
+      size.zero?
+    end
+
     # Return array of the elements on the current page
     def current_page
       first(@raw_page['records'].size)

data/lib/restforce/concerns/api.rb

@@ -380,7 +380,7 @@ module Restforce
             end
           else
             api_patch "sobjects/#{sobject}/#{field}/" \
-              "#{ERB::Util.url_encode(external_id)}", attrs
+                      "#{ERB::Util.url_encode(external_id)}", attrs
           end
 
         response.body.respond_to?(:fetch) ? response.body.fetch('id', true) : true
@@ -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)}"
@@ -510,7 +511,7 @@ module Restforce
 
       # Internal: Errors that should be rescued from in non-bang methods
       def exceptions
-        [Faraday::ClientError]
+        [Faraday::Error]
       end
     end
   end

data/lib/restforce/concerns/base.rb

@@ -61,9 +61,9 @@ module Restforce
       def initialize(opts = {})
         raise ArgumentError, 'Please specify a hash of options' unless opts.is_a?(Hash)
 
-        @options = Hash[Restforce.configuration.options.map do |option|
+        @options = Restforce.configuration.options.to_h do |option|
           [option, Restforce.configuration.send(option)]
-        end]
+        end
 
         @options.merge! opts
         yield builder if block_given?

data/lib/restforce/concerns/caching.rb

@@ -15,6 +15,13 @@ module Restforce
         options.delete(:use_cache)
       end
 
+      def with_caching
+        options[:use_cache] = true
+        yield
+      ensure
+        options[:use_cache] = false
+      end
+
       private
 
       # Internal: Cache to use for the caching middleware

data/lib/restforce/concerns/composite_api.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'restforce/concerns/verbs'
+
+module Restforce
+  module Concerns
+    module CompositeAPI
+      extend Restforce::Concerns::Verbs
+
+      define_verbs :post
+
+      def composite(all_or_none: false, collate_subrequests: false)
+        subrequests = Subrequests.new(options)
+        yield(subrequests)
+
+        if subrequests.requests.length > 25
+          raise ArgumentError, 'Cannot have more than 25 subrequests.'
+        end
+
+        properties = {
+          compositeRequest: subrequests.requests,
+          allOrNone: all_or_none,
+          collateSubrequests: collate_subrequests
+        }
+        response = api_post('composite', properties.to_json)
+
+        results = response.body['compositeResponse']
+        has_errors = results.any? { |result| result['httpStatusCode'].digits.last == 4 }
+        if all_or_none && has_errors
+          last_error_index = results.rindex { |result| result['httpStatusCode'] != 412 }
+          last_error = results[last_error_index]
+          raise CompositeAPIError, last_error['body'][0]['errorCode']
+        end
+
+        results
+      end
+
+      def composite!(collate_subrequests: false, &block)
+        composite(all_or_none: true, collate_subrequests: collate_subrequests, &block)
+      end
+
+      class Subrequests
+        def initialize(options)
+          @options = options
+          @requests = []
+        end
+        attr_reader :options, :requests
+
+        def create(sobject, reference_id, attrs)
+          requests << {
+            method: 'POST',
+            url: composite_api_path(sobject),
+            body: attrs,
+            referenceId: reference_id
+          }
+        end
+
+        def update(sobject, reference_id, attrs)
+          id = attrs.fetch(attrs.keys.find { |k, _v| k.to_s.casecmp?('id') }, nil)
+          raise ArgumentError, 'Id field missing from attrs.' unless id
+
+          attrs_without_id = attrs.reject { |k, _v| k.to_s.casecmp?('id') }
+          requests << {
+            method: 'PATCH',
+            url: composite_api_path("#{sobject}/#{id}"),
+            body: attrs_without_id,
+            referenceId: reference_id
+          }
+        end
+
+        def destroy(sobject, reference_id, id)
+          requests << {
+            method: 'DELETE',
+            url: composite_api_path("#{sobject}/#{id}"),
+            referenceId: reference_id
+          }
+        end
+
+        def upsert(sobject, reference_id, ext_field, attrs)
+          raise ArgumentError, 'External id field missing.' unless ext_field
+
+          ext_id = attrs.fetch(attrs.keys.find do |k, _v|
+            k.to_s.casecmp?(ext_field.to_s)
+          end, nil)
+          raise ArgumentError, 'External id missing from attrs.' unless ext_id
+
+          attrs_without_ext_id = attrs.reject { |k, _v| k.to_s.casecmp?(ext_field) }
+          requests << {
+            method: 'PATCH',
+            url: composite_api_path("#{sobject}/#{ext_field}/#{ext_id}"),
+            body: attrs_without_ext_id,
+            referenceId: reference_id
+          }
+        end
+
+        private
+
+        def composite_api_path(path)
+          "/services/data/v#{options[:api_version]}/sobjects/#{path}"
+        end
+      end
+    end
+  end
+end

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/concerns/picklists.rb

@@ -35,7 +35,7 @@ module Restforce
           @valid_for = options.delete(:valid_for)
           raise "#{field} is not a dependent picklist" if @valid_for && !dependent?
 
-          replace(picklist_values)
+          super(picklist_values)
         end
 
         private
@@ -85,7 +85,7 @@ module Restforce
         def valid?(picklist_entry)
           valid_for = picklist_entry['validFor'].ljust(16, 'A').unpack1('m').
                       unpack('C*')
-          (valid_for[index >> 3] & (0x80 >> index % 8)).positive?
+          (valid_for[index >> 3] & (0x80 >> (index % 8))).positive?
         end
       end
     end

data/lib/restforce/concerns/streaming.rb

@@ -95,9 +95,7 @@ module Restforce
 
         def replay_id(channel)
           handler = @replay_handlers[channel]
-          if handler.is_a?(Integer)
-            handler # treat it as a scalar
-          elsif handler.respond_to?(:[])
+          if handler.respond_to?(:[]) && !handler.is_a?(Integer)
             # Ask for the latest replayId for this channel
             handler[channel]
           else

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
@@ -151,11 +153,14 @@ module Restforce
     option :request_headers
 
     # Set a logger for when Restforce.log is set to true, defaulting to STDOUT
-    option :logger, default: ::Logger.new(STDOUT)
+    option :logger, default: ::Logger.new($stdout)
 
     # Set a log level for logging when Restforce.log is set to true, defaulting to :debug
     option :log_level, default: :debug
 
+    # Set use_cache to false to opt in to caching with client.with_caching
+    option :use_cache, default: true
+
     def options
       self.class.options
     end