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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0a5b2b706493559363ab625bd5acbef451386a515a1c473447f7583006750a7
-  data.tar.gz: 392dbe182794cc49819c6bc483e80d2dfc99fe3f96c5148fc644e43e9ffdc917
+  metadata.gz: 96cef32525e1e12a5b3d6e1eb8839eceb8aea9e3dddb1b8dc906b4b793bdec35
+  data.tar.gz: 148cb13c2428e83eb8e9dbf6720601ad3b03c90b2b2df73bad9b1d8022dab983
 SHA512:
-  metadata.gz: d8cecd00cd1de61ce8349e487ec416372c135b5f90ef81d7acc42a0512d6a9b615d10bcdb37f2f334ea5c65cf01a5c31addb775ef116ba43eb880eabe0c0ebe9
-  data.tar.gz: 61a0a748eece61489f3fb1e2c14c99d011505be14d7ed1aa0f1bee41469ae77ab19b8fbaf3f1c19c084b907cdff82afbad9e0bd0c0a0839aeb031a1ef120d7ca
+  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.38"
+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/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(

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

@@ -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

@@ -252,8 +252,12 @@ 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
@@ -264,7 +268,7 @@ module Orb
               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
                 api_name, mode, type_fn = field.fetch_values(:api_name, :mode, :type_fn)
                 case mode
@@ -272,7 +276,7 @@ module Orb
                   next
                 else
                   target = type_fn.call
-                  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
@@ -337,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

@@ -26,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
@@ -140,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 }
@@ -182,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
@@ -207,13 +224,21 @@ 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

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

@@ -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

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

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

data/lib/orb/internal/util.rb

@@ -122,7 +122,7 @@ module Orb
         # @return [Hash{Object=>Object}, Object]
         def coerce_hash(input)
           case input
-          in NilClass | Array | Set | Enumerator
+          in NilClass | Array | Set | Enumerator | StringIO | IO
             input
           else
             input.respond_to?(:to_h) ? input.to_h : input
@@ -348,10 +348,47 @@ module Orb
         end
       end
 
+      # @api private
+      class SerializationAdapter
+        # @return [Pathname, IO]
+        attr_reader :inner
+
+        # @param a [Object]
+        #
+        # @return [String]
+        def to_json(*a) = (inner.is_a?(IO) ? inner.read : inner.read(binmode: true)).to_json(*a)
+
+        # @param a [Object]
+        #
+        # @return [String]
+        def to_yaml(*a) = (inner.is_a?(IO) ? inner.read : inner.read(binmode: true)).to_yaml(*a)
+
+        # @api private
+        #
+        # @param inner [Pathname, IO]
+        def initialize(inner) = @inner = inner
+      end
+
       # @api private
       #
       # An adapter that satisfies the IO interface required by `::IO.copy_stream`
       class ReadIOAdapter
+        # @api private
+        #
+        # @return [Boolean, nil]
+        def close? = @closing
+
+        # @api private
+        def close
+          case @stream
+          in Enumerator
+            Orb::Internal::Util.close_fused!(@stream)
+          in IO if close?
+            @stream.close
+          else
+          end
+        end
+
         # @api private
         #
         # @param max_len [Integer, nil]
@@ -396,12 +433,21 @@ module Orb
 
         # @api private
         #
-        # @param stream [String, IO, StringIO, Enumerable<String>]
+        # @param src [String, Pathname, StringIO, Enumerable<String>]
         # @param blk [Proc]
         #
         # @yieldparam [String]
-        def initialize(stream, &blk)
-          @stream = stream.is_a?(String) ? StringIO.new(stream) : stream
+        def initialize(src, &blk)
+          @stream =
+            case src
+            in String
+              StringIO.new(src)
+            in Pathname
+              @closing = true
+              src.open(binmode: true)
+            else
+              src
+            end
           @buf = String.new.b
           @blk = blk
         end
@@ -414,9 +460,10 @@ module Orb
         # @return [Enumerable<String>]
         def writable_enum(&blk)
           Enumerator.new do |y|
+            buf = String.new.b
             y.define_singleton_method(:write) do
-              self << _1.clone
-              _1.bytesize
+              self << buf.replace(_1)
+              buf.bytesize
             end
 
             blk.call(y)
@@ -431,29 +478,39 @@ module Orb
         # @param boundary [String]
         # @param key [Symbol, String]
         # @param val [Object]
-        private def write_multipart_chunk(y, boundary:, key:, val:)
+        # @param closing [Array<Proc>]
+        private def write_multipart_chunk(y, boundary:, key:, val:, closing:)
+          val = val.inner if val.is_a?(Orb::Internal::Util::SerializationAdapter)
+
           y << "--#{boundary}\r\n"
           y << "Content-Disposition: form-data"
           unless key.nil?
             name = ERB::Util.url_encode(key.to_s)
             y << "; name=\"#{name}\""
           end
-          if val.is_a?(IO)
+          case val
+          in Pathname | IO
             filename = ERB::Util.url_encode(File.basename(val.to_path))
             y << "; filename=\"#{filename}\""
+          else
           end
           y << "\r\n"
           case val
+          in Pathname
+            y << "Content-Type: application/octet-stream\r\n\r\n"
+            io = val.open(binmode: true)
+            closing << io.method(:close)
+            IO.copy_stream(io, y)
           in IO
             y << "Content-Type: application/octet-stream\r\n\r\n"
-            IO.copy_stream(val.tap(&:rewind), y)
+            IO.copy_stream(val, y)
           in StringIO
             y << "Content-Type: application/octet-stream\r\n\r\n"
             y << val.string
           in String
             y << "Content-Type: application/octet-stream\r\n\r\n"
             y << val.to_s
-          in true | false | Integer | Float | Symbol
+          in _ if primitive?(val)
             y << "Content-Type: text/plain\r\n\r\n"
             y << val.to_s
           else
@@ -471,6 +528,7 @@ module Orb
         private def encode_multipart_streaming(body)
           boundary = SecureRandom.urlsafe_base64(60)
 
+          closing = []
           strio = writable_enum do |y|
             case body
             in Hash
@@ -478,19 +536,20 @@ module Orb
                 case val
                 in Array if val.all? { primitive?(_1) }
                   val.each do |v|
-                    write_multipart_chunk(y, boundary: boundary, key: key, val: v)
+                    write_multipart_chunk(y, boundary: boundary, key: key, val: v, closing: closing)
                   end
                 else
-                  write_multipart_chunk(y, boundary: boundary, key: key, val: val)
+                  write_multipart_chunk(y, boundary: boundary, key: key, val: val, closing: closing)
                 end
               end
             else
-              write_multipart_chunk(y, boundary: boundary, key: nil, val: body)
+              write_multipart_chunk(y, boundary: boundary, key: nil, val: body, closing: closing)
             end
             y << "--#{boundary}--\r\n"
           end
 
-          [boundary, strio]
+          fused_io = fused_enum(strio) { closing.each(&:call) }
+          [boundary, fused_io]
         end
 
         # @api private
@@ -501,21 +560,21 @@ module Orb
         # @return [Object]
         def encode_content(headers, body)
           content_type = headers["content-type"]
+          body = body.inner if body.is_a?(Orb::Internal::Util::SerializationAdapter)
+
           case [content_type, body]
-          in [%r{^application/(?:vnd\.api\+)?json}, _] unless body.nil?
+          in [%r{^application/(?:vnd\.api\+)?json}, Hash | Array | -> { primitive?(_1) }]
             [headers, JSON.fast_generate(body)]
-          in [%r{^application/(?:x-)?jsonl}, Enumerable]
+          in [%r{^application/(?:x-)?jsonl}, Enumerable] unless body.is_a?(StringIO) || body.is_a?(IO)
             [headers, body.lazy.map { JSON.fast_generate(_1) }]
-          in [%r{^multipart/form-data}, Hash | IO | StringIO]
+          in [%r{^multipart/form-data}, Hash | Pathname | StringIO | IO]
             boundary, strio = encode_multipart_streaming(body)
             headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"}
             [headers, strio]
-          in [_, IO]
-            [headers, body.tap(&:rewind)]
-          in [_, StringIO]
-            [headers, body.string]
           in [_, Symbol | Numeric]
             [headers, body.to_s]
+          in [_, StringIO]
+            [headers, body.string]
           else
             [headers, body]
           end