hive_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07111f77209d4cbfd69880e122f8d2972210928e22a11165a9522218ed389bca
+  data.tar.gz: 184d9565e9976454e373ec36e6d881377864a72616245827fd3a94ec463151e4
+SHA512:
+  metadata.gz: 5725404f0d899889a8cf46a0375df662434906b39d1c4fe7e89407ec4b96b63fc8199b20c4d3a56871575b2e69f9ed0ecd49e68ffd5974c530825bf0095ca77d
+  data.tar.gz: 0adf09a3cd8ef6ea8db79c9cbc833966533c39f03bfbd70fe5a36644d9db2c078ef0f516bfc20fbe622e4b079d3cc242e68fe90f2ceb106ff8877e59353dbb3c

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-15
+
+### Added
+
+- Rails-independent Hive API client foundation with fixed production and staging environments, defaulting safely to staging.
+- Bounded Faraday connections with injectable adapters and safe JSON middleware.
+- Shared resource and response-object foundations.
+- Merchant-scoped bearer authentication and typed, credential-safe API errors.
+- Hive rate-limit metadata and transport-error wrapping without automatic retries or logging.
+- Return rules, paginated return listing, safe explicit page traversal, and individual return retrieval.
+- Immutable, dedicated return response objects with deeply frozen provider evidence.
+
+### Out of scope
+
+- Webhook handling, automatic polling, retries, caching, persistence, and business workflows remain caller-owned.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 PostCo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,161 @@
+# HiveAPI
+
+Rails-independent Ruby client for the [Hive Merchant API](https://developers.hive.app/).
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem "hive_api", "~> 0.1.0"
+```
+
+Then run `bundle install`.
+
+## Usage
+
+### Initialize a client
+
+Require the gem and build a client. It defaults to Hive's staging API:
+
+```ruby
+require "hive_api"
+
+client = HiveAPI::Client.new(
+  api_token: ENV.fetch("HIVE_API_TOKEN"),
+  sandbox: true # Staging (the default)
+)
+
+# Select production explicitly:
+production_client = HiveAPI::Client.new(
+  api_token: ENV.fetch("HIVE_API_TOKEN"),
+  sandbox: false
+)
+```
+
+The client does not accept a custom base URL and it does not use global configuration. Connections use bounded connect and request timeouts, defaulting to 5 and 15 seconds respectively:
+
+```ruby
+HiveAPI::Client.new(
+  api_token: ENV.fetch("HIVE_API_TOKEN"),
+  sandbox: true,
+  open_timeout: 2,
+  timeout: 10
+)
+```
+
+Every request sends the API token as a bearer credential in the `Authorization` header. The gem
+does not acquire, refresh, rotate, log, or retry credentials or requests automatically.
+
+### Response objects
+
+Response objects expose provider keys as snake-case Ruby methods, including nested hashes and arrays. The original provider payload remains available as a deeply frozen snapshot through `raw`, while `to_h` returns plain recursive hashes and arrays.
+
+```ruby
+response = HiveAPI::Base.new(
+  "returnId" => "return-123",
+  "lineItems" => [{"merchantSKU" => "SKU-1"}]
+)
+
+response.return_id                     # => "return-123"
+response.line_items.first.merchant_sku # => "SKU-1"
+response.raw.frozen?                   # => true
+response.to_h                          # => {"return_id" => "return-123", ...}
+```
+
+### Returns
+
+The client exposes Hive's return rules and returns without applying merchant policy or traversing
+pages automatically:
+
+```ruby
+# GET /return_rules
+rules = client.return_rules.get
+rules.send_back_address.postal_code
+rules.default_rules.a
+rules.sku_rules.first.sku.sku_code
+
+# GET /returns
+page = client.returns.list(
+  sales_channel_id_in: [101, 202],
+  created_at_gt: "2026-09-01T00:00:00Z",
+  created_at_lt: "2026-10-01T00:00:00Z",
+  created_at_gte: "2026-09-02T00:00:00Z",
+  created_at_lte: "2026-09-30T23:59:59Z",
+  limit: 50
+)
+
+page.data.each do |hive_return|
+  hive_return.order.merchant_order_id
+  hive_return.announced_items
+  hive_return.handled_items
+end
+
+# GET /returns/{id}
+hive_return = client.returns.find(id: 5555)
+```
+
+`sales_channel_id_in:` accepts either an array or a comma-separated value. The timestamp filters
+are passed to Hive unchanged, so callers should provide ISO 8601 values with an explicit timezone.
+Nil filters are omitted.
+
+List responses expose `pagination.first_page_url`, `pagination.limit`, and
+`pagination.next_page_url`. Fetch another page explicitly when Hive provides one:
+
+```ruby
+next_page = client.returns.list_page(url: page.pagination.next_page_url)
+```
+
+`list_page` only follows URLs on the client's selected Hive environment and exact Returns path.
+All response objects are immutable and retain their deeply frozen provider payload through `raw`.
+
+### Error handling
+
+Unsuccessful responses raise a typed `HiveAPI::Error` subclass:
+
+```ruby
+begin
+  client.returns.find(id: 5555)
+rescue HiveAPI::AuthenticationError => error
+  # 401/403 responses
+  puts error.status_code
+rescue HiveAPI::ValidationError => error
+  # 400 responses
+  puts error.status_code
+rescue HiveAPI::NotFoundError => error
+  # 404 responses
+  puts error.status_code
+rescue HiveAPI::RateLimitError => error
+  # 429 responses
+  puts error.retry_after
+rescue HiveAPI::ServerError => error
+  # 500-599 responses
+  puts error.status_code
+rescue HiveAPI::APIError => error
+  # Other HTTP responses and transport failures
+  warn error.message
+end
+```
+
+Errors expose the HTTP status and Hive's `X-Rate-Limit-Used`, `X-Rate-Limit-Max`, and
+`Retry-After` metadata when present. Transport failures retain the original Faraday exception as
+their cause. Error messages redact bearer credentials and the configured token.
+
+### Caller responsibilities
+
+This gem is deliberately a thin API client. Webhook handling, automatic polling, retries, caching,
+persistence, and business workflows remain caller-owned. In particular, callers decide when and
+how to traverse subsequent pages; the gem never retries or polls automatically.
+
+## Development
+
+```sh
+bundle install
+bundle exec rspec
+bundle exec standardrb
+gem build hive_api.gemspec
+```
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/lib/hive_api/client.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module HiveAPI
+  class Client
+    LIVE_BASE_URL = "https://app.hive.app/merchant_api/v2/"
+    TEST_BASE_URL = "https://staging.app.hive.app/merchant_api/v2/"
+    DEFAULT_OPEN_TIMEOUT = 5
+    DEFAULT_TIMEOUT = 15
+
+    attr_reader :adapter, :api_token, :open_timeout, :timeout
+
+    def initialize(api_token:, sandbox: true, adapter: Faraday.default_adapter,
+      open_timeout: DEFAULT_OPEN_TIMEOUT, timeout: DEFAULT_TIMEOUT)
+      validate_api_token!(api_token)
+
+      @api_token = api_token
+      @sandbox = sandbox
+      @adapter = adapter
+      @open_timeout = open_timeout
+      @timeout = timeout
+    end
+
+    def connection
+      @connection ||= Faraday.new do |connection|
+        connection.url_prefix = sandbox? ? TEST_BASE_URL : LIVE_BASE_URL
+        connection.options.open_timeout = open_timeout
+        connection.options.timeout = timeout
+        connection.headers["Authorization"] = "Bearer #{api_token}"
+        connection.headers["Accept"] = "application/json"
+        connection.request :json
+        connection.response :json, content_type: /\bjson/
+        connection.adapter adapter
+      end
+    end
+
+    def return_rules
+      @return_rules ||= ReturnRulesResource.new(self)
+    end
+
+    def returns
+      @returns ||= ReturnsResource.new(self)
+    end
+
+    private
+
+    def validate_api_token!(api_token)
+      return if api_token.is_a?(String) && !api_token.strip.empty?
+
+      raise ArgumentError, "api_token must be a non-empty String"
+    end
+
+    def sandbox?
+      @sandbox
+    end
+  end
+end

data/lib/hive_api/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  class Error < StandardError
+    attr_reader :response, :status_code, :rate_limit_used, :rate_limit_max, :retry_after
+
+    def initialize(message = nil, response: nil, status_code: nil, rate_limit_used: nil,
+      rate_limit_max: nil, retry_after: nil)
+      super(message)
+      @response = response
+      @status_code = status_code
+      @rate_limit_used = rate_limit_used
+      @rate_limit_max = rate_limit_max
+      @retry_after = retry_after
+    end
+  end
+
+  class APIError < Error; end
+
+  class AuthenticationError < Error; end
+
+  class ValidationError < Error; end
+
+  class NotFoundError < Error; end
+
+  class RateLimitError < Error; end
+
+  class ServerError < Error; end
+end

data/lib/hive_api/object.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "active_support/core_ext/string/inflections"
+
+module HiveAPI
+  class Base < OpenStruct
+    attr_reader :original_response
+
+    def self.new(attributes)
+      return attributes.map { |item| super(item) }.freeze if attributes.is_a?(Array)
+
+      super
+    end
+
+    def initialize(attributes)
+      @original_response = deep_freeze(attributes)
+      super(to_ostruct(attributes))
+      freeze
+    end
+
+    def to_hash
+      ostruct_to_hash(self)
+    end
+
+    alias_method :to_h, :to_hash
+
+    def raw
+      @original_response
+    end
+
+    private
+
+    def to_ostruct(object, key: nil)
+      case object
+      when Hash
+        object_class = nested_object_class(key)
+        return object_class.new(object) if object_class
+
+        OpenStruct.new(
+          object.transform_keys { |key| key.to_s.underscore }
+            .to_h { |nested_key, value| [nested_key, to_ostruct(value, key: nested_key)] }
+        ).freeze
+      when Array
+        object.map { |value| to_ostruct(value, key: key) }.freeze
+      else
+        object.respond_to?(:freeze) ? object.freeze : object
+      end
+    end
+
+    def nested_object_class(_key)
+      nil
+    end
+
+    def deep_freeze(object)
+      case object
+      when Hash then object.transform_values { |value| deep_freeze(value) }.freeze
+      when Array then object.map { |item| deep_freeze(item) }.freeze
+      else object.respond_to?(:freeze) ? object.freeze : object
+      end
+    end
+
+    def ostruct_to_hash(object)
+      case object
+      when OpenStruct
+        object.each_pair.to_h
+          .transform_keys(&:to_s)
+          .transform_values { |value| ostruct_to_hash(value) }
+      when Array
+        object.map { |value| ostruct_to_hash(value) }
+      when Hash
+        object.transform_keys(&:to_s)
+          .transform_values { |value| ostruct_to_hash(value) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/hive_api/objects/pagination_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  module Objects
+    class PaginationResponse < Base; end
+  end
+end

data/lib/hive_api/objects/return_list_response.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  module Objects
+    class ReturnListResponse < Base
+      private
+
+      def nested_object_class(key)
+        case key.to_s
+        when "data" then ReturnResponse
+        when "pagination" then PaginationResponse
+        end
+      end
+    end
+  end
+end

data/lib/hive_api/objects/return_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  module Objects
+    class ReturnResponse < Base; end
+  end
+end

data/lib/hive_api/objects/return_rules_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  module Objects
+    class ReturnRulesResponse < Base; end
+  end
+end

data/lib/hive_api/resource.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "json"
+
+module HiveAPI
+  class Resource
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    def get_request(path, params: {}, headers: {})
+      handle_response(client.connection.get(path, params, headers))
+    rescue Faraday::Error => error
+      raise_transport_error(error)
+    end
+
+    def post_request(path, body:, headers: {})
+      handle_response(client.connection.post(path, body, headers))
+    rescue Faraday::Error => error
+      raise_transport_error(error)
+    end
+
+    def handle_response(response)
+      body = parse_body(response.body)
+      return body if response.status.between?(200, 299)
+
+      error_class, prefix = error_mapping(response.status)
+      message = "#{prefix} (HTTP #{response.status}): #{extract_error_message(body)}"
+      raise error_class.new(
+        message,
+        response: response,
+        status_code: response.status,
+        rate_limit_used: numeric_header(response, "x-rate-limit-used"),
+        rate_limit_max: numeric_header(response, "x-rate-limit-max"),
+        retry_after: numeric_header(response, "retry-after")
+      )
+    end
+
+    def parse_body(body)
+      return body unless body.is_a?(String)
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      body
+    end
+
+    def extract_error_message(body)
+      message = case body
+      when Hash
+        approved_error_message(body)
+      when String
+        body
+      end
+
+      redact_credentials(message || "Unknown error")
+    end
+
+    def approved_error_message(body)
+      [body["message"], body[:message], body["error"], body[:error]]
+        .find { |value| value.is_a?(String) } || errors_message(body)
+    end
+
+    def errors_message(body)
+      errors = body["errors"] || body[:errors]
+      return errors if errors.is_a?(String)
+      return unless errors.is_a?(Array)
+
+      messages = errors.select { |error| error.is_a?(String) }
+      messages.join(", ") unless messages.empty?
+    end
+
+    def redact_credentials(message)
+      redacted = message.dup
+      redacted.gsub!(/\bAuthorization\s*:\s*[^,;]+/i, "[REDACTED]")
+      redacted.gsub!(/\bBearer\s+[^\s,;]+/i, "[REDACTED]")
+      redacted.gsub!(client.api_token, "[REDACTED]")
+      redacted
+    end
+
+    def error_mapping(status)
+      case status
+      when 400 then [ValidationError, "Bad request"]
+      when 401, 403 then [AuthenticationError, "Authentication failed"]
+      when 404 then [NotFoundError, "Resource not found"]
+      when 429 then [RateLimitError, "Rate limited"]
+      when 500..599 then [ServerError, "Server error"]
+      else [APIError, "API error"]
+      end
+    end
+
+    def numeric_header(response, name)
+      value = response.headers[name]
+      return if value.nil?
+
+      Integer(value, exception: false) || Float(value, exception: false)
+    end
+
+    def raise_transport_error(error)
+      wrapped_error = APIError.new(
+        "Network request failed",
+        response: error.response,
+        status_code: error.response_status
+      )
+      raise wrapped_error, cause: error
+    end
+  end
+end

data/lib/hive_api/resources/return_rules_resource.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  class ReturnRulesResource < Resource
+    def get
+      Objects::ReturnRulesResponse.new(get_request("return_rules"))
+    end
+  end
+end

data/lib/hive_api/resources/returns_resource.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module HiveAPI
+  class ReturnsResource < Resource
+    INVALID_PAGE_URL_MESSAGE = "url must be a Returns page URL for the selected Hive environment"
+
+    def list(
+      sales_channel_id_in: nil,
+      created_at_gt: nil,
+      created_at_lt: nil,
+      created_at_gte: nil,
+      created_at_lte: nil,
+      limit: nil
+    )
+      params = {
+        "sales_channel_id[in]" => serialize_sales_channel_ids(sales_channel_id_in),
+        "created_at[gt]" => created_at_gt,
+        "created_at[lt]" => created_at_lt,
+        "created_at[gte]" => created_at_gte,
+        "created_at[lte]" => created_at_lte,
+        "limit" => limit
+      }.compact
+
+      build_list_response(get_request("returns", params: params))
+    end
+
+    def list_page(url:)
+      validate_page_url!(url)
+      build_list_response(get_request(url))
+    end
+
+    def find(id:)
+      Objects::ReturnResponse.new(get_request("returns/#{id}"))
+    end
+
+    private
+
+    def build_list_response(data)
+      Objects::ReturnListResponse.new(data)
+    end
+
+    def serialize_sales_channel_ids(value)
+      value.is_a?(Array) ? value.join(",") : value
+    end
+
+    def validate_page_url!(url)
+      page_uri = URI.parse(url)
+      base_uri = URI.parse(client.connection.url_prefix.to_s)
+      returns_path = URI.join(base_uri.to_s, "returns").path
+
+      valid = url.is_a?(String) &&
+        page_uri.absolute? &&
+        page_uri.userinfo.nil? &&
+        page_uri.fragment.nil? &&
+        page_uri.scheme == base_uri.scheme &&
+        page_uri.host == base_uri.host &&
+        page_uri.port == base_uri.port &&
+        page_uri.path == returns_path
+
+      raise ArgumentError, INVALID_PAGE_URL_MESSAGE unless valid
+    rescue URI::Error, TypeError
+      raise ArgumentError, INVALID_PAGE_URL_MESSAGE
+    end
+  end
+end

data/lib/hive_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HiveAPI
+  VERSION = "0.1.0"
+end

data/lib/hive_api.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "hive_api/version"
+
+module HiveAPI
+  autoload :Client, "hive_api/client"
+  autoload :Base, "hive_api/object"
+  autoload :Resource, "hive_api/resource"
+  autoload :Error, "hive_api/errors"
+  autoload :APIError, "hive_api/errors"
+  autoload :AuthenticationError, "hive_api/errors"
+  autoload :ValidationError, "hive_api/errors"
+  autoload :NotFoundError, "hive_api/errors"
+  autoload :RateLimitError, "hive_api/errors"
+  autoload :ServerError, "hive_api/errors"
+  autoload :ReturnRulesResource, "hive_api/resources/return_rules_resource"
+  autoload :ReturnsResource, "hive_api/resources/returns_resource"
+
+  module Objects
+    autoload :PaginationResponse, "hive_api/objects/pagination_response"
+    autoload :ReturnListResponse, "hive_api/objects/return_list_response"
+    autoload :ReturnResponse, "hive_api/objects/return_response"
+    autoload :ReturnRulesResponse, "hive_api/objects/return_rules_response"
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: hive_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- PostCo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small Ruby client foundation for integrating with Hive without depending
+  on Rails.
+email:
+- engineering@postco.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/hive_api.rb
+- lib/hive_api/client.rb
+- lib/hive_api/errors.rb
+- lib/hive_api/object.rb
+- lib/hive_api/objects/pagination_response.rb
+- lib/hive_api/objects/return_list_response.rb
+- lib/hive_api/objects/return_response.rb
+- lib/hive_api/objects/return_rules_response.rb
+- lib/hive_api/resource.rb
+- lib/hive_api/resources/return_rules_resource.rb
+- lib/hive_api/resources/returns_resource.rb
+- lib/hive_api/version.rb
+homepage: https://github.com/PostCo/hive_api
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/PostCo/hive_api
+  changelog_uri: https://github.com/PostCo/hive_api/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Rails-independent Ruby client for the Hive Merchant API
+test_files: []