modern_treasury 0.1.0.pre.alpha.17 → 0.1.0.pre.alpha.19

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

@@ -7,6 +7,8 @@ module ModernTreasury
       #
       # @abstract
       class BaseClient
+        extend ModernTreasury::Internal::Util::SorbetRuntimeSupport
+
         # from whatwg fetch spec
         MAX_REDIRECTS = 20
 
@@ -93,7 +95,11 @@ module ModernTreasury
                 URI.join(url, response_headers["location"])
               rescue ArgumentError
                 message = "Server responded with status #{status} but no valid location header."
-                raise ModernTreasury::Errors::APIConnectionError.new(url: url, message: message)
+                raise ModernTreasury::Errors::APIConnectionError.new(
+                  url: url,
+                  response: response_headers,
+                  message: message
+                )
               end
 
             request = {**request, url: location}
@@ -101,7 +107,11 @@ module ModernTreasury
             case [url.scheme, location.scheme]
             in ["https", "http"]
               message = "Tried to redirect to a insecure URL"
-              raise ModernTreasury::Errors::APIConnectionError.new(url: url, message: message)
+              raise ModernTreasury::Errors::APIConnectionError.new(
+                url: url,
+                response: response_headers,
+                message: message
+              )
             else
               nil
             end
@@ -143,9 +153,30 @@ module ModernTreasury
           end
         end
 
+        # @return [URI::Generic]
+        attr_reader :base_url
+
+        # @return [Float]
+        attr_reader :timeout
+
+        # @return [Integer]
+        attr_reader :max_retries
+
+        # @return [Float]
+        attr_reader :initial_retry_delay
+
+        # @return [Float]
+        attr_reader :max_retry_delay
+
+        # @return [Hash{String=>String}]
+        attr_reader :headers
+
+        # @return [String, nil]
+        attr_reader :idempotency_header
+
         # @api private
         # @return [ModernTreasury::Internal::Transport::PooledNetRequester]
-        attr_accessor :requester
+        attr_reader :requester
 
         # @api private
         #
@@ -174,10 +205,11 @@ module ModernTreasury
             },
             headers
           )
-          @base_url = ModernTreasury::Internal::Util.parse_uri(base_url)
+          @base_url_components = ModernTreasury::Internal::Util.parse_uri(base_url)
+          @base_url = ModernTreasury::Internal::Util.unparse_uri(@base_url_components)
           @idempotency_header = idempotency_header&.to_s&.downcase
-          @max_retries = max_retries
           @timeout = timeout
+          @max_retries = max_retries
           @initial_retry_delay = initial_retry_delay
           @max_retry_delay = max_retry_delay
         end
@@ -206,11 +238,11 @@ module ModernTreasury
         #
         #   @option req [Object, nil] :body
         #
-        #   @option req [Symbol, nil] :unwrap
+        #   @option req [Symbol, Integer, Array<Symbol, Integer>, Proc, nil] :unwrap
         #
-        #   @option req [Class, nil] :page
+        #   @option req [Class<ModernTreasury::Internal::Type::BasePage>, nil] :page
         #
-        #   @option req [Class, nil] :stream
+        #   @option req [Class<ModernTreasury::Internal::Type::BaseStream>, nil] :stream
         #
         #   @option req [ModernTreasury::Internal::Type::Converter, Class, nil] :model
         #
@@ -245,7 +277,7 @@ module ModernTreasury
 
           if @idempotency_header &&
              !headers.key?(@idempotency_header) &&
-             !Net::HTTP::IDEMPOTENT_METHODS_.include?(method.to_s.upcase)
+             (%w[POST PUT].include?(method.to_s.upcase) || opts.key?(:idempotency_key))
             headers[@idempotency_header] = opts.fetch(:idempotency_key) { generate_idempotency_key }
           end
 
@@ -253,7 +285,7 @@ module ModernTreasury
             headers["x-stainless-retry-count"] = "0"
           end
 
-          timeout = opts.fetch(:timeout, @timeout).to_f.clamp((0..))
+          timeout = opts.fetch(:timeout, @timeout).to_f.clamp(0..)
           unless headers.key?("x-stainless-timeout") || timeout.zero?
             headers["x-stainless-timeout"] = timeout.to_s
           end
@@ -268,10 +300,14 @@ module ModernTreasury
               ModernTreasury::Internal::Util.deep_merge(*[req[:body], opts[:extra_body]].compact)
             end
 
+          url = ModernTreasury::Internal::Util.join_parsed_uri(
+            @base_url_components,
+            {**req, path: path, query: query}
+          )
           headers, encoded = ModernTreasury::Internal::Util.encode_content(headers, body)
           {
             method: method,
-            url: ModernTreasury::Internal::Util.join_parsed_uri(@base_url, {**req, path: path, query: query}),
+            url: url,
             headers: headers,
             body: encoded,
             max_retries: opts.fetch(:max_retries, @max_retries),
@@ -353,7 +389,11 @@ module ModernTreasury
             self.class.reap_connection!(status, stream: stream)
 
             message = "Failed to complete the request within #{self.class::MAX_REDIRECTS} redirects."
-            raise ModernTreasury::Errors::APIConnectionError.new(url: url, message: message)
+            raise ModernTreasury::Errors::APIConnectionError.new(
+              url: url,
+              response: response,
+              message: message
+            )
           in 300..399
             self.class.reap_connection!(status, stream: stream)
 
@@ -383,7 +423,7 @@ module ModernTreasury
           in (400..) | ModernTreasury::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(
@@ -410,11 +450,11 @@ module ModernTreasury
         #
         # @param body [Object, nil]
         #
-        # @param unwrap [Symbol, nil]
+        # @param unwrap [Symbol, Integer, Array<Symbol, Integer>, Proc, nil]
         #
-        # @param page [Class, nil]
+        # @param page [Class<ModernTreasury::Internal::Type::BasePage>, nil]
         #
-        # @param stream [Class, nil]
+        # @param stream [Class<ModernTreasury::Internal::Type::BaseStream>, nil]
         #
         # @param model [ModernTreasury::Internal::Type::Converter, Class, nil]
         #
@@ -453,9 +493,9 @@ module ModernTreasury
 
           decoded = ModernTreasury::Internal::Util.decode_content(response, stream: stream)
           case req
-          in { stream: Class => st }
+          in {stream: Class => st}
             st.new(model: model, url: url, status: status, response: response, stream: decoded)
-          in { page: Class => page }
+          in {page: Class => page}
             page.new(client: self, req: req, headers: response, page_data: decoded)
           else
             unwrapped = ModernTreasury::Internal::Util.dig(decoded, req[:unwrap])
@@ -463,13 +503,59 @@ module ModernTreasury
           end
         end
 
+        # @api private
+        #
         # @return [String]
         def inspect
           # rubocop:disable Layout/LineLength
-          base_url = ModernTreasury::Internal::Util.unparse_uri(@base_url)
-          "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{base_url} max_retries=#{@max_retries} timeout=#{@timeout}>"
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{@base_url} max_retries=#{@max_retries} timeout=#{@timeout}>"
           # rubocop:enable Layout/LineLength
         end
+
+        define_sorbet_constant!(:RequestComponents) do
+          T.type_alias do
+            {
+              method: Symbol,
+              path: T.any(String, T::Array[String]),
+              query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
+              headers: T.nilable(
+                T::Hash[String,
+                        T.nilable(
+                          T.any(
+                            String,
+                            Integer,
+                            T::Array[T.nilable(T.any(String, Integer))]
+                          )
+                        )]
+              ),
+              body: T.nilable(T.anything),
+              unwrap: T.nilable(
+                T.any(
+                  Symbol,
+                  Integer,
+                  T::Array[T.any(Symbol, Integer)],
+                  T.proc.params(arg0: T.anything).returns(T.anything)
+                )
+              ),
+              page: T.nilable(T::Class[ModernTreasury::Internal::Type::BasePage[ModernTreasury::Internal::Type::BaseModel]]),
+              stream: T.nilable(T::Class[T.anything]),
+              model: T.nilable(ModernTreasury::Internal::Type::Converter::Input),
+              options: T.nilable(ModernTreasury::RequestOptions::OrHash)
+            }
+          end
+        end
+        define_sorbet_constant!(:RequestInput) do
+          T.type_alias do
+            {
+              method: Symbol,
+              url: URI::Generic,
+              headers: T::Hash[String, String],
+              body: T.anything,
+              max_retries: Integer,
+              timeout: Float
+            }
+          end
+        end
       end
     end
   end

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

@@ -5,6 +5,8 @@ module ModernTreasury
     module Transport
       # @api private
       class PooledNetRequester
+        extend ModernTreasury::Internal::Util::SorbetRuntimeSupport
+
         # from the golang stdlib
         # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
         KEEP_ALIVE_TIMEOUT = 30
@@ -54,14 +56,14 @@ module ModernTreasury
           # @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(
               method.to_s.upcase,
               !body.nil?,
               method != :head,
-              url.to_s
+              URI(url.to_s) # ensure we construct a URI class of the right scheme
             )
 
             headers.each { req[_1] = _2 }
@@ -75,12 +77,12 @@ module ModernTreasury
             in StringIO
               req["content-length"] ||= body.size.to_s unless req["transfer-encoding"]
               req.body_stream = ModernTreasury::Internal::Util::ReadIOAdapter.new(body, &blk)
-            in IO | Enumerator
+            in Pathname | IO | Enumerator
               req["transfer-encoding"] ||= "chunked" unless req["content-length"]
               req.body_stream = ModernTreasury::Internal::Util::ReadIOAdapter.new(body, &blk)
             end
 
-            req
+            [req, req.body_stream&.method(:close)]
           end
         end
 
@@ -123,13 +125,17 @@ module ModernTreasury
         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
 
@@ -145,7 +151,7 @@ module ModernTreasury
                 break if finished
 
                 rsp.read_body do |bytes|
-                  y << bytes
+                  y << bytes.force_encoding(Encoding::BINARY)
                   break if finished
 
                   self.class.calibrate_socket_timeout(conn, deadline)
@@ -154,8 +160,11 @@ module ModernTreasury
               end
             end
           rescue Timeout::Error
-            raise ModernTreasury::Errors::APITimeoutError
+            raise ModernTreasury::Errors::APITimeoutError.new(url: url, request: req)
+          rescue StandardError
+            raise ModernTreasury::Errors::APIConnectionError.new(url: url, request: req)
           end
+          # rubocop:enable Metrics/BlockLength
 
           conn, _, response = enum.next
           body = ModernTreasury::Internal::Util.fused_enum(enum, external: true) do
@@ -165,9 +174,11 @@ module ModernTreasury
             rescue StopIteration
               nil
             end
+          ensure
             conn.finish if !eof && conn&.started?
+            closing&.call
           end
-          [Integer(response.code), response, (response.body = body)]
+          [Integer(response.code), response, body]
         end
 
         # @api private
@@ -178,6 +189,18 @@ module ModernTreasury
           @size = size
           @pools = {}
         end
+
+        define_sorbet_constant!(:Request) do
+          T.type_alias do
+            {
+              method: Symbol,
+              url: URI::Generic,
+              headers: T::Hash[String, String],
+              body: T.anything,
+              deadline: Float
+            }
+          end
+        end
       end
     end
   end

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

@@ -13,6 +13,10 @@ module ModernTreasury
       class ArrayOf
         include ModernTreasury::Internal::Type::Converter
 
+        private_class_method :new
+
+        # @overload [](type_info, spec = {})
+        #
         # @param type_info [Hash{Symbol=>Object}, Proc, ModernTreasury::Internal::Type::Converter, Class]
         #
         # @param spec [Hash{Symbol=>Object}] .
@@ -24,13 +28,19 @@ module ModernTreasury
         #   @option spec [Proc] :union
         #
         #   @option spec [Boolean] :"nil?"
-        def self.[](type_info, spec = {}) = new(type_info, spec)
+        #
+        # @return [self]
+        def self.[](...) = new(...)
 
+        # @api public
+        #
         # @param other [Object]
         #
         # @return [Boolean]
         def ===(other) = other.is_a?(Array) && other.all?(item_type)
 
+        # @api public
+        #
         # @param other [Object]
         #
         # @return [Boolean]
@@ -40,6 +50,11 @@ module ModernTreasury
           # rubocop:enable Layout/LineLength
         end
 
+        # @api public
+        #
+        # @return [Integer]
+        def hash = [self.class, item_type].hash
+
         # @api private
         #
         # @param value [Array<Object>, Object]
@@ -79,12 +94,16 @@ module ModernTreasury
         #
         # @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
           if value.is_a?(Array)
             value.map do
-              ModernTreasury::Internal::Type::Converter.dump(target, _1)
+              ModernTreasury::Internal::Type::Converter.dump(target, _1, state: state)
             end
           else
             super
@@ -116,7 +135,18 @@ module ModernTreasury
         #   @option spec [Boolean] :"nil?"
         def initialize(type_info, spec = {})
           @item_type_fn = ModernTreasury::Internal::Type::Converter.type_info(type_info || spec)
-          @nilable = spec[:nil?]
+          @nilable = spec.fetch(:nil?, false)
+        end
+
+        # @api private
+        #
+        # @param depth [Integer]
+        #
+        # @return [String]
+        def inspect(depth: 0)
+          items = ModernTreasury::Internal::Type::Converter.inspect(item_type, depth: depth.succ)
+
+          "#{self.class}[#{[items, nilable? ? 'nil' : nil].compact.join(' | ')}]"
         end
       end
     end