dodopayments 1.22.0 → 1.47.0

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

@@ -5,6 +5,8 @@ module Dodopayments
     module Type
       # @api private
       module Converter
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
+
         # rubocop:disable Lint/UnusedMethodArgument
 
         # @api private
@@ -13,10 +15,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 [Object]
@@ -92,6 +98,48 @@ module Dodopayments
             end
           end
 
+          # @api private
+          #
+          # @param type_info [Hash{Symbol=>Object}, Proc, Dodopayments::Internal::Type::Converter, Class] .
+          #
+          #   @option type_info [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const
+          #
+          #   @option type_info [Proc] :enum
+          #
+          #   @option type_info [Proc] :union
+          #
+          #   @option type_info [Boolean] :"nil?"
+          #
+          # @param spec [Hash{Symbol=>Object}, Proc, Dodopayments::Internal::Type::Converter, Class] .
+          #
+          #   @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const
+          #
+          #   @option spec [Proc] :enum
+          #
+          #   @option spec [Proc] :union
+          #
+          #   @option spec [Boolean] :"nil?"
+          #
+          # @return [Hash{Symbol=>Object}]
+          def meta_info(type_info, spec)
+            [spec, type_info].grep(Hash).first.to_h.except(:const, :enum, :union, :nil?)
+          end
+
+          # @api private
+          #
+          # @param translate_names [Boolean]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def new_coerce_state(translate_names: true)
+            {
+              translate_names: translate_names,
+              strictness: true,
+              exactness: {yes: 0, no: 0, maybe: 0},
+              error: nil,
+              branched: 0
+            }
+          end
+
           # @api private
           #
           # Based on `target`, transform `value` into `target`, to the extent possible:
@@ -108,14 +156,11 @@ module Dodopayments
           #
           # @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:
+          # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`. This informs the 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.
           #
           # 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
@@ -128,21 +173,20 @@ module Dodopayments
           #
           # See implementation below for more details.
           #
-          #   @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 [Object]
-          def coerce(
-            target,
-            value,
-            state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
-          )
-            # rubocop:disable Lint/SuppressedException
+          def coerce(target, value, state: Dodopayments::Internal::Type::Converter.new_coerce_state)
             # rubocop:disable Metrics/BlockNesting
-            strictness, exactness = state.fetch_values(:strictness, :exactness)
+            exactness = state.fetch(:exactness)
 
             case target
             in Dodopayments::Internal::Type::Converter
@@ -158,29 +202,26 @@ module Dodopayments
                 exactness[value.nil? ? :yes : :maybe] += 1
                 return nil
               in -> { _1 <= Integer }
-                if value.is_a?(Integer)
+                case value
+                in Integer
                   exactness[:yes] += 1
                   return value
-                elsif strictness == :strong && Integer(value, exception: false) != value
-                  message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise value.is_a?(Numeric) ? ArgumentError.new(message) : TypeError.new(message)
                 else
                   Kernel.then do
                     return Integer(value).tap { exactness[:maybe] += 1 }
-                  rescue ArgumentError, TypeError
+                  rescue ArgumentError, TypeError => e
+                    state[:error] = e
                   end
                 end
               in -> { _1 <= Float }
                 if value.is_a?(Numeric)
                   exactness[:yes] += 1
                   return Float(value)
-                elsif strictness == :strong
-                  message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise TypeError.new(message)
                 else
                   Kernel.then do
                     return Float(value).tap { exactness[:maybe] += 1 }
-                  rescue ArgumentError, TypeError
+                  rescue ArgumentError, TypeError => e
+                    state[:error] = e
                   end
                 end
               in -> { _1 <= String }
@@ -192,16 +233,13 @@ module Dodopayments
                   exactness[:yes] += 1
                   return value.string
                 else
-                  if strictness == :strong
-                    message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                    raise TypeError.new(message)
-                  end
+                  state[:error] = TypeError.new("#{value.class} can't be coerced into #{String}")
                 end
               in -> { _1 <= Date || _1 <= Time }
                 Kernel.then do
                   return target.parse(value).tap { exactness[:yes] += 1 }
                 rescue ArgumentError, TypeError => e
-                  raise e if strictness == :strong
+                  state[:error] = e
                 end
               in -> { _1 <= StringIO } if value.is_a?(String)
                 exactness[:yes] += 1
@@ -219,10 +257,8 @@ module Dodopayments
                   return value
                 end
               else
-                if strictness == :strong
-                  message = "cannot convert non-matching #{value.class} into #{target.inspect}"
-                  raise ArgumentError.new(message)
-                end
+                message = "cannot convert non-matching #{value.class} into #{target.inspect}"
+                state[:error] = ArgumentError.new(message)
               end
             else
             end
@@ -230,7 +266,6 @@ module Dodopayments
             exactness[:no] += 1
             value
             # rubocop:enable Metrics/BlockNesting
-            # rubocop:enable Lint/SuppressedException
           end
 
           # @api private
@@ -268,6 +303,24 @@ module Dodopayments
             end
           end
         end
+
+        define_sorbet_constant!(:Input) do
+          T.type_alias { T.any(Dodopayments::Internal::Type::Converter, T::Class[T.anything]) }
+        end
+        define_sorbet_constant!(:CoerceState) do
+          T.type_alias do
+            {
+              translate_names: T::Boolean,
+              strictness: T::Boolean,
+              exactness: {yes: Integer, no: Integer, maybe: Integer},
+              error: T::Class[StandardError],
+              branched: Integer
+            }
+          end
+        end
+        define_sorbet_constant!(:DumpState) do
+          T.type_alias { {can_retry: T::Boolean} }
+        end
       end
     end
   end

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

@@ -17,13 +17,13 @@ module Dodopayments
       # values safely.
       #
       # @example
-      #   # `intent_status` is a `Dodopayments::Models::IntentStatus`
+      #   # `intent_status` is a `Dodopayments::IntentStatus`
       #   case intent_status
-      #   when Dodopayments::Models::IntentStatus::SUCCEEDED
+      #   when Dodopayments::IntentStatus::SUCCEEDED
       #     # ...
-      #   when Dodopayments::Models::IntentStatus::FAILED
+      #   when Dodopayments::IntentStatus::FAILED
       #     # ...
-      #   when Dodopayments::Models::IntentStatus::CANCELLED
+      #   when Dodopayments::IntentStatus::CANCELLED
       #     # ...
       #   else
       #     puts(intent_status)
@@ -42,6 +42,7 @@ module Dodopayments
       #   end
       module Enum
         include Dodopayments::Internal::Type::Converter
+        include Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         # All of the valid Symbol values for this enum.
         #
@@ -80,10 +81,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 [Symbol, Object]
@@ -94,8 +99,12 @@ module Dodopayments
           if values.include?(val)
             exactness[:yes] += 1
             val
+          elsif values.first&.class == val.class
+            exactness[:maybe] += 1
+            value
           else
-            exactness[values.first&.class == val.class ? :maybe : :no] += 1
+            exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{self}")
             value
           end
         end
@@ -111,6 +120,21 @@ module Dodopayments
         #
         #   @return [Symbol, Object]
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          types = values.map { Dodopayments::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(_1) }.uniq
+          case types
+          in []
+            T.noreturn
+          in [type]
+            type
+          else
+            T.any(*types)
+          end
+        end
+
         # @api private
         #
         # @param depth [Integer]

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

@@ -45,10 +45,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 [StringIO, Object]
@@ -62,6 +66,7 @@ module Dodopayments
               exactness[:yes] += 1
               value
             else
+              state[:error] = TypeError.new("#{value.class} can't be coerced into #{StringIO}")
               exactness[:no] += 1
               value
             end
@@ -89,6 +94,13 @@ module Dodopayments
 
             value
           end
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            T.any(Pathname, StringIO, IO, String, Dodopayments::FilePart)
+          end
         end
       end
     end

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

@@ -12,6 +12,7 @@ module Dodopayments
       # Hash of items of a given type.
       class HashOf
         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::HashOf]
+        # @return [self]
         def self.[](...) = new(...)
 
         # @api public
@@ -76,10 +77,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 [Hash{Symbol=>Object}, Object]
@@ -88,6 +93,7 @@ module Dodopayments
 
           unless value.is_a?(Hash)
             exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
             return value
           end
 
@@ -130,6 +136,13 @@ module Dodopayments
           end
         end
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          T::Hash[Dodopayments::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
+        end
+
         # @api private
         #
         # @return [generic<Elem>]
@@ -155,6 +168,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/request_parameters.rb

@@ -5,10 +5,10 @@ module Dodopayments
     module Type
       # @api private
       module RequestParameters
-        # @!parse
-        #   # Options to specify HTTP behaviour for this request.
-        #   # @return [Dodopayments::RequestOptions, Hash{Symbol=>Object}]
-        #   attr_accessor :request_options
+        # @!attribute request_options
+        # Options to specify HTTP behaviour for this request.
+        #
+        #   @return [Dodopayments::RequestOptions, Hash{Symbol=>Object}]
 
         # @param mod [Module]
         def self.included(mod)

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

@@ -6,46 +6,37 @@ module Dodopayments
       # @api private
       #
       # @example
-      #   # `price` is a `Dodopayments::Models::Price`
-      #   case price
-      #   when Dodopayments::Models::Price::OneTimePrice
-      #     puts(price.currency)
-      #   when Dodopayments::Models::Price::RecurringPrice
-      #     puts(price.discount)
+      #   # `customer_request` is a `Dodopayments::CustomerRequest`
+      #   case customer_request
+      #   when Dodopayments::AttachExistingCustomer
+      #     puts(customer_request.customer_id)
+      #   when Dodopayments::NewCustomer
+      #     puts(customer_request.email)
       #   else
-      #     puts(price)
-      #   end
-      #
-      # @example
-      #   case price
-      #   in {type: :one_time_price, currency: currency, discount: discount, price: price}
-      #     puts(currency)
-      #   in {type: :recurring_price, currency: currency, discount: discount, payment_frequency_count: payment_frequency_count}
-      #     puts(discount)
-      #   else
-      #     puts(price)
+      #     puts(customer_request)
       #   end
       module Union
         include Dodopayments::Internal::Type::Converter
+        include Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         # @api private
         #
         # All of the specified variant info for this union.
         #
-        # @return [Array<Array(Symbol, Proc)>]
+        # @return [Array<Array(Symbol, Proc, Hash{Symbol=>Object})>]
         private def known_variants = (@known_variants ||= [])
 
         # @api private
         #
-        # @return [Array<Array(Symbol, Object)>]
+        # @return [Array<Array(Symbol, Object, Hash{Symbol=>Object})>]
         protected def derefed_variants
-          known_variants.map { |key, variant_fn| [key, variant_fn.call] }
+          known_variants.map { |key, variant_fn, meta| [key, variant_fn.call, meta] }
         end
 
         # All of the specified variants for this union.
         #
         # @return [Array<Object>]
-        def variants = derefed_variants.map(&:last)
+        def variants = derefed_variants.map { _2 }
 
         # @api private
         #
@@ -71,12 +62,13 @@ module Dodopayments
         #
         #   @option spec [Boolean] :"nil?"
         private def variant(key, spec = nil)
+          meta = Dodopayments::Internal::Type::Converter.meta_info(nil, spec)
           variant_info =
             case key
             in Symbol
-              [key, Dodopayments::Internal::Type::Converter.type_info(spec)]
+              [key, Dodopayments::Internal::Type::Converter.type_info(spec), meta]
             in Proc | Dodopayments::Internal::Type::Converter | Class | Hash
-              [nil, Dodopayments::Internal::Type::Converter.type_info(key)]
+              [nil, Dodopayments::Internal::Type::Converter.type_info(key), meta]
             end
 
           known_variants << variant_info
@@ -99,7 +91,8 @@ module Dodopayments
             return nil if key == Dodopayments::Internal::OMIT
 
             key = key.to_sym if key.is_a?(String)
-            known_variants.find { |k,| k == key }&.last&.call
+            _, found = known_variants.find { |k,| k == key }
+            found&.call
           else
             nil
           end
@@ -135,14 +128,23 @@ module Dodopayments
 
         # @api private
         #
+        # Tries to efficiently coerce the given value to one of the known variants.
+        #
+        # If the value cannot match any of the known variants, the coercion is considered
+        # non-viable and returns the original value.
+        #
         # @param value [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 [Object]
@@ -153,7 +155,6 @@ module Dodopayments
 
           strictness = state.fetch(:strictness)
           exactness = state.fetch(:exactness)
-          state[:strictness] = strictness == :strong ? true : strictness
 
           alternatives = []
           known_variants.each do |_, variant_fn|
@@ -172,13 +173,10 @@ module Dodopayments
             end
           end
 
-          case alternatives.sort_by(&:first)
+          case alternatives.sort_by!(&:first)
           in []
             exactness[:no] += 1
-            if strictness == :strong
-              message = "no possible conversion of #{value.class} into a variant of #{target.inspect}"
-              raise ArgumentError.new(message)
-            end
+            state[:error] = ArgumentError.new("no matching variant for #{value.inspect}")
             value
           in [[_, exact, coerced], *]
             exact.each { exactness[_1] += _2 }
@@ -217,6 +215,21 @@ module Dodopayments
           super
         end
 
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type
+          types = variants.map { Dodopayments::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(_1) }.uniq
+          case types
+          in []
+            T.noreturn
+          in [type]
+            type
+          else
+            T.any(*types)
+          end
+        end
+
         # rubocop:enable Style/CaseEquality
         # rubocop:enable Style/HashEachMethods
 

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

@@ -10,6 +10,7 @@ module Dodopayments
       # When we don't know what to expect for the value.
       class Unknown
         extend Dodopayments::Internal::Type::Converter
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         # rubocop:disable Lint/UnusedMethodArgument
 
@@ -32,14 +33,20 @@ module Dodopayments
         class << self
           # @api private
           #
+          # No coercion needed for Unknown type.
+          #
           # @param value [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 [Object]
@@ -58,6 +65,13 @@ module Dodopayments
           #     @option state [Boolean] :can_retry
           #
           #   @return [Object]
+
+          # @api private
+          #
+          # @return [Object]
+          def to_sorbet_type
+            T.anything
+          end
         end
 
         # rubocop:enable Lint/UnusedMethodArgument