grape 3.2.1 → 3.3.0

data/lib/grape/validations/params_scope.rb

@@ -38,9 +38,10 @@ module Grape
         end
 
         def self.attr_key(declared_param_attr)
-          return attr_key(declared_param_attr.key) if declared_param_attr.is_a?(self)
-
-          if declared_param_attr.is_a?(Hash)
+          case declared_param_attr
+          when self
+            attr_key(declared_param_attr.key)
+          when Hash
             declared_param_attr.transform_values { |value| attrs_keys(value) }
           else
             declared_param_attr
@@ -86,7 +87,8 @@ module Grape
       end
 
       def configuration
-        (@api.configuration.respond_to?(:evaluate) && @api.configuration.evaluate) || @api.configuration
+        config = @api.configuration
+        config.is_a?(Grape::Util::Lazy::Base) ? config.evaluate : config
       end
 
       # @return [Boolean] whether or not this entire scope needs to be
@@ -195,13 +197,10 @@ module Grape
       private
 
       def build_full_path
-        if nested?
-          @parent.full_path + [@element]
-        elsif lateral?
-          @parent.full_path
-        else
-          []
-        end
+        return @parent.full_path + [@element] if nested?
+        return @parent.full_path if lateral?
+
+        []
       end
 
       # Add a new parameter which should be renamed when using the +#declared+
@@ -315,12 +314,9 @@ module Grape
       # push_declared_params cannot be called on the frozen scope later.
       def configure_declared_params
         push_renamed_param(full_path, @element_renamed) if @element_renamed
+        return @parent.push_declared_params [{ @element => @declared_params }] if nested?
 
-        if nested?
-          @parent.push_declared_params [@element => @declared_params]
-        else
-          @api.inheritable_setting.namespace_stackable[:declared_params] = @declared_params
-        end
+        @api.inheritable_setting.namespace_stackable[:declared_params] = @declared_params
       ensure
         @declared_params = nil
       end
@@ -332,139 +328,67 @@ module Grape
       end
 
       def validates(attrs, validations)
-        coerce_type = infer_coercion(validations)
-        required = validations.key?(:presence)
-        default = validations[:default]
-        values = validations[:values].is_a?(Hash) ? validations.dig(:values, :value) : validations[:values]
-        except_values = validations[:except_values].is_a?(Hash) ? validations.dig(:except_values, :value) : validations[:except_values]
-
-        # NB. values and excepts should be nil, Proc, Array, or Range.
-        # Specifically, values should NOT be a Hash
-        # use values or excepts to guess coerce type when stated type is Array
-        coerce_type = guess_coerce_type(coerce_type, values, except_values)
-
-        # default value should be present in values array, if both exist and are not procs
-        check_incompatible_option_values(default, values, except_values)
+        process_oneof!(validations) if validations.key?(:oneof)
+        spec = ValidationsSpec.from(validations)
 
-        # type should be compatible with values array, if both exist
-        validate_value_coercion(coerce_type, values, except_values)
+        document_params(attrs, spec)
 
-        document_params attrs, validations, coerce_type, values, except_values
+        # Presence runs first — `required` is forwarded to every subsequent
+        # validator (some short-circuit on it).
+        validate_presence(spec, attrs)
 
-        opts = derive_validator_options(validations).freeze
+        # Coerce runs second — later validators see the typed value.
+        validate_coerce(spec, attrs)
 
-        # Validate for presence before any other validators
-        validates_presence(validations, attrs, opts)
-
-        # Before we run the rest of the validators, let's handle
-        # whatever coercion so that we are working with correctly
-        # type casted values
-        coerce_type validations.extract!(:coerce, :coerce_with, :coerce_message), attrs, required, opts
-
-        validations.each do |type, options|
-          # Don't try to look up validators for documentation params that don't have one.
-          next if RESERVED_DOCUMENTATION_KEYWORDS.include?(type)
-
-          validate(type, options, attrs, required, opts)
-        end
-      end
-
-      # Validate and comprehend the +:type+, +:types+, and +:coerce_with+
-      # options that have been supplied to the parameter declaration.
-      # The +:type+ and +:types+ options will be removed from the
-      # validations list, replaced appropriately with +:coerce+ and
-      # +:coerce_with+ options that will later be passed to
-      # {Validators::CoerceValidator}. The type that is returned may be
-      # used for documentation and further validation of parameter
-      # options.
-      #
-      # @param validations [Hash] list of validations supplied to the
-      #   parameter declaration
-      # @return [class-like] type to which the parameter will be coerced
-      # @raise [ArgumentError] if the given type options are invalid
-      def infer_coercion(validations)
-        raise ArgumentError, ':type may not be supplied with :types' if validations.key?(:type) && validations.key?(:types)
-
-        validations[:coerce] = (options_key?(:type, :value, validations) ? validations[:type][:value] : validations[:type]) if validations.key?(:type)
-        validations[:coerce_message] = (options_key?(:type, :message, validations) ? validations[:type][:message] : nil) if validations.key?(:type)
-        validations[:coerce] = (options_key?(:types, :value, validations) ? validations[:types][:value] : validations[:types]) if validations.key?(:types)
-        validations[:coerce_message] = (options_key?(:types, :message, validations) ? validations[:types][:message] : nil) if validations.key?(:types)
-
-        validations.delete(:types) if validations.key?(:types)
-
-        coerce_type = validations[:coerce]
-
-        # Special case - when the argument is a single type that is a
-        # variant-type collection.
-        if Types.multiple?(coerce_type) && validations.key?(:type)
-          validations[:coerce] = Types::VariantCollectionCoercer.new(
-            coerce_type,
-            validations.delete(:coerce_with)
-          )
+        spec.validator_entries.each do |type, options|
+          validate(type, options, attrs, spec.required?, spec.shared_opts)
         end
-        validations.delete(:type)
-
-        coerce_type
       end
 
-      # Enforce correct usage of :coerce_with parameter.
-      # We do not allow coercion without a type, nor with
-      # +JSON+ as a type since this defines its own coercion
-      # method.
-      def check_coerce_with(validations)
-        return unless validations.key?(:coerce_with)
-        # type must be supplied for coerce_with..
-        raise ArgumentError, 'must supply type for coerce_with' unless validations.key?(:coerce)
-
-        # but not special JSON types, which
-        # already imply coercion method
-        return unless SPECIAL_JSON.include?(validations[:coerce])
+      # Enforce correct usage of :coerce_with on a CoerceOptions.
+      # We do not allow coercion without a type, nor with +JSON+ as a type
+      # since that defines its own coercion method.
+      def check_coerce_with(coerce_options)
+        return unless coerce_options.coerce_method
+        raise ArgumentError, 'must supply type for coerce_with' unless coerce_options.type
+        return unless SPECIAL_JSON.include?(coerce_options.type)
 
         raise ArgumentError, 'coerce_with disallowed for type: JSON'
       end
 
-      # Add type coercion validation to this scope,
-      # if any has been specified.
-      # This validation has special handling since it is
-      # composited from more than one +requires+/+optional+
-      # parameter, and needs to be run before most other
-      # validations.
-      def coerce_type(validations, attrs, required, opts)
-        check_coerce_with(validations)
+      def validate_presence(spec, attrs)
+        return unless spec.required?
 
-        # Falsy check (not key?) is intentional: when a remountable API is first
-        # evaluated on its base instance (no configuration supplied yet),
-        # configuration[:some_type] evaluates to nil. Skipping instantiation
-        # here is correct — the real mounted instance will replay this step with
-        # the actual type value.
-        return unless validations[:coerce]
-
-        coerce_options = {
-          type: validations[:coerce],
-          method: validations[:coerce_with],
-          message: validations[:coerce_message]
-        }
-        validate('coerce', coerce_options, attrs, required, opts)
+        validate('presence', spec.presence_options, attrs, true, spec.shared_opts)
       end
 
-      def guess_coerce_type(coerce_type, *values_list)
-        return coerce_type unless coerce_type == Array
+      def validate_coerce(spec, attrs)
+        coerce_options = spec.coerce_options
+        check_coerce_with(coerce_options)
+        # Falsy check is intentional: when a remountable API is first evaluated
+        # on its base instance (no configuration supplied yet),
+        # configuration[:some_type] evaluates to nil. Skipping instantiation
+        # here is correct — the real mounted instance will replay this step
+        # with the actual type value.
+        return unless coerce_options.type
 
-        values_list.each do |values|
-          next if !values || values.is_a?(Proc)
-          return values.first.class if values.is_a?(Range) || !values.empty?
-        end
-        coerce_type
+        validate('coerce', coerce_options, attrs, spec.required?, spec.shared_opts)
       end
 
-      def check_incompatible_option_values(default, values, except_values)
-        return unless default && !default.is_a?(Proc)
-
-        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) if values && !values.is_a?(Proc) && !Array(default).all? { |def_val| values.include?(def_val) }
+      # Translate a `oneof: [proc, proc, ...]` declaration into a list of
+      # captured validator arrays — one array per variant. Each variant's
+      # block is evaluated in its own +ParamsScope+ backed by an
+      # {OneofCollector} so the full params DSL is available inside variants
+      # and the resulting validators are kept out of the real API's
+      # registration list.
+      def process_oneof!(validations)
+        raise ArgumentError, 'oneof: requires type: Hash' unless validations[:type] == Hash
 
-        return unless except_values && !except_values.is_a?(Proc) && Array(default).any? { |def_val| except_values.include?(def_val) }
+        variants = validations[:oneof]
+        raise ArgumentError, 'oneof: must be a non-empty Array of blocks' unless variants.is_a?(Array) && variants.any?
+        raise ArgumentError, 'oneof: each variant must be a Proc' unless variants.all?(Proc)
 
-        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values)
+        validations[:oneof] = variants.map { |block| OneofCollector.collect(block) }
       end
 
       def validate(type, options, attrs, required, opts)
@@ -479,51 +403,9 @@ module Grape
         @api.inheritable_setting.namespace_stackable[:validations] = validator_instance
       end
 
-      def validate_value_coercion(coerce_type, *values_list)
-        return unless coerce_type
-
-        coerce_type = coerce_type.first if coerce_type.is_a?(Enumerable)
-        values_list.each do |values|
-          next if !values || values.is_a?(Proc)
-
-          value_types = values.is_a?(Range) ? [values.begin, values.end].compact : values
-          value_types = value_types.map { |type| Grape::API::Boolean.build(type) } if coerce_type == Grape::API::Boolean
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values) unless value_types.all?(coerce_type)
-        end
-      end
-
-      def extract_message_option(attrs)
-        return nil unless attrs.is_a?(Array)
-
-        opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
-        opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil
-      end
-
-      def options_key?(type, key, validations)
-        validations[type].respond_to?(:key?) && validations[type].key?(key) && !validations[type][key].nil?
-      end
-
       def all_element_blank?(scoped_params)
         scoped_params.respond_to?(:all?) && scoped_params.all?(&:blank?)
       end
-
-      # Validators don't have access to each other and they don't need, however,
-      # some validators might influence others, so their options should be shared
-      def derive_validator_options(validations)
-        allow_blank = validations[:allow_blank]
-
-        {
-          allow_blank: allow_blank.is_a?(Hash) ? allow_blank[:value] : allow_blank,
-          fail_fast: validations.delete(:fail_fast) || false
-        }
-      end
-
-      def validates_presence(validations, attrs, opts)
-        return unless validations.key?(:presence) && validations[:presence]
-
-        validate('presence', validations.delete(:presence), attrs, true, opts)
-        validations.delete(:message) if validations.key?(:message)
-      end
     end
   end
 end

data/lib/grape/validations/shared_options.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Immutable value object holding the two options every validator reads at
+    # construction time: +allow_blank+ and +fail_fast+. Internal to
+    # {Validators::Base}, which builds it from the +opts+ Hash so the public
+    # 5th-argument contract stays a plain Hash — not part of any wire contract.
+    #
+    # Defaults mirror the prior +opts.values_at+ behaviour: +allow_blank+ is
+    # +nil+ when the declaration didn't supply it (validators treat nil as
+    # "not set"), +fail_fast+ defaults to +false+.
+    SharedOptions = Data.define(:allow_blank, :fail_fast) do
+      def initialize(allow_blank: nil, fail_fast: false)
+        super
+      end
+    end
+  end
+end

data/lib/grape/validations/types/array_coercer.rb

@@ -12,7 +12,7 @@ module Grape
       # behavior of Virtus which was used earlier, a `Grape::Validations::Types::PrimitiveCoercer`
       # maintains Virtus behavior in coercing.
       class ArrayCoercer < DryTypeCoercer
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           super
           @coercer = strict ? DryTypes::Strict::Array : DryTypes::Params::Array
           @subtype = type.first
@@ -52,7 +52,7 @@ module Grape
         end
 
         def elem_coercer
-          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict)
+          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict:)
         end
       end
     end

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -33,6 +33,10 @@ module Grape
       # contract as +coerced?+, and must be supplied with a coercion
       # +method+.
       class CustomTypeCoercer
+        TYPE_CHECK_METHODS = %i[coerced? parsed?].freeze
+        COLLECTION_TYPES = [Array, Set].freeze
+        private_constant :TYPE_CHECK_METHODS, :COLLECTION_TYPES
+
         # A new coercer for the given type specification
         # and coercion method.
         #
@@ -41,8 +45,7 @@ module Grape
         # @param method [#parse,#call]
         #   optional coercion method. See class docs.
         def initialize(type, method = nil)
-          coercion_method = infer_coercion_method type, method
-          @method = enforce_symbolized_keys type, coercion_method
+          @method = build_coercion_method(type, method)
           @type_check = infer_type_check(type)
         end
 
@@ -66,97 +69,50 @@ module Grape
 
         private
 
-        # Determine the coercion method we're expected to use
-        # based on the parameters given.
-        #
-        # @param type see #new
-        # @param method see #new
-        # @return [#call] coercion method
+        def build_coercion_method(type, method)
+          coercion_method = infer_coercion_method(type, method)
+          return hash_symbolizer(coercion_method) if type == Hash
+          return collection_symbolizer(coercion_method) if COLLECTION_TYPES.include?(type)
+
+          coercion_method
+        end
+
         def infer_coercion_method(type, method)
-          if method
-            if method.respond_to? :parse
-              method.method :parse
-            else
-              method
-            end
-          else
-            # Try to use parse() declared on the target type.
-            # This may raise an exception, but we are out of ideas anyway.
-            type.method :parse
-          end
+          return type.method(:parse) unless method
+          return method unless method.respond_to?(:parse)
+
+          method.method(:parse)
+        end
+
+        def hash_symbolizer(method)
+          ->(val) { method.call(val).deep_symbolize_keys }
+        end
+
+        def collection_symbolizer(method)
+          ->(val) { method.call(val).map! { |item| symbolize_if_hash(item) } }
+        end
+
+        def symbolize_if_hash(item)
+          item.is_a?(Hash) ? item.deep_symbolize_keys : item
         end
 
-        # Determine how the type validity of a coerced
-        # value should be decided.
-        #
-        # @param type see #new
-        # @return [#call] a procedure which accepts a single parameter
-        #   and returns +true+ if the passed object is of the correct type.
         def infer_type_check(type)
-          # First check for special class methods
-          if type.respond_to? :coerced?
-            type.method :coerced?
-          elsif type.respond_to? :parsed?
-            type.method :parsed?
-          elsif type.respond_to? :call
-            # Arbitrary proc passed for type validation.
-            # Note that this will fail unless a method is also
-            # passed, or if the type also implements a parse() method.
-            type
-          elsif type.is_a?(Enumerable)
-            lambda do |value|
-              value.is_a?(Enumerable) && value.all? do |val|
-                recursive_type_check(type.first, val)
-              end
-            end
-          else
-            # By default, do a simple type check
-            ->(value) { value.is_a? type }
-          end
+          method_name = TYPE_CHECK_METHODS.detect { |m| type.respond_to?(m) }
+          return type.method(method_name) if method_name
+          return type if type.respond_to?(:call)
+          return enumerable_type_check(type) if type.is_a?(Enumerable)
+
+          ->(value) { value.is_a? type }
         end
 
-        def recursive_type_check(type, value)
-          if type.is_a?(Enumerable) && value.is_a?(Enumerable)
-            value.all? { |val| recursive_type_check(type.first, val) }
-          else
-            !type.is_a?(Enumerable) && value.is_a?(type)
-          end
+        def enumerable_type_check(type)
+          ->(value) { value.is_a?(Enumerable) && value.all? { |val| recursive_type_check(type.first, val) } }
         end
 
-        # Enforce symbolized keys for complex types
-        # by wrapping the coercion method such that
-        # any Hash objects in the immediate heirarchy
-        # have their keys recursively symbolized.
-        # This helps common libs such as JSON to work easily.
-        #
-        # @param type see #new
-        # @param method see #infer_coercion_method
-        # @return [#call] +method+ wrapped in an additional
-        #   key-conversion step, or just returns +method+
-        #   itself if no conversion is deemed to be
-        #   necessary.
-        def enforce_symbolized_keys(type, method)
-          # Collections have all values processed individually
-          if [Array, Set].include?(type)
-            lambda do |val|
-              method.call(val).tap do |new_val|
-                new_val.map do |item|
-                  item.is_a?(Hash) ? item.deep_symbolize_keys : item
-                end
-              end
-            end
-
-          # Hash objects are processed directly
-          elsif type == Hash
-            lambda do |val|
-              method.call(val).deep_symbolize_keys
-            end
-
-          # Simple types are not processed.
-          # This includes Array<primitive> types.
-          else
-            method
-          end
+        def recursive_type_check(type, value)
+          return value.all? { |val| recursive_type_check(type.first, val) } if type.is_a?(Enumerable) && value.is_a?(Enumerable)
+
+          !type.is_a?(Enumerable) && value.is_a?(type)
         end
       end
     end

data/lib/grape/validations/types/custom_type_collection_coercer.rb

@@ -29,7 +29,7 @@ module Grape
         # @param set [Boolean]
         #   when true, a +Set+ will be returned by {#call} instead
         #   of an +Array+ and duplicate items will be discarded.
-        def initialize(type, set = false)
+        def initialize(type, set: false)
           super(type)
           @set = set
         end

data/lib/grape/validations/types/dry_type_coercer.rb

@@ -26,13 +26,13 @@ module Grape
           end
 
           # Returns an instance of a coercer for a given type
-          def coercer_instance_for(type, strict = false)
+          def coercer_instance_for(type, strict: false)
             klass = type.instance_of?(Class) ? PrimitiveCoercer : collection_coercer_for(type)
-            klass.new(type, strict)
+            klass.new(type, strict:)
           end
         end
 
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           @type = type
           @strict = strict
           @cache_coercer = strict ? DryTypes::StrictCache : DryTypes::ParamsCache

data/lib/grape/validations/types/primitive_coercer.rb

@@ -7,7 +7,7 @@ module Grape
       # initialization. When +strict+ is true, it doesn't coerce a value but check
       # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           super
 
           @coercer = cache_coercer[type]
@@ -15,7 +15,7 @@ module Grape
 
         def call(val)
           return InvalidValue.new if reject?(val)
-          return nil if val.nil? || treat_as_nil?(val)
+          return if val.nil? || treat_as_nil?(val)
 
           super
         end
@@ -29,9 +29,14 @@ module Grape
         # but Virtus wouldn't accept it. So, this method only exists to not introduce
         # breaking changes.
         def reject?(val)
-          (val.is_a?(Array) && type == String) ||
-            (val.is_a?(String) && type == Hash) ||
-            (val.is_a?(Hash) && type == String)
+          case val
+          when Array, Hash
+            type == String
+          when String
+            type == Hash
+          else
+            false
+          end
         end
 
         # Dry-Types treats an empty string as invalid. However, Grape considers an empty string as

data/lib/grape/validations/types/set_coercer.rb

@@ -6,7 +6,7 @@ module Grape
       # Takes the given array and converts it to a set. Every element of the set
       # is also coerced.
       class SetCoercer < ArrayCoercer
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           super
 
           @coercer = nil

data/lib/grape/validations/types/variant_collection_coercer.rb

@@ -26,6 +26,14 @@ module Grape
           @member_coercer = MultipleTypeCoercer.new types, method
         end
 
+        # Returns the Grape DSL notation for this coercer, e.g. "Array[Integer, String]".
+        # Distinct from the plain-array string "[Integer, String]" produced by the
+        # +types:+ keyword, which lets documentation tools tell the two apart.
+        def to_s
+          container = @types.is_a?(Set) ? 'Set' : 'Array'
+          "#{container}[#{@types.join(', ')}]"
+        end
+
         # Coerce the given value.
         #
         # @param value [Array<String>] collection of values to be coerced

data/lib/grape/validations/types.rb

@@ -75,7 +75,7 @@ module Grape
       # @return [Boolean] +true+ if the given value will be treated as
       #   a list of types.
       def multiple?(type)
-        (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1
+        array_or_set?(type) && type.size > 1
       end
 
       # Does Grape provide special coercion and validation
@@ -98,17 +98,18 @@ module Grape
         GROUPS.include? type
       end
 
+      def array_or_set?(type)
+        type.is_a?(Array) || type.is_a?(Set)
+      end
+
       # A valid custom type must implement a class-level `parse` method, taking
       # one String argument and returning the parsed value in its correct type.
       #
       # @param type [Class] type to check
       # @return [Boolean] whether or not the type can be used as a custom type
       def custom?(type)
-        !primitive?(type) &&
-          !structure?(type) &&
-          !multiple?(type) &&
-          type.respond_to?(:parse) &&
-          type.method(:parse).arity == 1
+        !(primitive?(type) || structure?(type) || multiple?(type)) &&
+          type.respond_to?(:parse) && type.method(:parse).arity == 1
       end
 
       # Is the declared type an +Array+ or +Set+ of a {#custom?} type?
@@ -117,9 +118,7 @@ module Grape
       # @return [Boolean] true if +type+ is a collection of a type that implements
       #   its own +#parse+ method.
       def collection_of_custom?(type)
-        (type.is_a?(Array) || type.is_a?(Set)) &&
-          type.length == 1 &&
-          (custom?(type.first) || special?(type.first))
+        array_or_set?(type) && type.length == 1 && (custom?(type.first) || special?(type.first))
       end
 
       def map_special(type)
@@ -162,27 +161,21 @@ module Grape
       end
 
       def create_coercer_instance(type, method, strict)
-        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
-        type = Types.map_special(type)
-
-        # Use a special coercer for multiply-typed parameters.
-        if Types.multiple?(type)
-          MultipleTypeCoercer.new(type, method)
-
-          # Use a special coercer for custom types and coercion methods.
-        elsif method || Types.custom?(type)
-          CustomTypeCoercer.new(type, method)
-
-          # Special coercer for collections of types that implement a parse method.
-          # CustomTypeCoercer (above) already handles such types when an explicit coercion
-          # method is supplied.
-        elsif Types.collection_of_custom?(type)
-          Types::CustomTypeCollectionCoercer.new(
-            Types.map_special(type.first), type.is_a?(Set)
-          )
-        else
-          DryTypeCoercer.coercer_instance_for(type, strict)
-        end
+        # map_special doesn't recurse into collections — applied only to the top-level type here.
+        type = map_special(type)
+
+        # Multiply-typed parameters, e.g. types: [Integer, String].
+        return MultipleTypeCoercer.new(type, method) if multiple?(type)
+
+        # User-supplied coercion method, or a custom type with its own #parse.
+        return CustomTypeCoercer.new(type, method) if method || custom?(type)
+
+        # Array/Set of a custom type — CustomTypeCoercer already handles single
+        # custom types when an explicit coercion method is supplied.
+        return CustomTypeCollectionCoercer.new(map_special(type.first), set: type.is_a?(Set)) if collection_of_custom?(type)
+
+        # Fallback: let dry-types handle primitives, structures, and known specials.
+        DryTypeCoercer.coercer_instance_for(type, strict:)
       end
 
       class CoercerCache < Grape::Util::Cache