dodopayments 1.20.0 → 1.47.0

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

@@ -7,6 +7,8 @@ module Dodopayments
       #
       # @abstract
       class BaseClient
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
+
         # from whatwg fetch spec
         MAX_REDIRECTS = 20
 
@@ -151,6 +153,27 @@ module Dodopayments
           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 [Dodopayments::Internal::Transport::PooledNetRequester]
         attr_reader :requester
@@ -182,10 +205,11 @@ module Dodopayments
             },
             headers
           )
-          @base_url = Dodopayments::Internal::Util.parse_uri(base_url)
+          @base_url_components = Dodopayments::Internal::Util.parse_uri(base_url)
+          @base_url = Dodopayments::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
@@ -276,10 +300,14 @@ module Dodopayments
               Dodopayments::Internal::Util.deep_merge(*[req[:body], opts[:extra_body]].compact)
             end
 
+          url = Dodopayments::Internal::Util.join_parsed_uri(
+            @base_url_components,
+            {**req, path: path, query: query}
+          )
           headers, encoded = Dodopayments::Internal::Util.encode_content(headers, body)
           {
             method: method,
-            url: Dodopayments::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),
@@ -337,7 +365,7 @@ module Dodopayments
         #
         # @raise [Dodopayments::Errors::APIError]
         # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        def send_request(request, redirect_count:, retry_count:, send_retry_header:)
           url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout)
           input = {
             **request.except(:timeout),
@@ -446,6 +474,7 @@ module Dodopayments
           self.class.validate!(req)
           model = req.fetch(:model) { Dodopayments::Internal::Type::Unknown }
           opts = req[:options].to_h
+          unwrap = req[:unwrap]
           Dodopayments::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)
           url = request.fetch(:url)
@@ -461,12 +490,19 @@ module Dodopayments
 
           decoded = Dodopayments::Internal::Util.decode_content(response, stream: stream)
           case req
-          in { stream: Class => st }
-            st.new(model: model, url: url, status: status, response: response, stream: decoded)
-          in { page: Class => page }
+          in {stream: Class => st}
+            st.new(
+              model: model,
+              url: url,
+              status: status,
+              response: response,
+              unwrap: unwrap,
+              stream: decoded
+            )
+          in {page: Class => page}
             page.new(client: self, req: req, headers: response, page_data: decoded)
           else
-            unwrapped = Dodopayments::Internal::Util.dig(decoded, req[:unwrap])
+            unwrapped = Dodopayments::Internal::Util.dig(decoded, unwrap)
             Dodopayments::Internal::Type::Converter.coerce(model, unwrapped)
           end
         end
@@ -476,10 +512,54 @@ module Dodopayments
         # @return [String]
         def inspect
           # rubocop:disable Layout/LineLength
-          base_url = Dodopayments::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[Dodopayments::Internal::Type::BasePage[Dodopayments::Internal::Type::BaseModel]]),
+              stream: T.nilable(T::Class[T.anything]),
+              model: T.nilable(Dodopayments::Internal::Type::Converter::Input),
+              options: T.nilable(Dodopayments::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/dodopayments/internal/transport/pooled_net_requester.rb

@@ -5,10 +5,14 @@ module Dodopayments
     module Transport
       # @api private
       class PooledNetRequester
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
+
         # from the golang stdlib
         # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
         KEEP_ALIVE_TIMEOUT = 30
 
+        DEFAULT_MAX_CONNECTIONS = [Etc.nprocessors, 99].max
+
         class << self
           # @api private
           #
@@ -182,11 +186,23 @@ module Dodopayments
         # @api private
         #
         # @param size [Integer]
-        def initialize(size: Etc.nprocessors)
+        def initialize(size: self.class::DEFAULT_MAX_CONNECTIONS)
           @mutex = Mutex.new
           @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/dodopayments/internal/type/array_of.rb

@@ -12,6 +12,7 @@ module Dodopayments
       # Array of items of a given type.
       class ArrayOf
         include Dodopayments::Internal::Type::Converter
+        include Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         private_class_method :new
 
@@ -29,7 +30,7 @@ module Dodopayments
         #
         #   @option spec [Boolean] :"nil?"
         #
-        # @return [Dodopayments::Internal::Type::ArrayOf]
+        # @return [self]
         def self.[](...) = new(...)
 
         # @api public
@@ -61,10 +62,14 @@ module Dodopayments
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Array<Object>, Object]
@@ -73,6 +78,7 @@ module Dodopayments
 
           unless value.is_a?(Array)
             exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{Array}")
             return value
           end
 
@@ -110,6 +116,13 @@ module Dodopayments
           end
         end
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          T::Array[Dodopayments::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
+        end
+
         # @api private
         #
         # @return [generic<Elem>]
@@ -135,6 +148,7 @@ module Dodopayments
         #   @option spec [Boolean] :"nil?"
         def initialize(type_info, spec = {})
           @item_type_fn = Dodopayments::Internal::Type::Converter.type_info(type_info || spec)
+          @meta = Dodopayments::Internal::Type::Converter.meta_info(type_info, spec)
           @nilable = spec.fetch(:nil?, false)
         end
 

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

@@ -6,6 +6,7 @@ module Dodopayments
       # @abstract
       class BaseModel
         extend Dodopayments::Internal::Type::Converter
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         class << self
           # @api private
@@ -13,11 +14,17 @@ module Dodopayments
           # Assumes superclass fields are totally defined before fields are accessed /
           # defined on subclasses.
           #
-          # @return [Hash{Symbol=>Hash{Symbol=>Object}}]
-          def known_fields
-            @known_fields ||= (self < Dodopayments::Internal::Type::BaseModel ? superclass.known_fields.dup : {})
+          # @param child [Class<Dodopayments::Internal::Type::BaseModel>]
+          def inherited(child)
+            super
+            child.known_fields.replace(known_fields.dup)
           end
 
+          # @api private
+          #
+          # @return [Hash{Symbol=>Hash{Symbol=>Object}}]
+          def known_fields = @known_fields ||= {}
+
           # @api private
           #
           # @return [Hash{Symbol=>Hash{Symbol=>Object}}]
@@ -45,6 +52,7 @@ module Dodopayments
           #
           #   @option spec [Boolean] :"nil?"
           private def add_field(name_sym, required:, type_info:, spec:)
+            meta = Dodopayments::Internal::Type::Converter.meta_info(type_info, spec)
             type_fn, info =
               case type_info
               in Proc | Dodopayments::Internal::Type::Converter | Class
@@ -53,7 +61,7 @@ module Dodopayments
                 [Dodopayments::Internal::Type::Converter.type_info(type_info), type_info]
               end
 
-            setter = "#{name_sym}="
+            setter = :"#{name_sym}="
             api_name = info.fetch(:api_name, name_sym)
             nilable = info.fetch(:nil?, false)
             const = if required && !nilable
@@ -74,31 +82,65 @@ module Dodopayments
                 required: required,
                 nilable: nilable,
                 const: const,
-                type_fn: type_fn
+                type_fn: type_fn,
+                meta: meta
               }
 
-            define_method(setter) { @data.store(name_sym, _1) }
+            define_method(setter) do |value|
+              target = type_fn.call
+              state = Dodopayments::Internal::Type::Converter.new_coerce_state(translate_names: false)
+              coerced = Dodopayments::Internal::Type::Converter.coerce(target, value, state: state)
+              status = @coerced.store(name_sym, state.fetch(:error) || true)
+              stored =
+                case [target, status]
+                in [Dodopayments::Internal::Type::Converter | Symbol, true]
+                  coerced
+                else
+                  value
+                end
+              @data.store(name_sym, stored)
+            end
 
+            # rubocop:disable Style/CaseEquality
+            # rubocop:disable Metrics/BlockLength
             define_method(name_sym) do
               target = type_fn.call
-              value = @data.fetch(name_sym) { const == Dodopayments::Internal::OMIT ? nil : const }
-              state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
-              if (nilable || !required) && value.nil?
-                nil
-              else
-                Dodopayments::Internal::Type::Converter.coerce(
-                  target, value, state: state
+
+              case @coerced[name_sym]
+              in true | false if Dodopayments::Internal::Type::Converter === target
+                @data.fetch(name_sym)
+              in ::StandardError => e
+                raise Dodopayments::Errors::ConversionError.new(
+                  on: self.class,
+                  method: __method__,
+                  target: target,
+                  value: @data.fetch(name_sym),
+                  cause: e
                 )
+              else
+                Kernel.then do
+                  value = @data.fetch(name_sym) { const == Dodopayments::Internal::OMIT ? nil : const }
+                  state = Dodopayments::Internal::Type::Converter.new_coerce_state(translate_names: false)
+                  if (nilable || !required) && value.nil?
+                    nil
+                  else
+                    Dodopayments::Internal::Type::Converter.coerce(
+                      target, value, state: state
+                    )
+                  end
+                rescue StandardError => e
+                  raise Dodopayments::Errors::ConversionError.new(
+                    on: self.class,
+                    method: __method__,
+                    target: target,
+                    value: value,
+                    cause: e
+                  )
+                end
               end
-            rescue StandardError => e
-              cls = self.class.name.split("::").last
-              message = [
-                "Failed to parse #{cls}.#{__method__} from #{value.class} to #{target.inspect}.",
-                "To get the unparsed API response, use #{cls}[#{__method__.inspect}].",
-                "Cause: #{e.message}"
-              ].join(" ")
-              raise Dodopayments::Errors::ConversionError.new(message)
             end
+            # rubocop:enable Metrics/BlockLength
+            # rubocop:enable Style/CaseEquality
           end
 
           # @api private
@@ -198,23 +240,28 @@ module Dodopayments
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
-          # @return [Dodopayments::Internal::Type::BaseModel, Object]
+          # @return [self, Object]
           def coerce(value, state:)
             exactness = state.fetch(:exactness)
 
-            if value.is_a?(self.class)
+            if value.is_a?(self)
               exactness[:yes] += 1
               return value
             end
 
             unless (val = Dodopayments::Internal::Util.coerce_hash(value)).is_a?(Hash)
               exactness[:no] += 1
+              state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
               return value
             end
             exactness[:yes] += 1
@@ -222,13 +269,15 @@ module Dodopayments
             keys = val.keys.to_set
             instance = new
             data = instance.to_h
+            status = instance.instance_variable_get(:@coerced)
 
             # rubocop:disable Metrics/BlockLength
             fields.each do |name, field|
               mode, required, target = field.fetch_values(:mode, :required, :type)
               api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
+              src_name = state.fetch(:translate_names) ? api_name : name
 
-              unless val.key?(api_name)
+              unless val.key?(src_name)
                 if required && mode != :dump && const == Dodopayments::Internal::OMIT
                   exactness[nilable ? :maybe : :no] += 1
                 else
@@ -237,9 +286,10 @@ module Dodopayments
                 next
               end
 
-              item = val.fetch(api_name)
-              keys.delete(api_name)
+              item = val.fetch(src_name)
+              keys.delete(src_name)
 
+              state[:error] = nil
               converted =
                 if item.nil? && (nilable || !required)
                   exactness[nilable ? :yes : :maybe] += 1
@@ -253,6 +303,8 @@ module Dodopayments
                     item
                   end
                 end
+
+              status.store(name, state.fetch(:error) || true)
               data.store(name, converted)
             end
             # rubocop:enable Metrics/BlockLength
@@ -263,7 +315,7 @@ module Dodopayments
 
           # @api private
           #
-          # @param value [Dodopayments::Internal::Type::BaseModel, Object]
+          # @param value [self, Object]
           #
           # @param state [Hash{Symbol=>Object}] .
           #
@@ -302,6 +354,46 @@ module Dodopayments
 
             acc
           end
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            self
+          end
+        end
+
+        class << self
+          # @api private
+          #
+          # @param model [Dodopayments::Internal::Type::BaseModel]
+          # @param convert [Boolean]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def recursively_to_h(model, convert:)
+            rec = ->(x) do
+              case x
+              in Dodopayments::Internal::Type::BaseModel
+                if convert
+                  fields = x.class.known_fields
+                  x.to_h.to_h do |key, val|
+                    [key, rec.call(fields.key?(key) ? x.public_send(key) : val)]
+                  rescue Dodopayments::Errors::ConversionError
+                    [key, rec.call(val)]
+                  end
+                else
+                  rec.call(x.to_h)
+                end
+              in Hash
+                x.transform_values(&rec)
+              in Array
+                x.map(&rec)
+              else
+                x
+              end
+            end
+            rec.call(model)
+          end
         end
 
         # @api public
@@ -340,9 +432,23 @@ module Dodopayments
 
         alias_method :to_hash, :to_h
 
+        # @api public
+        #
+        # In addition to the behaviour of `#to_h`, this method will recursively call
+        # `#to_h` on nested models.
+        #
+        # @return [Hash{Symbol=>Object}]
+        def deep_to_h = self.class.recursively_to_h(@data, convert: false)
+
         # @param keys [Array<Symbol>, nil]
         #
         # @return [Hash{Symbol=>Object}]
+        #
+        # @example
+        #   # `attach_existing_customer` is a `Dodopayments::AttachExistingCustomer`
+        #   attach_existing_customer => {
+        #     customer_id: customer_id
+        #   }
         def deconstruct_keys(keys)
           (keys || self.class.known_fields.keys)
             .filter_map do |k|
@@ -355,29 +461,6 @@ module Dodopayments
             .to_h
         end
 
-        class << self
-          # @api private
-          #
-          # @param model [Dodopayments::Internal::Type::BaseModel]
-          #
-          # @return [Hash{Symbol=>Object}]
-          def walk(model)
-            walk = ->(x) do
-              case x
-              in Dodopayments::Internal::Type::BaseModel
-                walk.call(x.to_h)
-              in Hash
-                x.transform_values(&walk)
-              in Array
-                x.map(&walk)
-              else
-                x
-              end
-            end
-            walk.call(model)
-          end
-        end
-
         # @api public
         #
         # @param a [Object]
@@ -396,12 +479,15 @@ module Dodopayments
         #
         # @param data [Hash{Symbol=>Object}, self]
         def initialize(data = {})
-          case Dodopayments::Internal::Util.coerce_hash(data)
-          in Hash => coerced
-            @data = coerced
-          else
-            message = "Expected a #{Hash} or #{Dodopayments::Internal::Type::BaseModel}, got #{data.inspect}"
-            raise ArgumentError.new(message)
+          @data = {}
+          @coerced = {}
+          Dodopayments::Internal::Util.coerce_hash!(data).each do
+            if self.class.known_fields.key?(_1)
+              public_send(:"#{_1}=", _2)
+            else
+              @data.store(_1, _2)
+              @coerced.store(_1, false)
+            end
           end
         end
 
@@ -431,12 +517,19 @@ module Dodopayments
         # @api public
         #
         # @return [String]
-        def to_s = self.class.walk(@data).to_s
+        def to_s = deep_to_h.to_s
 
         # @api private
         #
         # @return [String]
-        def inspect = "#<#{self.class}:0x#{object_id.to_s(16)} #{self}>"
+        def inspect
+          converted = self.class.recursively_to_h(self, convert: true)
+          "#<#{self.class}:0x#{object_id.to_s(16)} #{converted}>"
+        end
+
+        define_sorbet_constant!(:KnownField) do
+          T.type_alias { {mode: T.nilable(Symbol), required: T::Boolean, nilable: T::Boolean} }
+        end
       end
     end
   end

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

@@ -10,6 +10,7 @@ module Dodopayments
       # Ruby has no Boolean class; this is something for models to refer to.
       class Boolean
         extend Dodopayments::Internal::Type::Converter
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         private_class_method :new
 
@@ -30,14 +31,20 @@ module Dodopayments
         class << self
           # @api private
           #
+          # Coerce value to Boolean if possible, otherwise return the original value.
+          #
           # @param value [Boolean, Object]
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [Boolean, Object]
@@ -56,6 +63,13 @@ module Dodopayments
           #     @option state [Boolean] :can_retry
           #
           #   @return [Boolean, Object]
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            T::Boolean
+          end
         end
       end
     end