fulfil_api 0.6.3 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5088d4a6e17bfc91b7dbdbd841db0d649bbc7fc16e295fb63a1cf8d4e80436a
-  data.tar.gz: 30f89d00763dde2c6d2b1573ded61440097b87904dae062c7f8ee147de9621e0
+  metadata.gz: 2971bc621921930210bce77c057d6da8ce549cfe476fb1fc29d72f10c4447303
+  data.tar.gz: 97658bf767d8909e359ad66441de0f81108982c6383070778eb04d3386c2fb3d
 SHA512:
-  metadata.gz: 35aa477f5a29a3597d7567bcb8f6708fb89cb13d20c0f848cb06dd46f381bbff94dbddb36bf6fb95d9e544f01c7e94989f44ab872e1ed891f5ea254dfa358727
-  data.tar.gz: de45ced7efb091fc5cfcce224310afab14b233f97197887d94137f2c31007b43b363db424a1478108a8469e1813eeb980a71febe0d4c55f6b6e63d101a57c35b
+  metadata.gz: 020e57b3a676a3c56f2d2b76e5b269010764d3a95f41ef19848f0477e4f77ac9db9871252c68efe77fe35af1fbd6f319d8283f43b578caf7e09e8de4651120a9
+  data.tar.gz: 51af4a10179668acf8977fca9dccfc133bbb25516c7464cb87bd05f9abf0a5926b1631620cf9265a9637b7b0ffa8c7b9a6618bf9ee7b75912005eb3f1722e1a3

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+- Raise a `FulfilApi::HttpError` instead of a generic `FulfilApi::Error` when a request to Fulfil fails, with a dedicated subclass per HTTP status code (e.g. `FulfilApi::HttpError::TooManyRequests` for a 429). The exception message is now the description reported by Fulfil rather than its serialized response body, and the status code, body and headers are available through `#status_code`, `#response_body` and `#response_headers`. `FulfilApi::HttpError` inherits from `FulfilApi::Error`, so existing rescues keep working.
+
+- Re-enable Ruby's built-in retry for idempotent requests on the persistent connection, which the `net_http_persistent` adapter disables by forcing `max_retries` to `0`. This recovers stale keep-alive sockets transparently instead of surfacing them as read timeouts.
+- Add a `connection_options` configuration option to tune the persistent connection (`max_retries`, `idle_timeout`, `pool_size`).
+- `FulfilApi.with_config` now merges the temporary options over the active configuration instead of replacing it, so a block inherits credentials and other unspecified settings rather than resetting them to their defaults.
+
 ## [0.1.0] - 2024-08-10
 
 - Initial release

data/README.md

@@ -41,6 +41,8 @@ end
 
 #### Using a Dynamic Configuration
 
+`with_config` temporarily applies options **on top of the currently active configuration** (per thread) and reverts when the block returns. The options you pass are merged over the active config, so you only need to specify what changes — credentials and other settings are inherited rather than reset to their defaults.
+
 ```ruby
 FulfilApi.with_config(
   access_token: FulfilApi::AccessToken.new(ENV["FULFIL_API_KEY"]),
@@ -50,6 +52,17 @@ FulfilApi.with_config(
 end
 ```
 
+This makes it easy to use different settings in contexts with different constraints. For example, a web request bound by a 30s timeout can keep tight defaults globally, while a background job (which has more time) overrides just the timeouts and retries without re-passing credentials:
+
+```ruby
+FulfilApi.with_config(
+  request_options: { open_timeout: 5, read_timeout: 60, write_timeout: 30 },
+  connection_options: { max_retries: 3, idle_timeout: 10 }
+) do
+  # Long-running work against the Fulfil API
+end
+```
+
 #### Available Configuration Options
 
 The following configuration options are (currently) available throught both configuration methods:
@@ -60,7 +73,16 @@ The following configuration options are (currently) available throught both conf
 
 - `merchant_id` (`String`): The `merchant_id` is the subdomain that the Fulfil instance is hosted on. This configuration option is required to be able to query Fulfil's API endpoints.
 
-- `request_options` (`Hash`): The `request_options` are the configuration options for the HTTP client. See [https://lostisland.github.io/faraday/#/customization/request-options](https://lostisland.github.io/faraday/#/customization/request-options) in `faraday`.
+- `request_options` (`Hash`): The `request_options` are the per-request timeout options for the HTTP client. See [https://lostisland.github.io/faraday/#/customization/request-options](https://lostisland.github.io/faraday/#/customization/request-options) in `faraday`.
+
+> **NOTE:** With the persistent (keep-alive) adapter there is no single whole-request `timeout`; Faraday resolves `read_timeout`, `open_timeout`, and `write_timeout` independently. `read_timeout` is the value that governs a slow or stalled response.
+
+- `connection_options` (`Hash`): Tuning for the persistent (keep-alive) connection. Supported keys:
+  - `max_retries` (default `1`): Re-enables Ruby's built-in retry for **idempotent** requests (`GET`/`HEAD`/`PUT`/`DELETE`/`OPTIONS`). The `net_http_persistent` adapter disables this by forcing it to `0`, which makes a keep-alive socket the server has already dropped surface as a read timeout instead of being retried transparently on a fresh socket. `POST` is never auto-retried, so this is side-effect safe. Set to `0` to restore the adapter's default behaviour.
+  - `idle_timeout` (`Integer`, optional): Seconds a pooled socket may sit idle before it is recycled. Lower this towards your server's keep-alive window to shrink the stale-socket window for non-idempotent requests.
+  - `pool_size` (`Integer`, optional): Maximum number of concurrent connections kept in the pool.
+
+> **NOTE:** When retries are enabled, the worst-case time for a request is roughly `(max_retries + 1) × read_timeout`. On platforms with a hard request cap (e.g. Heroku's 30s router limit), keep `read_timeout` low enough that this product stays under the cap.
 
 ### Querying the Fulfil API
 
@@ -127,6 +149,35 @@ line_items = FulfilApi::Resource.set(model_name: "sale.line").where(["id", "in",
 line_items = FulfilApi::Resource.set(model_name: "sale.line").find_by(["sale.id", "=", 100])
 ```
 
+### Handling Errors
+
+Whenever a request to Fulfil fails, the gem raises a `FulfilApi::HttpError`. Every HTTP status code has its own subclass, named after the status code it represents, so you can rescue the exact failure you care about:
+
+```ruby
+begin
+  FulfilApi::Resource.set(model_name: "sale.sale").find_by(["id", "=", 100])
+rescue FulfilApi::HttpError::TooManyRequests => exception
+  puts exception.message    # => "This user has exceeded an allotted request count. Try again later."
+  puts exception.status_code # => 429
+
+  sleep exception.response_headers["retry-after"].to_i
+  retry
+end
+```
+
+The message is the description reported by Fulfil. The raw response is available through `#response_body`, `#response_headers` and `#status_code`.
+
+To catch anything that went wrong, rescue the base class instead:
+
+```ruby
+rescue FulfilApi::HttpError => exception
+  Rails.logger.error("Fulfil responded with #{exception.status_code}: #{exception.message}")
+```
+
+A request that never reached Fulfil — a connection reset, a DNS failure, a timeout — has no status code to name and raises a `FulfilApi::HttpError` itself.
+
+`FulfilApi::HttpError` inherits from `FulfilApi::Error`, the base class of every error in this gem, so code that already rescues `FulfilApi::Error` keeps working unchanged.
+
 ### Using the 3PL (TPL) Client
 
 The gem also includes a client for Fulfil's [3PL Integration API](https://fulfil-3pl-integration-api.readme.io/reference/getting-started-with-your-api). This is a separate API that allows third-party logistics providers to interact with Fulfil on behalf of a merchant.

data/lib/fulfil_api/client.rb

@@ -109,7 +109,9 @@ module FulfilApi
     # @return [Faraday::Connection]
     def build_connection
       Faraday.new(url: api_endpoint, request: configuration.request_options) do |connection|
-        connection.adapter :net_http_persistent # TODO: Allow passing configuration options
+        connection.adapter(:net_http_persistent, **adapter_options) do |http|
+          configure_persistent_connection(http)
+        end
 
         # Configuration of the request middleware
         connection.request :json
@@ -120,9 +122,40 @@ module FulfilApi
       end
     end
 
+    # Initialization options for the persistent adapter. Only `pool_size` is
+    #   accepted here; `idle_timeout` and `max_retries` are applied to the live
+    #   Net::HTTP::Persistent instance in {#configure_persistent_connection}.
+    #
+    # @return [Hash]
+    def adapter_options
+      options = {}
+      options[:pool_size] = configuration.connection_options[:pool_size] if configuration.connection_options[:pool_size]
+      options
+    end
+
+    # Tunes the underlying Net::HTTP::Persistent connection.
+    #
+    # The `net_http_persistent` adapter forces `max_retries` to 0 on every
+    #   request, which disables Ruby's built-in retry for idempotent requests.
+    #   Restoring it lets a stale keep-alive socket — one the server has already
+    #   closed — be retried transparently on a fresh socket instead of surfacing
+    #   as a read timeout. The config block runs after the adapter zeroes the
+    #   value, so this takes effect.
+    #
+    # @param http [Net::HTTP::Persistent] The live persistent connection.
+    # @return [void]
+    def configure_persistent_connection(http)
+      if configuration.connection_options[:idle_timeout]
+        http.idle_timeout = configuration.connection_options[:idle_timeout]
+      end
+      return if configuration.connection_options[:max_retries].nil?
+
+      http.max_retries = configuration.connection_options[:max_retries]
+    end
+
     # @return [Array] The cache key identifying a unique connection.
     def connection_cache_key
-      [configuration.merchant_id, configuration.request_options]
+      [configuration.merchant_id, configuration.request_options, configuration.connection_options]
     end
 
     # @param relative_path [String] The relative path to the API endpoint.
@@ -134,15 +167,10 @@ module FulfilApi
 
     # @param exception [Faraday::Error] Any error raised by Faraday during the execution
     #   of the HTTP request to the API endpoint.
+    # @raise [FulfilApi::HttpError] The error dedicated to the HTTP status code of the
+    #   response of Fulfil.
     def handle_request_error(exception)
-      raise FulfilApi::Error.new(
-        exception.message,
-        details: {
-          response_body: exception.response_body,
-          response_headers: exception.response_headers,
-          response_status: exception.response_status
-        }
-      )
+      raise FulfilApi::HttpError.from_faraday_error(exception)
     end
 
     # @param method [Symbol, String] The HTTP verb for the HTTP request.

data/lib/fulfil_api/configuration.rb

@@ -7,10 +7,23 @@ module FulfilApi
   #   to these settings.
   class Configuration
     attr_accessor :access_token, :api_version, :merchant_id, :request_options, :tpl
+    attr_reader :connection_options
 
     DEFAULT_API_VERSION = "v2"
     DEFAULT_REQUEST_OPTIONS = { open_timeout: 1, read_timeout: 5, write_timeout: 5, timeout: 5 }.freeze
 
+    # Tuning for the persistent (keep-alive) HTTP connection.
+    #
+    # `max_retries` re-enables Ruby's built-in retry for idempotent requests
+    #   (GET/HEAD/PUT/DELETE/OPTIONS). The `net_http_persistent` adapter forces
+    #   it to 0, which means a keep-alive socket the server has already dropped
+    #   surfaces as a read timeout instead of being transparently retried on a
+    #   fresh socket. POST is never auto-retried, so this is side-effect safe.
+    #
+    # `idle_timeout` and `pool_size` are passed through to the underlying
+    #   Net::HTTP::Persistent connection when set.
+    DEFAULT_CONNECTION_OPTIONS = { max_retries: 1 }.freeze
+
     # Initializes the configuration with optional settings.
     #
     # @param options [Hash, nil] An optional list of configuration options.
@@ -25,6 +38,16 @@ module FulfilApi
       set_default_options
     end
 
+    # Merges the provided connection options over the defaults so that, for
+    #   example, setting only `idle_timeout` still keeps the default
+    #   `max_retries`. Assigning `nil` resets to the defaults.
+    #
+    # @param options [Hash, nil] The connection options to apply.
+    # @return [void]
+    def connection_options=(options)
+      @connection_options = DEFAULT_CONNECTION_OPTIONS.merge(options || {})
+    end
+
     private
 
     # Sets the default options for the gem configuration.
@@ -36,6 +59,7 @@ module FulfilApi
     def set_default_options
       self.api_version = DEFAULT_API_VERSION if api_version.nil?
       self.request_options = DEFAULT_REQUEST_OPTIONS if request_options.nil?
+      self.connection_options = nil if connection_options.nil?
     end
   end
 
@@ -75,15 +99,23 @@ module FulfilApi
       end
   end
 
-  # Temporarily applies the provided configuration options within a block,
-  #   and then reverts to the original configuration after the block executes.
+  # Temporarily applies the provided configuration options on top of the
+  #   currently active configuration, and then reverts after the block executes.
+  #
+  # The temporary options are merged over a copy of the active configuration, so
+  #   a block only needs to specify what it overrides — credentials and other
+  #   settings (`access_token`, `merchant_id`, ...) are inherited rather than
+  #   reset to their defaults.
   #
   # @param temporary_options [Hash] A hash of temporary configuration options.
   # @yield Executes the block with the temporary configuration.
   # @return [void]
   def self.with_config(temporary_options)
-    original_configuration = configuration.dup
-    self.configuration = temporary_options
+    original_configuration = configuration
+
+    self.configuration = original_configuration.dup.tap do |config|
+      temporary_options.each { |key, value| config.public_send(:"#{key}=", value) }
+    end
 
     yield
   ensure

data/lib/fulfil_api/http_error.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  # The {FulfilApi::HttpError} is raised whenever a request to an API endpoint of
+  #   Fulfil fails.
+  #
+  # Every HTTP status code Fulfil can respond with has a dedicated subclass, named
+  #   after the status code it represents. A 429 response raises a
+  #   {FulfilApi::HttpError::TooManyRequests}, a 422 an
+  #   {FulfilApi::HttpError::UnprocessableEntity}, and so on. See {STATUS_CODES} for
+  #   the full list. This lets callers rescue the exact failure they care about
+  #   instead of rescuing everything and inspecting the status code themselves.
+  #
+  # Requests that never reached Fulfil — a connection reset, a DNS failure, a
+  #   timeout — have no status code to name and raise a {FulfilApi::HttpError}.
+  #
+  # @example rescuing one specific HTTP status code
+  #   begin
+  #     FulfilApi::Resource.set(model_name: "sale.sale").find_by(["id", "=", 100])
+  #   rescue FulfilApi::HttpError::TooManyRequests => exception
+  #     sleep exception.response_headers["retry-after"].to_i
+  #     retry
+  #   end
+  #
+  # @example rescuing any failed request
+  #   begin
+  #     FulfilApi::Resource.set(model_name: "sale.sale").find_by(["id", "=", 100])
+  #   rescue FulfilApi::HttpError => exception
+  #     Rails.logger.error("Fulfil responded with #{exception.status_code}: #{exception.message}")
+  #   end
+  #
+  # @note {FulfilApi::HttpError} inherits from {FulfilApi::Error}, so any code that
+  #   already rescues {FulfilApi::Error} keeps catching these exceptions.
+  class HttpError < Error
+    # The keys of an error response of Fulfil that can hold the human readable
+    #   message, in the order they're preferred.
+    #
+    # Fulfil is not consistent in how it reports failures: HTTP level errors carry a
+    #   `description`, application level errors a `message`, and a handful of
+    #   endpoints only return an `error`.
+    MESSAGE_KEYS = %w[description message error].freeze
+
+    # Maps an HTTP status code onto the name of the {FulfilApi::HttpError} subclass
+    #   representing it.
+    STATUS_CODES = {
+      400 => :BadRequest,
+      401 => :Unauthorized,
+      402 => :PaymentRequired,
+      403 => :Forbidden,
+      404 => :NotFound,
+      405 => :MethodNotAllowed,
+      406 => :NotAcceptable,
+      407 => :ProxyAuthenticationRequired,
+      408 => :RequestTimeout,
+      409 => :Conflict,
+      410 => :Gone,
+      411 => :LengthRequired,
+      412 => :PreconditionFailed,
+      413 => :PayloadTooLarge,
+      414 => :UriTooLong,
+      415 => :UnsupportedMediaType,
+      416 => :RangeNotSatisfiable,
+      417 => :ExpectationFailed,
+      418 => :ImATeapot,
+      421 => :MisdirectedRequest,
+      422 => :UnprocessableEntity,
+      423 => :Locked,
+      424 => :FailedDependency,
+      425 => :TooEarly,
+      426 => :UpgradeRequired,
+      428 => :PreconditionRequired,
+      429 => :TooManyRequests,
+      431 => :RequestHeaderFieldsTooLarge,
+      451 => :UnavailableForLegalReasons,
+      500 => :InternalServerError,
+      501 => :NotImplemented,
+      502 => :BadGateway,
+      503 => :ServiceUnavailable,
+      504 => :GatewayTimeout,
+      505 => :HttpVersionNotSupported,
+      506 => :VariantAlsoNegotiates,
+      507 => :InsufficientStorage,
+      508 => :LoopDetected,
+      510 => :NotExtended,
+      511 => :NetworkAuthenticationRequired
+    }.freeze
+
+    # Defines a dedicated exception class for every status code in {STATUS_CODES} and
+    #   indexes them by their status code, so {.for_status_code} can look one up
+    #   without going through {Module#const_get}.
+    CLASSES_BY_STATUS_CODE = STATUS_CODES.transform_values do |class_name|
+      const_set(class_name, Class.new(self))
+    end.freeze
+
+    class << self
+      # Looks up the {FulfilApi::HttpError} subclass representing the given HTTP
+      #   status code.
+      #
+      # @param status_code [Integer, nil] The HTTP status code of the response.
+      # @return [Class<FulfilApi::HttpError>] The subclass for the status code, or
+      #   {FulfilApi::HttpError} itself when the status code is unknown or absent.
+      def for_status_code(status_code)
+        CLASSES_BY_STATUS_CODE.fetch(status_code, HttpError)
+      end
+
+      # Builds the most specific {FulfilApi::HttpError} for the given Faraday exception.
+      #
+      # @param exception [Faraday::Error] Any error raised by Faraday during the
+      #   execution of the HTTP request to the API endpoint.
+      # @return [FulfilApi::HttpError]
+      def from_faraday_error(exception)
+        details = {
+          response_body: exception.response_body,
+          response_headers: exception.response_headers,
+          response_status: exception.response_status
+        }
+
+        for_status_code(exception.response_status).new(
+          message_from(exception.response_body) || exception.message, details: details
+        )
+      end
+
+      private
+
+      # Extracts the human readable error message out of the response body of Fulfil.
+      #
+      # @param response_body [String, Hash, nil] The response body of the API endpoint.
+      # @return [String, nil] The message, or nil when the body holds none. An HTML
+      #   error page and an empty body both yield nil.
+      def message_from(response_body)
+        body = parse(response_body)
+        return if body.nil?
+
+        MESSAGE_KEYS.map { |key| body[key] }.find { |message| message.is_a?(String) && message.present? }
+      end
+
+      # @param response_body [String, Hash, nil] The response body of the API endpoint.
+      # @return [ActiveSupport::HashWithIndifferentAccess, nil]
+      def parse(response_body)
+        return response_body.with_indifferent_access if response_body.is_a?(Hash)
+        return if response_body.blank?
+
+        parsed_body = JSON.parse(response_body)
+        parsed_body.with_indifferent_access if parsed_body.is_a?(Hash)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    # Unlike {FulfilApi::Error}, the message is returned as-is. The name of the
+    #   exception class already tells you what went wrong, so prefixing it only gets
+    #   in the way of the description reported by Fulfil.
+    #
+    # @note {StandardError#message} delegates to {StandardError#to_s}, which still
+    #   holds the message passed to the constructor.
+    #
+    # @return [String]
+    def message
+      to_s
+    end
+
+    # @return [String, Hash, nil] The raw response body of the API endpoint of Fulfil.
+    def response_body
+      details&.dig(:response_body)
+    end
+
+    # @return [Hash, nil] The response headers of the API endpoint of Fulfil.
+    def response_headers
+      details&.dig(:response_headers)
+    end
+
+    # @return [Integer, nil] The HTTP status code of the response, or nil when the
+    #   request never reached Fulfil.
+    def status_code
+      details&.dig(:response_status)
+    end
+  end
+end

data/lib/fulfil_api/relation/batchable.rb

@@ -49,7 +49,7 @@ module FulfilApi
       # @yield [FulfilApi::Relation] Yields FulfilApi::Relation
       #   objects to work with a batch of records.
       # @return [FulfilApi::Relation]
-      def in_batches(of: 500, retries: :unlimited) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def in_batches(of: 500, retries: :unlimited) # rubocop:disable Metrics/MethodLength
         current_retry = 0
         current_offset = request_offset.presence || 0
         batch_size = of
@@ -64,18 +64,14 @@ module FulfilApi
 
           current_offset += 1
           current_retry = 0 # Reset the retries back to the default
-        rescue FulfilApi::Error => e
-          if e.details[:response_status] == 429
-            if retries != :unlimited && current_retry > retries
-              raise RetryLimitExceeded, "the maximum number of #{retries} retries has been reached."
-            end
-
-            current_retry += 1
-            sleep 0.25
-            retry
+        rescue FulfilApi::HttpError::TooManyRequests
+          if retries != :unlimited && current_retry > retries
+            raise RetryLimitExceeded, "the maximum number of #{retries} retries has been reached."
           end
 
-          raise e
+          current_retry += 1
+          sleep 0.25
+          retry
         end
 
         self

data/lib/fulfil_api/tpl_client.rb

@@ -123,11 +123,10 @@ module FulfilApi
     #
     # @return [Faraday::Connection]
     def build_connection
-      Faraday.new(
-        url: api_endpoint,
-        request: configuration.request_options
-      ) do |connection|
-        connection.adapter :net_http_persistent
+      Faraday.new(url: api_endpoint, request: configuration.request_options) do |connection|
+        connection.adapter(:net_http_persistent, **adapter_options) do |http|
+          configure_persistent_connection(http)
+        end
 
         # Configuration of the request middleware
         connection.request :json
@@ -138,9 +137,40 @@ module FulfilApi
       end
     end
 
+    # Initialization options for the persistent adapter. Only `pool_size` is
+    #   accepted here; `idle_timeout` and `max_retries` are applied to the live
+    #   Net::HTTP::Persistent instance in {#configure_persistent_connection}.
+    #
+    # @return [Hash]
+    def adapter_options
+      options = {}
+      options[:pool_size] = configuration.connection_options[:pool_size] if configuration.connection_options[:pool_size]
+      options
+    end
+
+    # Tunes the underlying Net::HTTP::Persistent connection.
+    #
+    # The `net_http_persistent` adapter forces `max_retries` to 0 on every
+    #   request, which disables Ruby's built-in retry for idempotent requests.
+    #   Restoring it lets a stale keep-alive socket — one the server has already
+    #   closed — be retried transparently on a fresh socket instead of surfacing
+    #   as a read timeout. The config block runs after the adapter zeroes the
+    #   value, so this takes effect.
+    #
+    # @param http [Net::HTTP::Persistent] The live persistent connection.
+    # @return [void]
+    def configure_persistent_connection(http)
+      if configuration.connection_options[:idle_timeout]
+        http.idle_timeout = configuration.connection_options[:idle_timeout]
+      end
+      return if configuration.connection_options[:max_retries].nil?
+
+      http.max_retries = configuration.connection_options[:max_retries]
+    end
+
     # @return [Array] The cache key identifying a unique connection.
     def connection_cache_key
-      [merchant_id, api_version, configuration.request_options]
+      [merchant_id, api_version, configuration.request_options, configuration.connection_options]
     end
 
     # @param relative_path [String] The relative path to the API endpoint.
@@ -152,15 +182,10 @@ module FulfilApi
 
     # @param exception [Faraday::Error] Any error raised by Faraday during the execution
     #   of the HTTP request to the API endpoint.
+    # @raise [FulfilApi::HttpError] The error dedicated to the HTTP status code of the
+    #   response of Fulfil.
     def handle_request_error(exception)
-      raise FulfilApi::Error.new(
-        exception.message,
-        details: {
-          response_body: exception.response_body,
-          response_headers: exception.response_headers,
-          response_status: exception.response_status
-        }
-      )
+      raise FulfilApi::HttpError.from_faraday_error(exception)
     end
 
     # @param method [Symbol, String] The HTTP verb for the HTTP request.

data/lib/fulfil_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FulfilApi
-  VERSION = "0.6.3"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fulfil_api
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.1
 platform: ruby
 authors:
 - Stefan Vermaas
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -85,6 +86,7 @@ files:
 - lib/fulfil_api/configuration.rb
 - lib/fulfil_api/customer_shipment.rb
 - lib/fulfil_api/error.rb
+- lib/fulfil_api/http_error.rb
 - lib/fulfil_api/relation.rb
 - lib/fulfil_api/relation/batchable.rb
 - lib/fulfil_api/relation/countable.rb
@@ -111,6 +113,7 @@ metadata:
   source_code_uri: https://www.github.com/codeturebv/fulfil_api
   changelog_uri: https://www.github.com/codeturebv/fulfil_api/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -125,7 +128,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: A HTTP client to interact the Fulfil.io API
 test_files: []