orb-billing 0.1.0.pre.alpha.38 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 249d2973800ed2fb6c87fe4e0c7b22208082baef56fa69146ebd6b6eb464fd0f
-  data.tar.gz: e3db0fd166e2f0e698bc3487a9e69d6b0461bdab175a105624f43b4b230c150d
+  metadata.gz: 96cef32525e1e12a5b3d6e1eb8839eceb8aea9e3dddb1b8dc906b4b793bdec35
+  data.tar.gz: 148cb13c2428e83eb8e9dbf6720601ad3b03c90b2b2df73bad9b1d8022dab983
 SHA512:
-  metadata.gz: ce5534719e3cfa2faa48435c2ec0b84910f1f1cfb4e5679c43ae6cbe4d218855479bac17e467d723799ccf1953197a7cfe9a89442f5b904bcb252a66490b9fb8
-  data.tar.gz: fed3c6b0e6311ab74defabad0b7fa99f6b464de6dce1af15f2212e7c4725211eba89aae5fd4747611ebab9b778a5c036a3b7b8a1d808fdf8609f6b2af28869fe
+  metadata.gz: aeb7b0a8da2dc0c3b5134cb979eb60af78bc8ce3dc64fb204da38e40ef7cb5ca0f9eb476eb601dd40fd3b796f2b459a8182b83f1176dd37c68c35d4f7cb3be33
+  data.tar.gz: 87f4b582111e480f15e830a0b537ca205c89d5958b2b3ff4dc275e2c8966805b8e8b804205f5e945636cc7532940f25846dad64411c8110cd0dfc630f3b261fc

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "orb-billing", "~> 0.1.0.pre.alpha.37"
+gem "orb-billing", "~> 0.1.0"
 ```
 
 <!-- x-release-please-end -->
@@ -148,6 +148,13 @@ After Solargraph is installed, **you must populate its index** either via the pr
 bundle exec solargraph gems
 ```
 
+Note: if you had installed the gem either using a `git:` or `github:` URL, or had vendored the gem using bundler, you will need to set up your [`.solargraph.yml`](https://solargraph.org/guides/configuration) to include the path to the gem's `lib` directory.
+
+```yaml
+include:
+  - 'vendor/bundle/ruby/*/gems/orb-billing-*/lib/**/*.rb'
+```
+
 Otherwise Solargraph will not be able to provide type information or auto-completion for any non-indexed libraries.
 
 ### Sorbet
@@ -161,7 +168,8 @@ Due to limitations with the Sorbet type system, where a method otherwise can tak
 Please follow Sorbet's [setup guides](https://sorbet.org/docs/adopting) for best experience.
 
 ```ruby
-params = Orb::Models::CustomerCreateParams.new(email: "example-customer@withorb.com", name: "My Customer")
+params =
+  Orb::Models::CustomerCreateParams.new(email: "example-customer@withorb.com", name: "My Customer")
 
 orb.customers.create(**params)
 ```

data/lib/orb/client.rb

@@ -60,6 +60,9 @@ module Orb
     # @return [Orb::Resources::DimensionalPriceGroups]
     attr_reader :dimensional_price_groups
 
+    # @return [Orb::Resources::SubscriptionChanges]
+    attr_reader :subscription_changes
+
     # @api private
     #
     # @return [Hash{String=>String}]
@@ -124,6 +127,7 @@ module Orb
       @subscriptions = Orb::Resources::Subscriptions.new(client: self)
       @alerts = Orb::Resources::Alerts.new(client: self)
       @dimensional_price_groups = Orb::Resources::DimensionalPriceGroups.new(client: self)
+      @subscription_changes = Orb::Resources::SubscriptionChanges.new(client: self)
     end
   end
 end

data/lib/orb/internal/transport/base_client.rb

@@ -380,7 +380,7 @@ module Orb
           in (400..) | Orb::Errors::APIConnectionError
             self.class.reap_connection!(status, stream: stream)
 
-            delay = retry_delay(response, retry_count: retry_count)
+            delay = retry_delay(response || {}, retry_count: retry_count)
             sleep(delay)
 
             send_request(
@@ -393,7 +393,7 @@ module Orb
         end
 
         # Execute the request specified by `req`. This is the method that all resource
-        #   methods call into.
+        # methods call into.
         #
         # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: Orb::Internal::Type::Unknown, options: {})
         #

data/lib/orb/internal/transport/pooled_net_requester.rb

@@ -6,7 +6,7 @@ module Orb
       # @api private
       class PooledNetRequester
         # from the golang stdlib
-        #   https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+        # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
         KEEP_ALIVE_TIMEOUT = 30
 
         class << self
@@ -54,7 +54,7 @@ module Orb
           # @param blk [Proc]
           #
           # @yieldparam [String]
-          # @return [Net::HTTPGenericRequest]
+          # @return [Array(Net::HTTPGenericRequest, Proc)]
           def build_request(request, &blk)
             method, url, headers, body = request.fetch_values(:method, :url, :headers, :body)
             req = Net::HTTPGenericRequest.new(
@@ -75,12 +75,12 @@ module Orb
             in StringIO
               req["content-length"] ||= body.size.to_s unless req["transfer-encoding"]
               req.body_stream = Orb::Internal::Util::ReadIOAdapter.new(body, &blk)
-            in IO | Enumerator
+            in Pathname | IO | Enumerator
               req["transfer-encoding"] ||= "chunked" unless req["content-length"]
               req.body_stream = Orb::Internal::Util::ReadIOAdapter.new(body, &blk)
             end
 
-            req
+            [req, req.body_stream&.method(:close)]
           end
         end
 
@@ -123,13 +123,17 @@ module Orb
         def execute(request)
           url, deadline = request.fetch_values(:url, :deadline)
 
+          req = nil
           eof = false
           finished = false
+          closing = nil
+
+          # rubocop:disable Metrics/BlockLength
           enum = Enumerator.new do |y|
             with_pool(url, deadline: deadline) do |conn|
               next if finished
 
-              req = self.class.build_request(request) do
+              req, closing = self.class.build_request(request) do
                 self.class.calibrate_socket_timeout(conn, deadline)
               end
 
@@ -154,8 +158,11 @@ module Orb
               end
             end
           rescue Timeout::Error
-            raise Orb::Errors::APITimeoutError
+            raise Orb::Errors::APITimeoutError.new(url: url, request: req)
+          rescue StandardError
+            raise Orb::Errors::APIConnectionError.new(url: url, request: req)
           end
+          # rubocop:enable Metrics/BlockLength
 
           conn, _, response = enum.next
           body = Orb::Internal::Util.fused_enum(enum, external: true) do
@@ -165,7 +172,9 @@ module Orb
             rescue StopIteration
               nil
             end
+          ensure
             conn.finish if !eof && conn&.started?
+            closing&.call
           end
           [Integer(response.code), response, (response.body = body)]
         end

data/lib/orb/internal/type/array_of.rb

@@ -79,10 +79,20 @@ module Orb
         #
         # @param value [Array<Object>, Object]
         #
+        # @param state [Hash{Symbol=>Object}] .
+        #
+        #   @option state [Boolean] :can_retry
+        #
         # @return [Array<Object>, Object]
-        def dump(value)
+        def dump(value, state:)
           target = item_type
-          value.is_a?(Array) ? value.map { Orb::Internal::Type::Converter.dump(target, _1) } : super
+          if value.is_a?(Array)
+            value.map do
+              Orb::Internal::Type::Converter.dump(target, _1, state: state)
+            end
+          else
+            super
+          end
         end
 
         # @api private

data/lib/orb/internal/type/base_model.rb

@@ -19,7 +19,7 @@ module Orb
           # @api private
           #
           # Assumes superclass fields are totally defined before fields are accessed /
-          #   defined on subclasses.
+          # defined on subclasses.
           #
           # @return [Hash{Symbol=>Hash{Symbol=>Object}}]
           def known_fields
@@ -143,7 +143,7 @@ module Orb
           # @api private
           #
           # `request_only` attributes not excluded from `.#coerce` when receiving responses
-          #   even if well behaved servers should not send them
+          # even if well behaved servers should not send them
           #
           # @param blk [Proc]
           private def request_only(&blk)
@@ -252,36 +252,37 @@ module Orb
           #
           # @param value [Orb::Internal::Type::BaseModel, Object]
           #
+          # @param state [Hash{Symbol=>Object}] .
+          #
+          #   @option state [Boolean] :can_retry
+          #
           # @return [Hash{Object=>Object}, Object]
-          def dump(value)
+          def dump(value, state:)
             unless (coerced = Orb::Internal::Util.coerce_hash(value)).is_a?(Hash)
               return super
             end
 
-            is_param = singleton_class <= Orb::Internal::Type::RequestParameters::Converter
             acc = {}
 
             coerced.each do |key, val|
               name = key.is_a?(String) ? key.to_sym : key
               case (field = known_fields[name])
               in nil
-                acc.store(name, super(val))
+                acc.store(name, super(val, state: state))
               else
-                mode, type_fn = field.fetch_values(:mode, :type_fn)
+                api_name, mode, type_fn = field.fetch_values(:api_name, :mode, :type_fn)
                 case mode
                 in :coerce
                   next
                 else
                   target = type_fn.call
-                  api_name = is_param ? name : field.fetch(:api_name)
-                  acc.store(api_name, Orb::Internal::Type::Converter.dump(target, val))
+                  acc.store(api_name, Orb::Internal::Type::Converter.dump(target, val, state: state))
                 end
               end
             end
 
-            known_fields.each do |name, field|
-              mode, const = field.fetch_values(:mode, :const)
-              api_name = is_param ? name : field.fetch(:api_name)
+            known_fields.each_value do |field|
+              api_name, mode, const = field.fetch_values(:api_name, :mode, :const)
               next if mode == :coerce || acc.key?(api_name) || const == Orb::Internal::OMIT
               acc.store(api_name, const)
             end
@@ -291,11 +292,11 @@ module Orb
         end
 
         # Returns the raw value associated with the given key, if found. Otherwise, nil is
-        #   returned.
+        # returned.
         #
-        #   It is valid to lookup keys that are not in the API spec, for example to access
-        #   undocumented features. This method does not parse response data into
-        #   higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
+        # It is valid to lookup keys that are not in the API spec, for example to access
+        # undocumented features. This method does not parse response data into
+        # higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
         #
         # @param key [Symbol]
         #
@@ -310,12 +311,12 @@ module Orb
 
         # Returns a Hash of the data underlying this object. O(1)
         #
-        #   Keys are Symbols and values are the raw values from the response. The return
-        #   value indicates which values were ever set on the object. i.e. there will be a
-        #   key in this hash if they ever were, even if the set value was nil.
+        # Keys are Symbols and values are the raw values from the response. The return
+        # value indicates which values were ever set on the object. i.e. there will be a
+        # key in this hash if they ever were, even if the set value was nil.
         #
-        #   This method is not recursive. The returned value is shared by the object, so it
-        #   should not be mutated.
+        # This method is not recursive. The returned value is shared by the object, so it
+        # should not be mutated.
         #
         # @return [Hash{Symbol=>Object}]
         def to_h = @data
@@ -340,12 +341,12 @@ module Orb
         # @param a [Object]
         #
         # @return [String]
-        def to_json(*a) = self.class.dump(self).to_json(*a)
+        def to_json(*a) = Orb::Internal::Type::Converter.dump(self.class, self).to_json(*a)
 
         # @param a [Object]
         #
         # @return [String]
-        def to_yaml(*a) = self.class.dump(self).to_yaml(*a)
+        def to_yaml(*a) = Orb::Internal::Type::Converter.dump(self.class, self).to_yaml(*a)
 
         # Create a new instance of a model.
         #

data/lib/orb/internal/type/boolean.rb

@@ -45,8 +45,12 @@ module Orb
           #   #
           #   # @param value [Boolean, Object]
           #   #
+          #   # @param state [Hash{Symbol=>Object}] .
+          #   #
+          #   #   @option state [Boolean] :can_retry
+          #   #
           #   # @return [Boolean, Object]
-          #   def dump(value) = super
+          #   def dump(value, state:) = super
         end
       end
     end

data/lib/orb/internal/type/converter.rb

@@ -3,7 +3,6 @@
 module Orb
   module Internal
     module Type
-      # rubocop:disable Metrics/ModuleLength
       # @api private
       module Converter
         # rubocop:disable Lint/UnusedMethodArgument
@@ -27,15 +26,24 @@ module Orb
         #
         # @param value [Object]
         #
+        # @param state [Hash{Symbol=>Object}] .
+        #
+        #   @option state [Boolean] :can_retry
+        #
         # @return [Object]
-        def dump(value)
+        def dump(value, state:)
           case value
           in Array
-            value.map { Orb::Internal::Type::Unknown.dump(_1) }
+            value.map { Orb::Internal::Type::Unknown.dump(_1, state: state) }
           in Hash
-            value.transform_values { Orb::Internal::Type::Unknown.dump(_1) }
+            value.transform_values { Orb::Internal::Type::Unknown.dump(_1, state: state) }
           in Orb::Internal::Type::BaseModel
-            value.class.dump(value)
+            value.class.dump(value, state: state)
+          in StringIO
+            value.string
+          in Pathname | IO
+            state[:can_retry] = false if value.is_a?(IO)
+            Orb::Internal::Util::SerializationAdapter.new(value)
           else
             value
           end
@@ -76,37 +84,37 @@ module Orb
           #
           # Based on `target`, transform `value` into `target`, to the extent possible:
           #
-          #   1. if the given `value` conforms to `target` already, return the given `value`
-          #   2. if it's possible and safe to convert the given `value` to `target`, then the
-          #      converted value
-          #   3. otherwise, the given `value` unaltered
+          # 1. if the given `value` conforms to `target` already, return the given `value`
+          # 2. if it's possible and safe to convert the given `value` to `target`, then the
+          #    converted value
+          # 3. otherwise, the given `value` unaltered
           #
-          #   The coercion process is subject to improvement between minor release versions.
-          #   See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode
+          # The coercion process is subject to improvement between minor release versions.
+          # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode
           #
           # @param target [Orb::Internal::Type::Converter, Class]
           #
           # @param value [Object]
           #
           # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`, or `:strong`. This informs the
-          #   coercion strategy when we have to decide between multiple possible conversion
-          #   targets:
+          # coercion strategy when we have to decide between multiple possible conversion
+          # targets:
           #
-          #   - `true`: the conversion must be exact, with minimum coercion.
-          #   - `false`: the conversion can be approximate, with some coercion.
-          #   - `:strong`: the conversion must be exact, with no coercion, and raise an error
-          #     if not possible.
+          # - `true`: the conversion must be exact, with minimum coercion.
+          # - `false`: the conversion can be approximate, with some coercion.
+          # - `:strong`: the conversion must be exact, with no coercion, and raise an error
+          #   if not possible.
           #
-          #   The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
-          #   any given conversion attempt, the exactness will be updated based on how closely
-          #   the value recursively matches the target type:
+          # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
+          # any given conversion attempt, the exactness will be updated based on how closely
+          # the value recursively matches the target type:
           #
-          #   - `yes`: the value can be converted to the target type with minimum coercion.
-          #   - `maybe`: the value can be converted to the target type with some reasonable
-          #     coercion.
-          #   - `no`: the value cannot be converted to the target type.
+          # - `yes`: the value can be converted to the target type with minimum coercion.
+          # - `maybe`: the value can be converted to the target type with some reasonable
+          #   coercion.
+          # - `no`: the value cannot be converted to the target type.
           #
-          #   See implementation below for more details.
+          # See implementation below for more details.
           #
           #   @option state [Boolean, :strong] :strictness
           #
@@ -141,9 +149,9 @@ module Orb
                 if value.is_a?(Integer)
                   exactness[:yes] += 1
                   return value
-                elsif strictness == :strong
+                elsif strictness == :strong && Integer(value, exception: false) != value
                   message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise TypeError.new(message)
+                  raise value.is_a?(Numeric) ? ArgumentError.new(message) : TypeError.new(message)
                 else
                   Kernel.then do
                     return Integer(value).tap { exactness[:maybe] += 1 }
@@ -183,18 +191,26 @@ module Orb
                 rescue ArgumentError, TypeError => e
                   raise e if strictness == :strong
                 end
-              in -> { _1 <= IO } if value.is_a?(String)
+              in -> { _1 <= StringIO } if value.is_a?(String)
                 exactness[:yes] += 1
                 return StringIO.new(value.b)
               else
               end
             in Symbol
-              if (value.is_a?(Symbol) || value.is_a?(String)) && value.to_sym == target
-                exactness[:yes] += 1
-                return target
-              elsif strictness == :strong
-                message = "cannot convert non-matching #{value.class} into #{target.inspect}"
-                raise ArgumentError.new(message)
+              case value
+              in Symbol | String
+                if value.to_sym == target
+                  exactness[:yes] += 1
+                  return target
+                else
+                  exactness[:maybe] += 1
+                  return value
+                end
+              else
+                if strictness == :strong
+                  message = "cannot convert non-matching #{value.class} into #{target.inspect}"
+                  raise ArgumentError.new(message)
+                end
               end
             else
             end
@@ -208,17 +224,24 @@ module Orb
           # @api private
           #
           # @param target [Orb::Internal::Type::Converter, Class]
+          #
           # @param value [Object]
           #
+          # @param state [Hash{Symbol=>Object}] .
+          #
+          #   @option state [Boolean] :can_retry
+          #
           # @return [Object]
-          def dump(target, value)
-            # rubocop:disable Layout/LineLength
-            target.is_a?(Orb::Internal::Type::Converter) ? target.dump(value) : Orb::Internal::Type::Unknown.dump(value)
-            # rubocop:enable Layout/LineLength
+          def dump(target, value, state: {can_retry: true})
+            case target
+            in Orb::Internal::Type::Converter
+              target.dump(value, state: state)
+            else
+              Orb::Internal::Type::Unknown.dump(value, state: state)
+            end
           end
         end
       end
-      # rubocop:enable Metrics/ModuleLength
     end
   end
 end

data/lib/orb/internal/type/enum.rb

@@ -6,15 +6,15 @@ module Orb
       # @api private
       #
       # A value from among a specified list of options. OpenAPI enum values map to Ruby
-      #   values in the SDK as follows:
+      # values in the SDK as follows:
       #
-      #   1. boolean => true | false
-      #   2. integer => Integer
-      #   3. float => Float
-      #   4. string => Symbol
+      # 1. boolean => true | false
+      # 2. integer => Integer
+      # 3. float => Float
+      # 4. string => Symbol
       #
-      #   We can therefore convert string values to Symbols, but can't convert other
-      #   values safely.
+      # We can therefore convert string values to Symbols, but can't convert other
+      # values safely.
       #
       # @example
       #   # `billing_cycle_relative_date` is a `Orb::Models::BillingCycleRelativeDate`
@@ -66,7 +66,7 @@ module Orb
         # @api private
         #
         # Unlike with primitives, `Enum` additionally validates that the value is a member
-        #   of the enum.
+        # of the enum.
         #
         # @param value [String, Symbol, Object]
         #
@@ -97,8 +97,12 @@ module Orb
         #   #
         #   # @param value [Symbol, Object]
         #   #
+        #   # @param state [Hash{Symbol=>Object}] .
+        #   #
+        #   #   @option state [Boolean] :can_retry
+        #   #
         #   # @return [Symbol, Object]
-        #   def dump(value) = super
+        #   def dump(value, state:) = super
       end
     end
   end

data/lib/orb/internal/type/hash_of.rb

@@ -99,12 +99,16 @@ module Orb
         #
         # @param value [Hash{Object=>Object}, Object]
         #
+        # @param state [Hash{Symbol=>Object}] .
+        #
+        #   @option state [Boolean] :can_retry
+        #
         # @return [Hash{Symbol=>Object}, Object]
-        def dump(value)
+        def dump(value, state:)
           target = item_type
           if value.is_a?(Hash)
             value.transform_values do
-              Orb::Internal::Type::Converter.dump(target, _1)
+              Orb::Internal::Type::Converter.dump(target, _1, state: state)
             end
           else
             super

data/lib/orb/internal/type/io_like.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Orb
+  module Internal
+    module Type
+      # @api private
+      #
+      # @abstract
+      #
+      # Either `Pathname` or `StringIO`.
+      class IOLike
+        extend Orb::Internal::Type::Converter
+
+        # @param other [Object]
+        #
+        # @return [Boolean]
+        def self.===(other)
+          case other
+          in StringIO | Pathname | IO
+            true
+          else
+            false
+          end
+        end
+
+        # @param other [Object]
+        #
+        # @return [Boolean]
+        def self.==(other) = other.is_a?(Class) && other <= Orb::Internal::Type::IOLike
+
+        class << self
+          # @api private
+          #
+          # @param value [StringIO, String, Object]
+          #
+          # @param state [Hash{Symbol=>Object}] .
+          #
+          #   @option state [Boolean, :strong] :strictness
+          #
+          #   @option state [Hash{Symbol=>Object}] :exactness
+          #
+          #   @option state [Integer] :branched
+          #
+          # @return [StringIO, Object]
+          def coerce(value, state:)
+            exactness = state.fetch(:exactness)
+            case value
+            in String
+              exactness[:yes] += 1
+              StringIO.new(value)
+            in StringIO
+              exactness[:yes] += 1
+              value
+            else
+              exactness[:no] += 1
+              value
+            end
+          end
+
+          # @!parse
+          #   # @api private
+          #   #
+          #   # @param value [Pathname, StringIO, IO, String, Object]
+          #   #
+          #   # @param state [Hash{Symbol=>Object}] .
+          #   #
+          #   #   @option state [Boolean] :can_retry
+          #   #
+          #   # @return [Pathname, StringIO, IO, String, Object]
+          #   def dump(value, state:) = super
+        end
+      end
+    end
+  end
+end

data/lib/orb/internal/type/request_parameters.rb

@@ -26,9 +26,18 @@ module Orb
           #
           # @return [Array(Object, Hash{Symbol=>Object})]
           def dump_request(params)
-            case (dumped = dump(params))
+            state = {can_retry: true}
+            case (dumped = dump(params, state: state))
             in Hash
-              [dumped.except(:request_options), dumped[:request_options]]
+              options = Orb::Internal::Util.coerce_hash(dumped[:request_options])
+              request_options =
+                case [options, state.fetch(:can_retry)]
+                in [Hash | nil, false]
+                  {**options.to_h, max_retries: 0}
+                else
+                  options
+                end
+              [dumped.except(:request_options), request_options]
             else
               [dumped, nil]
             end

data/lib/orb/internal/type/union.rb

@@ -205,15 +205,19 @@ module Orb
         #
         # @param value [Object]
         #
+        # @param state [Hash{Symbol=>Object}] .
+        #
+        #   @option state [Boolean] :can_retry
+        #
         # @return [Object]
-        def dump(value)
+        def dump(value, state:)
           if (target = resolve_variant(value))
-            return Orb::Internal::Type::Converter.dump(target, value)
+            return Orb::Internal::Type::Converter.dump(target, value, state: state)
           end
 
           known_variants.each do
             target = _2.call
-            return Orb::Internal::Type::Converter.dump(target, value) if target === value
+            return Orb::Internal::Type::Converter.dump(target, value, state: state) if target === value
           end
 
           super