Single-pass input coercion + validation

[gmac]

Dropping this in here as it could be very good for everyone if we all used the same input coercion process. The GraphQL Ruby one is pretty heavy at the moment and doesn't always match the spec. The code below was assembled in collaboration with Claude over many, many passes through GraphQL-js reference implementations and its tests. We've found that it matches the spec better than GraphQL Ruby, and benchmarks around twice as fast for processing large inputs. It has a few opinions:

• All input coercion and GraphQL Ruby validation is performed during a single traversal pass. Coercion errors are raised immediately at the step where they occur, while validation errors are cached and passed forward to where the input is actually consumed, and raise there upon execution.

• All input is evaluated statically. Arguments are assumed the same across all list objects, and validators always receive nil as their object. Assuming all input can be evaluated statically saves a ton of work.

• All resolved arguments come out as frozen hashes. This allows read-only arguments to come out with frozen variable hashes inlined into their structure without adding an extra traversal of variables. We offer a utility to deep-copy frozen arguments that field resolver can use if desired. Most of the time though, the frozen read-only structure is cheap and sufficient.

Usage:

@input = InputFormatter.new(@context)

# seed the internal cache of variables...
@input.coerce_variable_values(@query.selected_operation.variables, @query.provided_variables)

# format arguments...
arguments, argument_errors = @input.coerce_argument_values(field_definition, field_nodes.first)

class InputFormatter
  #: type input_hash = Hash[String | Symbol, untyped]
  #: type variables_hash = Hash[String, untyped]

  GRAPHQL_PRINTER = GraphQL::Language::Printer.new
  VALUE_CANNOT_BE_NULL = "Expected value to not be null".freeze

  class InputError < ExecutionError
    #: error_path
    attr_reader :path

    #: (
    #|   String message,
    #|   ?path: error_path,
    #|   ?nodes: Array[GraphQL::Language::Nodes::AbstractNode],
    #|   ?extensions: extensions_hash?
    #| ) -> void
    def initialize(message, path: EMPTY_ARRAY, nodes: EMPTY_ARRAY, extensions: nil)
      @path = path
      super(message, nodes:, extensions:)
    end
  end

  class InputCoercionError < InputError; end
  class InputValidatorError < InputError; end
  class InputValidationErrorSet < ExecutionError
    #: Array[ExecutionError]
    attr_reader :errors

    #: (
    #|   ?String?,
    #|   ?exec_field: GraphQL::BreadthExec::Executor::ExecutionField?,
    #|   ?errors: Array[ExecutionError]
    #| ) -> void
    def initialize(message = nil, exec_field: nil, errors: [])
      @errors = errors
      super(message || errors.map(&:message).join(", "), exec_field:)
    end

    #: (
    #|   ?String?,
    #|   ?extensions: extensions_hash?,
    #|   ?cause: Exception?
    #| ) -> ExecutionErrorSet
    def add_error(message = nil, extensions: nil, cause: nil)
      @errors << ExecutionError.new(message, exec_field:, extensions:, cause:)
      self
    end

    # @override
    #: () -> Array[GraphQL::Language::Nodes::AbstractNode]
    def nodes
      @errors.flat_map(&:nodes)
    end

    # @override
    #: () { (ExecutionError) -> void } -> void
    def each(&block)
      @errors.each(&block)
    end
  end

  # Maintains a partial state cache for an individual input traversal
  # this would allow many traversals to be parallelized against a shared input cache
  class State
    #: error_path
    attr_reader :path

    #: Array[InputCoercionError]
    attr_reader :coercion_errors

    #: Array[InputValidatorError]
    attr_reader :validator_errors

    #: GraphQL::Language::Nodes::AbstractNode?
    attr_accessor :current_node

    def initialize
      @coercion_errors = EMPTY_ARRAY
      @validator_errors = EMPTY_ARRAY
      @path = EMPTY_ARRAY
    end

    #: (String | Integer) -> untyped
    def add_path(segment)
      @path = [] if @path.frozen?
      @path << segment
      return nil unless block_given?

      begin
        yield
      ensure
        @path.pop
      end
    end

    #: (String | InputCoercionError, ?extensions: extensions_hash?) -> Util::NilLike
    def add_coercion_error(err, extensions: nil)
      err = InputCoercionError.new(err, nodes: current_node ? [current_node] : EMPTY_ARRAY, path: @path.dup, extensions:) if err.is_a?(String)
      @coercion_errors = [] if @coercion_errors.frozen?
      @coercion_errors << err
      UNDEFINED
    end

    #: (String | InputValidatorError, ?extensions: extensions_hash?) -> Util::NilLike
    def add_validator_error(err, extensions: nil)
      err = InputValidatorError.new(err, nodes: current_node ? [current_node] : EMPTY_ARRAY, path: @path.dup, extensions:) if err.is_a?(String)
      @validator_errors = [] if @validator_errors.frozen?
      @validator_errors << err
      UNDEFINED
    end

    #: () -> State
    def reset!
      self.current_node = nil
      @coercion_errors.clear unless @coercion_errors.frozen?
      @validator_errors.clear unless @validator_errors.frozen?
      @path.clear unless @path.frozen?
      self
    end
  end

  #: variables_hash
  attr_reader :variables

  #: Hash[String, Array[InputValidatorError]]
  attr_reader :variable_validator_errors

  #: bool
  attr_accessor :symbolize_keys

  #: (GraphQL::Query::Context, ?symbolize_keys: bool) -> void
  def initialize(context, symbolize_keys: true)
    @context = context
    @variables = EMPTY_OBJECT
    @variable_validator_errors = EMPTY_OBJECT
    @symbolize_keys = symbolize_keys
    @default_state = State.new
  end

  #: -> bool
  def symbolize_keys? = @symbolize_keys

  # based on graphql.js typeFromAST
  #: (untyped) -> singleton(GraphQL::Schema::Member)?
  def type_from_ast(node)
    case node
    when GraphQL::Language::Nodes::ListType
      type_from_ast(node.of_type)&.to_list_type
    when GraphQL::Language::Nodes::NonNullType
      type_from_ast(node.of_type)&.to_non_null_type
    else
      @context.types.type(node.name)
    end
  end

  # based on graphql.js coerceVariableValues
  #: (
  #|   Array[GraphQL::Language::Nodes::VariableDefinition] var_nodes,
  #|   input_hash inputs,
  #|   ?state: State,
  #| ) -> variables_hash
  def coerce_variable_values(var_nodes, inputs, state: @default_state.reset!)
    return @variables if var_nodes.empty? && inputs.empty?

    variable_errors = []
    @variables = {}

    var_nodes.each do |var_node|
      # top-level variable name always remains keyed in unmodified string form...
      var_name = var_node.name
      var_type = type_from_ast(var_node.type)
      value = fetch_with_indifferent_access(inputs, var_name)

      # Variable defines a bogus input type? (ie: Object, Interface, or Union)
      if var_type.nil? || !var_type.unwrap.kind.input?
        type_node = var_node.type #: untyped
        type_node = type_node.of_type while type_node.is_a?(GraphQL::Language::Nodes::WrapperType)

        # This should only ever manifest during static validations,
        # which precedes/short-circuits the variable validation pass.
        # This outcome is only included as a redundancy safeguard.
        variable_errors << InputCoercionError.new(
          "#{type_node.name} isn't a valid input type (on $#{var_name})",
          nodes: [var_node],
        )

      elsif value.equal?(UNDEFINED)
        if !var_node.default_value.nil?
          # Calling `value_from_ast` should never error here assuming the document is properly validated
          @variables[var_name] = value_from_ast(var_node.default_value, var_type, state:)
        elsif var_type.non_null?
          variable_errors << InputCoercionError.new(
            "Variable \"$#{var_name}\" of required type \"#{var_type.to_type_signature}\" was not provided.",
            nodes: [var_node],
            extensions: {
              "value" => nil,
              "problems" => [{ "path" => [], "explanation" => VALUE_CANNOT_BE_NULL }],
            },
          )
        end

      elsif value.nil? && var_type.non_null?
        variable_errors << InputCoercionError.new(
          "Variable \"$#{var_name}\" of non-null type \"#{var_type.to_type_signature}\" must not be null.",
          nodes: [var_node],
          extensions: {
            "value" => nil,
            "problems" => [{ "path" => [], "explanation" => VALUE_CANNOT_BE_NULL }],
          },
        )

      else
        # Coerce the provided value into the named variable field, and collect any value coercion errors.
        state.current_node = var_node
        @variables[var_name] = coerce_input_value(value, var_type, state:)
      end
    rescue InputCoercionError => e
      state.add_coercion_error(e)
    ensure
      unless state.coercion_errors.empty?
        message = "Variable $#{var_name} of type #{var_type&.to_type_signature} was provided invalid value"

        unless state.coercion_errors.first.path.empty?
          error_descs = state.coercion_errors.map { "#{_1.path.join(".")} (#{_1.message.sub(/\.$/, "")})" }
          message << " for #{error_descs.join(", ")}"
        end

        extensions = state.coercion_errors.each_with_object({}) { |obj, ext| ext.merge!(obj.extensions) if obj.extensions }
        extensions["value"] = value
        extensions["problems"] = state.coercion_errors.map { { "path" => _1.path, "explanation" => _1.message } }

        variable_errors << InputCoercionError.new(
          message,
          nodes: [var_node],
          extensions:,
        )
      end

      unless state.validator_errors.empty?
        # variable validator errors get stored for later to be incorporated while coercing arguments
        @variable_validator_errors = {} if @variable_validator_errors.frozen?
        @variable_validator_errors[var_name] = state.validator_errors.dup
      end

      state.reset!
    end

    raise InputValidationErrorSet.new(errors: variable_errors) unless variable_errors.empty?

    @variables.freeze
  end

  # based on graphql.js getVariableValues
  # The "variables" argument assumes the provided variables have already been coerced.
  #: (
  #|   GraphQL::Schema::Field | singleton(GraphQL::Schema::Directive),
  #|   (GraphQL::Language::Nodes::Field | GraphQL::Language::Nodes::Directive)?,
  #|   ?variables: variables_hash,
  #|   ?state: State,
  #| ) -> [graphql_arguments, Array[InputError]]
  def coerce_argument_values(member, node, variables: @variables, state: @default_state.reset!)
    arg_defs = @context.types.arguments(member)
    arg_nodes = node&.arguments || EMPTY_ARRAY
    return [EMPTY_OBJECT, EMPTY_ARRAY] if arg_defs.empty?

    arguments = {}
    argument_errors = []
    arg_nodes_by_name = arg_nodes.each_with_object({}) do |arg_node, acc|
      acc[arg_node.name] = arg_node
    end

    arg_defs.each do |arg|
      arg_node = arg_nodes_by_name[arg.graphql_name]
      arg_key = symbolize_keys? ? arg.keyword : arg.graphql_name
      state.add_path(arg.graphql_name)
      state.current_node = arg_node

      if arg_node.nil?
        if arg.default_value?
          arg_value = format_default_value(arg.default_value, arg.type, state:)
          arguments[arg_key] = validate_value(arg, arg_value, state:)
        elsif arg.type.non_null?
          argument_errors << InputCoercionError.new(
            "Argument \"#{arg.graphql_name}\" of required type \"#{arg.type.to_type_signature}\" was not provided.",
            nodes: node ? [node] : EMPTY_ARRAY,
          )
        end
        next
      end

      value_node = arg_node.value
      is_null = false

      if value_node.is_a?(GraphQL::Language::Nodes::NullValue)
        is_null = true

      elsif value_node.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
        variable_value = (variables || EMPTY_OBJECT).fetch(value_node.name, UNDEFINED)
        if variable_value.equal?(UNDEFINED)
          if arg.default_value?
            state.current_node = value_node
            arg_value = format_default_value(arg.default_value, arg.type, state:)
            arguments[arg_key] = validate_value(arg, arg_value, state:)
          elsif arg.type.non_null?
            argument_errors << InputCoercionError.new(
              "Argument \"#{arg.graphql_name}\" of required type \"#{arg.type.to_type_signature}\" " \
                "was provided the variable \"$#{value_node.name}\" which was not provided a runtime value.",
              nodes: [value_node],
            )
          end
          next
        end

        is_null = variable_value.nil?
      end

      if is_null && arg.type.non_null?
        argument_errors << InputCoercionError.new(
          "Argument \"#{arg.graphql_name}\" of non-null type \"#{arg.type.to_type_signature}\" must not be null.",
          nodes: [value_node],
        )
        next
      end

      arg_value = value_from_ast(value_node, arg.type, variables:, state:)
      if arg_value.equal?(UNDEFINED)
        argument_errors << InputCoercionError.new(
          "Argument \"#{arg.graphql_name}\" has invalid value #{print_node(value_node)}",
          nodes: [value_node],
        )
        next
      end

      arguments[arg_key] = validate_value(arg, arg_value, state:)

      argument_errors.concat(state.validator_errors) unless state.validator_errors.empty?
    ensure
      state.reset!
    end

    if !argument_errors.empty? && argument_errors.any?(InputCoercionError)
      # If we got here, then GraphQL Ruby passed something that BreadthExec didn't (implies a BreadthExec bug)
      # Report the error rather than raising so that shimmed fields can still use GraphQL Ruby values
      GraphQL::BreadthExec.report_error(InputValidationErrorSet.new(errors: argument_errors.grep(InputCoercionError)))
      arguments = EMPTY_OBJECT
    else
      # otherwise, validate the resolved field argument structure
      validate_value(member, arguments, state:)
      validate_value(member.resolver, arguments, state:, as: member) if member.is_a?(GraphQL::Schema::Field) && member.resolver
      argument_errors.concat(state.validator_errors) unless state.validator_errors.empty?
    end

    [arguments.freeze, argument_errors]
  end

  # based on graphql.js coerceInputValue
  #: (
  #|   untyped input_value,
  #|   untyped type,
  #|   ?state: State,
  #| ) -> untyped
  def coerce_input_value(input_value, type, state: State.new)
    if type.non_null?
      if !input_value.nil?
        coerce_input_value(input_value, type.of_type, state:)
      else
        # this check is already covered by the main coerce_variable_values loop
        state.add_coercion_error("Non-null type cannot be null.")
      end

    elsif input_value.nil?
      nil

    elsif type.list?
      item_type = type.of_type

      if input_value.is_a?(Array)
        input_value.map.with_index do |item, index|
          state.add_path(index) { coerce_input_value(item, item_type, state:) }
        end.freeze
      else
        # Lists accept a non-list value as a set of one.
        item_value = state.add_path(0) { coerce_input_value(input_value, item_type, state:) }
        [item_value].freeze
      end

    elsif type.kind.input_object?
      unless input_value.is_a?(Hash)
        return state.add_coercion_error("Expected type \"#{type.graphql_name}\" to be an object.")
      end

      coerced_obj = {}

      arg_defs_by_name = arguments_map_for_type(type)
      arg_defs_by_name.each_value do |arg|
        state.add_path(arg.graphql_name)
        arg_key = symbolize_keys? ? arg.keyword : arg.graphql_name
        arg_value = fetch_with_indifferent_access(input_value, arg.graphql_name)
        if arg_value.equal?(UNDEFINED)
          if arg.default_value?
            arg_value = format_default_value(arg.default_value, arg.type, state:)
            coerced_obj[arg_key] = validate_value(arg, arg_value, state:)
          elsif arg.type.non_null?
            state.add_coercion_error("Field \"#{arg.graphql_name}\" of required type \"#{arg.type.to_type_signature}\" was not provided.")
          end
          next
        end

        arg_value = coerce_input_value(arg_value, arg.type, state:)
        coerced_obj[arg_key] = validate_value(arg, arg_value, state:)
      ensure
        state.path.pop
      end

      if input_value.size > coerced_obj.size
        input_value.each_key do |field_name|
          unless arg_defs_by_name.key?(field_name.to_s)
            state.add_coercion_error("Field \"#{field_name}\" is not defined by type \"#{type.graphql_name}\".")
          end
        end
      end

      if one_of_input_object?(type)
        if coerced_obj.size != 1
          state.add_coercion_error("Exactly one key must be specified for OneOf type \"#{type.graphql_name}\".")
        end

        coerced_obj.each do |arg_key, value|
          next unless value.nil?

          state.add_coercion_error("Exactly one value must be specified for OneOf type \"#{type.graphql_name}\", but \"#{arg_key}\" was null.")
        end
      end

      validate_value(type, coerced_obj.freeze, state:)
    elsif type.kind.leaf?
      result = begin
        type.coerce_input(input_value, @context)
      rescue GraphQL::ExecutionError => e
        return state.add_coercion_error(e.message, extensions: e.extensions)
      rescue StandardError => e
        return state.add_coercion_error("Expected type \"#{type.graphql_name}\".")
      end

      if result.nil?
        if type.kind.enum?
          # variable validation (see test_errors_for_incorrect_variable_enums)
          state.add_coercion_error("Value does not exist in '#{type.graphql_name}' enum.")
        elsif type.default_scalar?
          # variable validation (see test_errors_for_incorrect_variable_values)
          state.add_coercion_error("Cannot represent non-#{type.graphql_name} value.")
        end
      end

      result
    else
      raise InputCoercionError, "Unexpected input type: #{type.graphql_name}."
    end
  end

  # based on graphql.js valueFromAST
  # This method should never raise errors in a validated document,
  # because we know that everything is correct by the AST.
  #: (
  #|   GraphQL::Language::Nodes::AbstractNode? | Array[GraphQL::Language::Nodes::AbstractNode] value_node,
  #|   untyped type,
  #|   ?variables: variables_hash?,
  #|   ?state: State,
  #| ) -> untyped
  def value_from_ast(value_node, type, variables: nil, state: State.new)
    if value_node.nil?
      state.add_coercion_error("Expected value node to be non-null.")

    elsif value_node.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
      var_name = value_node.name
      variable_value = (variables || EMPTY_OBJECT).fetch(var_name, UNDEFINED)
      if variable_value.equal?(UNDEFINED)
        return state.add_coercion_error("Expected variable $#{var_name} to be defined.")
      end

      if variable_value.nil? && type.non_null?
        return state.add_coercion_error("Expected variable $#{var_name} to be non-null.")
      end

      # Add all runtime errors that were cached for this variable field
      @variable_validator_errors.fetch(var_name, EMPTY_ARRAY).each do |e|
        state.add_validator_error(InputValidatorError.new(e.message, nodes: e.nodes.dup, path: state.path + e.path))
      end

      variable_value
    elsif type.non_null?
      if value_node.is_a?(GraphQL::Language::Nodes::NullValue)
        return state.add_coercion_error("Expected value node to be non-null.")
      end

      value_from_ast(value_node, type.of_type, variables:, state:)
    elsif value_node.is_a?(GraphQL::Language::Nodes::NullValue)
      nil
    elsif type.list?
      item_type = type.of_type

      if value_node.is_a?(Array)
        coerced_items = []
        value_node.each_with_index do |item_node, index|
          item_value = state.add_path(index) do
            if missing_variable?(item_node, variables)
              return state.add_coercion_error("Expected item to be non-null.") if item_type.non_null?

              nil
            else
              value_from_ast(item_node, item_type, variables:, state:)
            end
          end
          return UNDEFINED if item_value.equal?(UNDEFINED)

          coerced_items << item_value
        end
        coerced_items.freeze
      else
        # Lists accept a non-list value as a set of one.
        item_value = state.add_path(0) { value_from_ast(value_node, item_type, variables:, state:) }
        return UNDEFINED if item_value.equal?(UNDEFINED)

        [item_value].freeze
      end

    elsif type.kind.input_object?
      unless value_node.is_a?(GraphQL::Language::Nodes::InputObject)
        return state.add_coercion_error("Expected value node to be an input object.")
      end

      coerced_obj = {}
      arg_nodes_by_name = value_node.arguments.each_with_object({}) do |arg_node, acc|
        acc[arg_node.name] = arg_node
      end

      @context.types.arguments(type).each do |arg|
        arg_node = arg_nodes_by_name[arg.graphql_name]
        arg_key = symbolize_keys? ? arg.keyword : arg.graphql_name
        state.add_path(arg.graphql_name)
        state.current_node = arg_node

        if arg_node.nil? || missing_variable?(arg_node.value, variables)
          if arg.default_value?
            arg_value = format_default_value(arg.default_value, arg.type, state:)
            coerced_obj[arg_key] = validate_value(arg, arg_value, state:)
          elsif arg.type.non_null?
            return state.add_coercion_error("Expected argument \"#{arg.graphql_name}\" to be non-null.")
          end
          next
        end

        arg_value = value_from_ast(arg_node.value, arg.type, variables:, state:)
        return UNDEFINED if arg_value.equal?(UNDEFINED)

        coerced_obj[arg_key] = validate_value(arg, arg_value, state:)
      ensure
        state.path.pop
      end

      if one_of_input_object?(type)
        if coerced_obj.size != 1
          return state.add_coercion_error("Exactly one key must be specified for OneOf type \"#{type.graphql_name}\".")
        end

        coerced_obj.each do |arg_key, value|
          if value.nil?
            return state.add_coercion_error("Exactly one value must be specified for OneOf type \"#{type.graphql_name}\", but \"#{arg_key}\" was null.")
          end
        end
      end

      validate_value(type, coerced_obj.freeze, state:)
    elsif type.kind.leaf?
      if type.kind.enum?
        if value_node.is_a?(GraphQL::Language::Nodes::Enum)
          value_node = value_node.name
        else
          return state.add_coercion_error("Expected value node to be an enum.")
        end
      end

      result = begin
        type.coerce_input(value_node, @context)
      rescue GraphQL::ExecutionError => e
        return state.add_coercion_error(e.message, extensions: e.extensions)
      rescue StandardError => e
        return state.add_coercion_error("Expected type \"#{type.graphql_name}\".")
      end

      # default scalar values (String, Int, Boolean, etc.) cannot be nil
      if result.nil? && type.kind.scalar? && type.default_scalar?
        return state.add_coercion_error("Cannot represent non-#{type.graphql_name} value.")
      end

      result
    else
      raise InputCoercionError, "Unexpected input type: #{type.graphql_name}."
    end
  end

  #: (
  #|   untyped default_value,
  #|   untyped type,
  #|   ?state: State,
  #| ) -> untyped
  def format_default_value(default_value, type, state: State.new)
    return default_value if default_value.nil?

    # Unwrap non-null wrapper since default values don't need null checking
    type = type.of_type while type.non_null?

    if type.list?
      if default_value.is_a?(Array)
        default_value.map.with_index do |item, index|
          state.add_path(index) { format_default_value(item, type.of_type, state:) }
        end.freeze
      else
        # Lists accept a non-list value as a set of one.
        item_value = state.add_path(0) { format_default_value(default_value, type.of_type, state:) }
        [item_value].freeze
      end
    elsif type.kind.input_object?
      unless default_value.is_a?(Hash)
        # should never happen in a valid document
        return state.add_coercion_error("Expected default value for type \"#{type.graphql_name}\" to be an object.")
      end

      coerced_obj = {}
      arg_defs_by_name = arguments_map_for_type(type)
      default_value.each do |key, value|
        arg = arg_defs_by_name[key.to_s]
        if arg.nil?
          # should never happen in a valid document
          state.add_coercion_error("Invalid default field \"#{key}\" for type \"#{type.graphql_name}\".")
          next
        end

        state.add_path(arg.graphql_name) do
          arg_key = symbolize_keys? ? arg.keyword : arg.graphql_name
          arg_value = format_default_value(value, arg.type, state:)
          coerced_obj[arg_key] = validate_value(arg, arg_value, state:)
        end
      end

      # don't validate this – it's not a complete value
      coerced_obj.freeze
    else
      default_value
    end
  end

  #: (untyped, untyped, ?state: State, ?as: untyped) -> untyped
  def validate_value(member, value, state: State.new, as: nil)
    unless member.validators.empty?
      member.validators.each do |validator|
        # Always validate statically with no object.
        # BreadthExec does not support object-contextual arguments.
        result = validator.validate(nil, @context, value)
        next if result.nil? || result.empty?

        interpolation_vars = { validated: (as || member).graphql_name, value: value.inspect }

        case result
        when String
          state.add_validator_error(result % interpolation_vars)
        when Array
          result.each { |err| state.add_validator_error(err % interpolation_vars) }
        else
          raise ImplementationError, "Unexpected argument validation result: #{result.class}."
        end
      end
    end

    value
  end

  private

  #: (input_hash, String, ?default: untyped) -> untyped
  def fetch_with_indifferent_access(input, key, default: UNDEFINED)
    input.fetch(key) { input.fetch(key.to_sym, default) }
  end

  #: (GraphQL::Language::Nodes::AbstractNode) -> String
  def print_node(node)
    GRAPHQL_PRINTER.print(node)
  end

  #: (
  #|   GraphQL::Language::Nodes::AbstractNode? | Array[GraphQL::Language::Nodes::AbstractNode] value_node,
  #|   variables_hash? variables,
  #| ) -> bool
  def missing_variable?(value_node, variables)
    if value_node.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
      variables.nil? || !variables.key?(value_node.name)
    else
      false
    end
  end

  #: (singleton(GraphQL::Schema::InputObject)) -> bool
  def one_of_input_object?(type)
    @one_of_types ||= {}.compare_by_identity
    @one_of_types.fetch(type) do
      @one_of_types[type] = !type.directives.empty? && type.directives.any? { _1.graphql_name == "oneOf" }
    end
  end

  #: (GraphQL::Schema::Member type) -> Hash[String, GraphQL::Schema::Argument]
  def arguments_map_for_type(type)
    @arguments_map_by_type ||= {}.compare_by_identity
    @arguments_map_by_type[type] ||= @context.types.arguments(type).each_with_object({}) do |arg, memo|
      memo[arg.graphql_name] = arg
    end
  end
end

[gmac]

Comes with a whopping test suite...

class InputFormatterTest < Minitest::Test
  UNDEFINED = GraphQL::BreadthExec::Executor::UNDEFINED

  TEST_SCHEMA = GraphQL::Schema.from_definition(%|
    enum TestStatus {
      ACTIVE
      INACTIVE
    }

    input NestedInput {
      value: String
      nested: NestedInput
    }

    input TestInput {
      string: String
      int: Int
      float: Float
      boolean: Boolean
      id: ID
      enum: TestStatus
      nested: NestedInput
      stringList: [String]
      nonNullItemList: [String!]
      nestedList: [NestedInput]
    }

    input RequiredFieldsInput {
      required: String!
      optional: String
    }

    input ValidatedFieldsInput {
      scalar: String
      list: [String]
      input: ValidatedFieldsInput
      inputList: [ValidatedFieldsInput]
    }

    input OneOfInput @oneOf {
      string: String
      int: Int
    }

    type Mutation {
      testInput(input: TestInput): Boolean
      requiredFields(input: RequiredFieldsInput!): Boolean
      argWithDefault(input: String = "fallback-value"): Boolean
      oneOf(input: OneOfInput!): Boolean
      validates(input: ValidatedFieldsInput!): Boolean
      validatesOneArg(a: String, b: String): Boolean
    }

    type Query {
      ping: Boolean
    }
  |)

  TEST_SCHEMA.mutation.fields["validatesOneArg"].tap do |f|
    f.validates(required: { one_of: [:a, :b] })
  end

  TEST_SCHEMA.get_type("ValidatedFieldsInput").tap do |t|
    t.arguments["scalar"].validates(length: { minimum: 2 })
    t.arguments["list"].validates(length: { minimum: 2 })
  end

  def setup
    @context = GraphQL::Query.new(TEST_SCHEMA, "{ __typename }").context
    @input = GraphQL::BreadthExec::Executor::InputFormatter.new(@context)
    @state = GraphQL::BreadthExec::Executor::InputFormatter::State.new
  end

  # === type_from_ast ===

  def test_type_from_ast_named_type
    type_string = "String"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_equal(GraphQL::Types::String, result)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_non_null_type
    type_string = "String!"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_predicate(result, :non_null?)
    assert_equal(GraphQL::Types::String, result.of_type)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_list_type
    type_string = "[String]"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_predicate(result, :list?)
    assert_equal(GraphQL::Types::String, result.of_type)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_non_null_list_type
    type_string = "[String]!"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_predicate(result, :non_null?)
    assert_predicate(result.of_type, :list?)
    assert_equal(GraphQL::Types::String, result.of_type.of_type)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_list_of_non_null_type
    type_string = "[String!]"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_predicate(result, :list?)
    assert_predicate(result.of_type, :non_null?)
    assert_equal(GraphQL::Types::String, result.of_type.of_type)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_non_null_list_of_non_null_type
    type_string = "[String!]!"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_predicate(result, :non_null?)
    assert_predicate(result.of_type, :list?)
    assert_predicate(result.of_type.of_type, :non_null?)
    assert_equal(GraphQL::Types::String, result.of_type.of_type.of_type)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_nested_list_type
    type_string = "[[Int]]"
    result = @input.type_from_ast(get_type_node(type_string))

    assert_predicate(result, :list?)
    assert_predicate(result.of_type, :list?)
    assert_equal(GraphQL::Types::Int, result.of_type.of_type)
    assert_equal(type_string, result.to_type_signature)
  end

  def test_type_from_ast_unknown_type_returns_nil
    assert_nil @input.type_from_ast(get_type_node("UnknownType"))
  end

  # === coerce_variable_values ===

  def test_coerce_variable_values_empty_inputs_returns_empty
    var_defs = get_variables_ast("")
    result = @input.coerce_variable_values(var_defs, {})

    assert_equal({}, result)
  end

  def test_coerce_variable_values_non_input_type_raises_error
    var_defs = get_variables_ast("$value: Query")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, { "value" => {} })
    end

    assert_equal(1, error.errors.size)
    assert_equal("Query isn't a valid input type (on $value)", error.errors.first&.message)
  end

  def test_coerce_variable_values_unknown_type_raises_error
    var_defs = get_variables_ast("$value: UnknownType!")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, { "value" => "anything" })
    end

    assert_equal(1, error.errors.size)
    assert_match(/UnknownType isn't a valid input type/, error.errors.first&.message)
  end

  def test_coerce_variable_values_with_valid_variable
    var_defs = get_variables_ast("$name: String")
    result = @input.coerce_variable_values(var_defs, { "name" => "hello" })

    assert_equal({ "name" => "hello" }, result)
  end

  def test_coerce_variable_values_always_keeps_root_variable_names_as_natural_string_keys
    var_defs = get_variables_ast("$my_fancyVar: TestInput")
    vars_input = { "my_fancyVar" => { "stringList" => ["a", "b"] } }

    @input.symbolize_keys = true
    result = @input.coerce_variable_values(var_defs, vars_input)
    assert_equal({ "my_fancyVar" => { string_list: ["a", "b"] } }, result)

    @input.symbolize_keys = false
    result = @input.coerce_variable_values(var_defs, vars_input)
    assert_equal({ "my_fancyVar" => { "stringList" => ["a", "b"] } }, result)
  end

  def test_coerce_variable_values_applies_default_when_not_provided
    var_defs = get_variables_ast('$name: String = "default"')
    result = @input.coerce_variable_values(var_defs, {})

    assert_equal({ "name" => "default" }, result)
  end

  def test_coerce_variable_values_raises_error_when_non_null_isnt_provided
    var_defs = get_variables_ast("$name: String!")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, {})
    end

    assert_equal(1, error.errors.size)
    assert_equal('Variable "$name" of required type "String!" was not provided.', error.errors.first&.message)
  end

  def test_coerce_variable_values_raises_error_when_non_null_provided_as_null
    var_defs = get_variables_ast("$name: String!")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, { "name" => nil })
    end

    assert_equal(1, error.errors.size)
    assert_equal('Variable "$name" of non-null type "String!" must not be null.', error.errors.first&.message)
  end

  def test_coerce_variable_values_nullable_variable_with_no_value_is_unset
    var_defs = get_variables_ast("$name: String")
    result = @input.coerce_variable_values(var_defs, {})

    assert_equal({}, result)
  end

  def test_coerce_variable_values_nullable_variable_with_null_value_is_null
    var_defs = get_variables_ast("$name: String")
    result = @input.coerce_variable_values(var_defs, { "name" => nil })

    assert_equal({ "name" => nil }, result)
  end

  def test_coerce_variable_values_invalid_value_raises_error
    var_defs = get_variables_ast("$count: Int")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, { "count" => "not-an-int" })
    end

    assert_equal(1, error.errors.size)
    assert_equal('Variable $count of type Int was provided invalid value', error.errors.first&.message)
  end

  def test_coerce_variable_values_formats_multiple_variables
    var_defs = get_variables_ast("$a: String!, $b: Int")
    result = @input.coerce_variable_values(var_defs, { "a" => "hello", "b" => 42 })

    assert_equal({ "a" => "hello", "b" => 42 }, result)
  end

  def test_coerce_variable_values_raises_error_for_list_of_non_null_containing_null
    var_defs = get_variables_ast("$input: [String!]")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, { "input" => ["A", nil, "B"] })
    end

    assert_equal(1, error.errors.size)
    assert_equal("Variable $input of type [String!] was provided invalid value for 1 (Non-null type cannot be null)", error.errors.first&.message)
  end

  def test_coerce_variable_values_raises_with_multiple_errors
    var_defs = get_variables_ast("$a: String!, $b: Int!")

    error = assert_raises(GraphQL::BreadthExec::InputValidationErrorSet) do
      @input.coerce_variable_values(var_defs, {})
    end

    assert_equal(2, error.errors.size)
  end

  def test_coerce_variable_values_stores_runtime_validation_errors_by_variable_name
    var_defs = get_variables_ast("$myVar: ValidatedFieldsInput")
    result = @input.coerce_variable_values(var_defs, { "myVar" => { "scalar" => "a" } })

    assert_equal({ "myVar" => { scalar: "a" } }, result)
    assert_equal(["myVar"], @input.variable_validator_errors.keys)
    assert_equal(["scalar is too short (minimum is 2)"], @input.variable_validator_errors["myVar"]&.map(&:message))
  end

  # === coerce_argument_values ===

  def test_coerce_argument_values_returns_empty_for_empty_args
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node("testInput")
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({}, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_coerces_literal_string_value
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: { string: "hello" })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ input: { string: "hello" } }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_coerces_complex_input
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: { string: "foo", stringList: ["bar"], int: 42 })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ input: { string: "foo", string_list: ["bar"], int: 42 } }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_coerces_single_value_into_list
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: { stringList: "single" })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ input: { string_list: ["single"] } }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_preserves_null_values_in_list
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: { stringList: ["A", null, "C"] })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ input: { string_list: ["A", nil, "C"] } }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_invalidates_lists_with_invalid_items
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: { nonNullItemList: ["A", null, "C"] })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({}, result)
    assert_equal(1, errors.size)
    assert_equal('Argument "input" has invalid value {nonNullItemList: ["A", null, "C"]}', errors.first&.message)
  end

  def test_coerce_argument_values_uses_default_when_argument_not_provided
    field_def = get_root_field("mutation", "argWithDefault")
    field_node = get_field_node("argWithDefault")
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ input: "fallback-value" }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_returns_error_for_missing_non_null_argument
    field_def = get_root_field("mutation", "requiredFields")
    field_node = get_field_node("requiredFields")
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({}, result)
    assert_equal(1, errors.size)
    assert_equal('Argument "input" of required type "RequiredFieldsInput!" was not provided.', errors.first&.message)
  end

  def test_coerce_argument_values_uses_default_when_variable_not_provided
    field_def = get_root_field("mutation", "argWithDefault")
    field_node = get_field_node("argWithDefault(input: $myVar)")
    result, errors = @input.coerce_argument_values(field_def, field_node, variables: {})

    assert_equal({ input: "fallback-value" }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_returns_error_for_missing_non_null_variable
    field_def = get_root_field("mutation", "requiredFields")
    field_node = get_field_node("requiredFields(input: $myVar)")
    result, errors = @input.coerce_argument_values(field_def, field_node, variables: {})

    assert_equal({}, result)
    assert_equal(1, errors.size)
    assert_equal('Argument "input" of required type "RequiredFieldsInput!" was provided the variable "$myVar" which was not provided a runtime value.', errors.first&.message)
  end

  def test_coerce_argument_values_returns_error_for_null_on_non_null_argument
    field_def = get_root_field("mutation", "requiredFields")
    field_node = get_field_node("requiredFields(input: null)")
    result, errors = @input.coerce_argument_values(field_def, field_node, variables: {})

    assert_equal({}, result)
    assert_equal(1, errors.size)
    assert_equal('Argument "input" of non-null type "RequiredFieldsInput!" must not be null.', errors.first&.message)
  end

  def test_coerce_argument_values_returns_error_for_null_variable_on_non_null_argument
    field_def = get_root_field("mutation", "requiredFields")
    field_node = get_field_node("requiredFields(input: $myVar)")
    result, errors = @input.coerce_argument_values(field_def, field_node, variables: { "myVar" => nil })

    assert_equal({}, result)
    assert_equal(1, errors.size)
    assert_equal('Argument "input" of non-null type "RequiredFieldsInput!" must not be null.', errors.first&.message)
  end

  def test_coerce_argument_values_returns_error_for_invalid_value
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: ["foo", "bar"])')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({}, result)
    assert_equal(1, errors.size)
    assert_equal('Argument "input" has invalid value ["foo", "bar"]', errors.first&.message)
  end

  def test_coerce_argument_values_reports_error_for_coercion_errors
    field_def = get_root_field("mutation", "requiredFields")
    field_node = get_field_node('requiredFields(input: null)')

    reported = assert_error_reported(InputValidationErrorSet) do
      result, errors = @input.coerce_argument_values(field_def, field_node)

      assert_equal({}, result)
      assert_equal(1, errors.size)
      assert_instance_of(InputCoercionError, errors.first)
    end #: as GraphQL::BreadthExec::InputValidationErrorSet

    assert_equal(1, reported.errors.size)
    assert_equal('Argument "input" of non-null type "RequiredFieldsInput!" must not be null.', reported.message)
  end

  def test_coerce_argument_values_coerces_variable_value
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node("testInput(input: $inputVar)")
    result, errors = @input.coerce_argument_values(field_def, field_node, variables: { "inputVar" => { string: "from-var" } })

    assert_equal({ input: { string: "from-var" } }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_formats_keys_as_strings_when_symbolize_keys_disabled
    @input.symbolize_keys = false
    field_def = get_root_field("mutation", "testInput")
    field_node = get_field_node('testInput(input: { stringList: ["hello"], nested: { value: "deep" } })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ "input" => { "stringList" => ["hello"], "nested" => { "value" => "deep" } } }, result)
    assert_empty(errors)
  end

  def test_coerce_argument_values_runs_validators_on_arguments
    field_def = get_root_field("mutation", "validates")
    field_node = get_field_node('validates(input: { scalar: "a" })')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ input: { scalar: "a" } }, result)
    assert_equal(1, errors.size)
    assert_equal("scalar is too short (minimum is 2)", errors.first&.message)
  end

  def test_coerce_argument_values_runs_validators_on_fields
    field_def = get_root_field("mutation", "validatesOneArg")
    field_node = get_field_node('validatesOneArg(a: "a", b: "b")')
    result, errors = @input.coerce_argument_values(field_def, field_node)

    assert_equal({ a: "a", b: "b" }, result)
    assert_equal(1, errors.size)
    assert_equal("validatesOneArg must include exactly one of the following arguments: a, b.", errors.first&.message)
  end

  # === coerce_input_value ===

  def test_coerce_input_value_coerces_valid_non_null_value
    type = get_type("String!")
    result = @input.coerce_input_value("hello", type, state: @state)

    assert_equal("hello", result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_null_on_non_null_type
    type = get_type("String!")
    result = @input.coerce_input_value(nil, type, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Non-null type cannot be null.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_returns_nil_for_null_on_nullable_type
    type = get_type("String")
    result = @input.coerce_input_value(nil, type, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_coerces_array_for_list_type
    type = get_type("[String]")
    result = @input.coerce_input_value(["a", "b", "c"], type, state: @state)

    assert_equal(["a", "b", "c"], result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_wraps_single_value_as_array_for_list_type
    type = get_type("[String]")
    result = @input.coerce_input_value("single", type, state: @state)

    assert_equal(["single"], result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_with_path_for_single_invalid_list_value
    type = get_type("[Int]")
    result = @input.coerce_input_value("not-an-int", type, state: @state)

    assert_equal([nil], result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([0], @state.coercion_errors[0].path)
    assert_equal("Cannot represent non-Int value.", @state.coercion_errors[0].message)
  end

  def test_coerce_input_value_returns_nil_for_null_on_list_type
    type = get_type("[String]")
    result = @input.coerce_input_value(nil, type, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_at_index_for_invalid_list_item
    type = get_type("[Int]")
    result = @input.coerce_input_value([1, "not-an-int", 3], type, state: @state)

    assert_equal([1, nil, 3], result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1], @state.coercion_errors.first.path)
    assert_equal("Cannot represent non-Int value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_adds_error_for_null_among_non_null_list_items
    type = get_type("[String!]")
    result = @input.coerce_input_value(["a", nil, "c"], type, state: @state)

    assert_equal(["a", UNDEFINED, "c"], result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1], @state.coercion_errors.first.path)
    assert_equal("Non-null type cannot be null.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_array_for_non_null_list_type
    input = ["a", "b"]
    result1 = @input.coerce_input_value(input, get_type("[String]!"), state: @state)
    result2 = @input.coerce_input_value(input, get_type("[String!]!"), state: @state)

    assert_equal(input, result1)
    assert_equal(input, result2)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_missing_non_null_list_type
    type = get_type("[String]!")
    result = @input.coerce_input_value(nil, type, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Non-null type cannot be null.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_empty_list
    type = get_type("[String]")
    result = @input.coerce_input_value([], type, state: @state)

    assert_equal([], result)
    assert_empty(@state.coercion_errors)
    assert_predicate(result, :frozen?)
  end

  def test_coerce_input_value_coerces_valid_nested_list
    type = get_type("[[Int]]")
    result = @input.coerce_input_value([[1], [2, 3]], type, state: @state)

    assert_equal([[1], [2, 3]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_wraps_single_value_twice_for_nested_list
    type = get_type("[[Int]]")
    result = @input.coerce_input_value(42, type, state: @state)

    assert_equal([[42]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_wraps_each_item_for_nested_list
    type = get_type("[[Int]]")
    result = @input.coerce_input_value([1, 2, 3], type, state: @state)

    assert_equal([[1], [2], [3]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_preserves_null_values_in_nested_list
    type = get_type("[[Int]]")
    result = @input.coerce_input_value([42, [nil], nil], type, state: @state)

    assert_equal([[42], [nil], nil], result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_returns_nil_for_null_on_nested_list
    type = get_type("[[Int]]")
    result = @input.coerce_input_value(nil, type, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_coerces_list_of_input_objects
    type = get_type("[NestedInput]")
    result = @input.coerce_input_value([{ "value" => "a" }, { "value" => "b" }], type, state: @state)

    assert_equal([{ value: "a" }, { value: "b" }], result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_item_in_list_of_input_objects
    type = get_type("[NestedInput]")
    result = @input.coerce_input_value([{ "value" => "a" }, "not-an-object", { "value" => "c" }], type, state: @state)

    assert_equal([{ value: "a" }, UNDEFINED, { value: "c" }], result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1], @state.coercion_errors.first.path)
    assert_equal('Expected type "NestedInput" to be an object.', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_adds_error_for_nested_field_in_list_of_input_objects
    type = get_type("[TestInput]")
    input = [
      { "int" => 1 },
      { "int" => "not-an-int" },
      { "int" => 3 },
    ]
    result = @input.coerce_input_value(input, type, state: @state)

    assert_equal([{ int: 1 }, { int: nil }, { int: 3 }], result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1, "int"], @state.coercion_errors.first.path)
    assert_equal("Cannot represent non-Int value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_tracks_path_across_list_and_object_positions
    type = get_type("[TestInput]")
    input = [
      { "nestedList" => [{ "value" => "ok" }, { "value" => "also-ok" }] },
      { "nestedList" => [{ "value" => "fine" }, "not-an-object", { "value" => "still-fine" }] },
    ]
    result = @input.coerce_input_value(input, type, state: @state)

    assert_equal(
      [
        { nested_list: [{ value: "ok" }, { value: "also-ok" }] },
        { nested_list: [{ value: "fine" }, UNDEFINED, { value: "still-fine" }] },
      ],
      result,
    )
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1, "nestedList", 1], @state.coercion_errors.first.path)
    assert_equal('Expected type "NestedInput" to be an object.', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_collects_errors_with_deeply_nested_paths
    type = get_type("[TestInput]")
    input = [
      { "nested" => { "badField" => "x" } },
      { "nestedList" => [{ "badField" => "y" }] },
      { "int" => "not-int", "boolean" => "not-bool" },
      { "nested" => { "nested" => { "badField" => "z" } } },
    ]
    result = @input.coerce_input_value(input, type, state: @state)

    assert_equal(4, result.size)
    assert_equal(5, @state.coercion_errors.size)

    assert_equal([0, "nested"], @state.coercion_errors[0].path)
    assert_equal('Field "badField" is not defined by type "NestedInput".', @state.coercion_errors[0].message)

    assert_equal([1, "nestedList", 0], @state.coercion_errors[1].path)
    assert_equal('Field "badField" is not defined by type "NestedInput".', @state.coercion_errors[1].message)

    assert_equal([2, "int"], @state.coercion_errors[2].path)
    assert_equal("Cannot represent non-Int value.", @state.coercion_errors[2].message)

    assert_equal([2, "boolean"], @state.coercion_errors[3].path)
    assert_equal("Cannot represent non-Boolean value.", @state.coercion_errors[3].message)

    assert_equal([3, "nested", "nested"], @state.coercion_errors[4].path)
    assert_equal('Field "badField" is not defined by type "NestedInput".', @state.coercion_errors[4].message)
  end

  def test_coerce_input_value_coerces_input_object_with_valid_fields
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "string" => "hello", "int" => 42 }, type, state: @state)

    assert_equal({ string: "hello", int: 42 }, result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_formats_keys_as_strings_when_symbolize_keys_disabled
    @input.symbolize_keys = false
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "stringList" => ["hello"] }, type, state: @state)

    assert_equal({ "stringList" => ["hello"] }, result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_uses_graphql_name_in_static_error_path
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "nestedList" => [{ "unknown" => "x" }] }, type, state: @state)

    assert_equal({ nested_list: [{}] }, result)
    assert_equal(["nestedList", 0], @state.coercion_errors.first.path)
  end

  def test_coerce_input_value_adds_error_for_non_hash_input_object
    type = get_type("TestInput")
    result = @input.coerce_input_value("not-an-object", type, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Expected type "TestInput" to be an object.', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_adds_error_for_missing_required_field
    type = get_type("RequiredFieldsInput")
    result = @input.coerce_input_value({ "optional" => "hello" }, type, state: @state)

    assert_equal({ optional: "hello" }, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal(["required"], @state.coercion_errors.first.path)
    assert_equal('Field "required" of required type "String!" was not provided.', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_adds_error_for_unknown_field
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "unknownField" => "value" }, type, state: @state)

    assert_equal({}, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Field "unknownField" is not defined by type "TestInput".', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_nested_input_object
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "nested" => { "value" => "hello" } }, type, state: @state)

    assert_equal({ nested: { value: "hello" } }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_nested_input_object_error
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "nested" => "not-an-object" }, type, state: @state)

    assert_equal({ nested: UNDEFINED }, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal(["nested"], @state.coercion_errors.first.path)
    assert_equal('Expected type "NestedInput" to be an object.', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_allows_one_of_with_single_field
    type = get_type("OneOfInput")
    result = @input.coerce_input_value({ "string" => "hello" }, type, state: @state)

    assert_equal({ string: "hello" }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_one_of_with_multiple_fields
    type = get_type("OneOfInput")
    result = @input.coerce_input_value({ "string" => "hello", "int" => 42 }, type, state: @state)

    assert_equal({ string: "hello", int: 42 }, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Exactly one key must be specified for OneOf type "OneOfInput".', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_adds_error_for_one_of_with_null_value
    type = get_type("OneOfInput")
    result = @input.coerce_input_value({ "string" => nil }, type, state: @state)

    assert_equal({ string: nil }, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Exactly one value must be specified for OneOf type "OneOfInput", but "string" was null.', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_adds_error_for_one_of_with_no_fields
    type = get_type("OneOfInput")
    result = @input.coerce_input_value({}, type, state: @state)

    assert_equal({}, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Exactly one key must be specified for OneOf type "OneOfInput".', @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_string
    type = get_type("String")
    result = @input.coerce_input_value("hello", type, state: @state)

    assert_equal("hello", result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_string
    type = get_type("String")
    result = @input.coerce_input_value(true, type, state: @state)

    assert_nil(result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-String value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_int
    type = get_type("Int")
    result = @input.coerce_input_value(42, type, state: @state)

    assert_equal(42, result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_int
    type = get_type("Int")
    result = @input.coerce_input_value("not-an-int", type, state: @state)

    assert_nil(result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-Int value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_float
    type = get_type("Float")
    result = @input.coerce_input_value(3.14, type, state: @state)

    assert_in_delta(3.14, result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_coerces_valid_float_with_compatible_value
    type = get_type("Float")
    result = @input.coerce_input_value(42, type, state: @state)

    assert_in_delta(42.0, result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_float
    type = get_type("Float")
    result = @input.coerce_input_value("not-a-float", type, state: @state)

    assert_nil(result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-Float value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_boolean
    type = get_type("Boolean")
    result = @input.coerce_input_value(true, type, state: @state)

    assert_equal(true, result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_boolean
    type = get_type("Boolean")
    result = @input.coerce_input_value("not-a-boolean", type, state: @state)

    assert_nil(result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-Boolean value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_id
    type = get_type("ID")

    result1 = @input.coerce_input_value("abc123", type, state: @state)
    assert_equal("abc123", result1)
    assert_empty(@state.coercion_errors)

    result2 = @input.coerce_input_value(123, type, state: @state)
    assert_equal("123", result2)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_id
    type = get_type("ID")
    result = @input.coerce_input_value(true, type, state: @state)

    assert_nil(result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-ID value.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_coerces_valid_enum
    type = get_type("TestStatus")
    result = @input.coerce_input_value("ACTIVE", type, state: @state)

    assert_equal("ACTIVE", result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_invalid_enum
    type = get_type("TestStatus")
    result = @input.coerce_input_value("INVALID", type, state: @state)

    assert_nil(result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Value does not exist in 'TestStatus' enum.", @state.coercion_errors.first&.message)
  end

  def test_coerce_input_value_enum_with_internal_value_mapping
    test_enum = Class.new(GraphQL::Schema::Enum) do
      graphql_name "MappedEnum"
      value "FOO", value: "InternalFoo"
      value "BAR", value: 123456789
    end

    foo_result = @input.coerce_input_value("FOO", test_enum, state: @state)
    assert_equal("InternalFoo", foo_result)
    assert_empty(@state.coercion_errors)

    bar_result = @input.coerce_input_value("BAR", test_enum, state: @state)
    assert_equal(123456789, bar_result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_scalar_coercion_error
    test_scalar = Class.new(GraphQL::Schema::Scalar) do
      graphql_name "ErrorScalar"

      class << self
        def coerce_input(input, _context)
          raise GraphQL::CoercionError, "Custom coercion error: #{input}"
        end
      end
    end

    result = @input.coerce_input_value("bad-value", test_scalar, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Custom coercion error: bad-value", @state.coercion_errors[0].message)
  end

  def test_coerce_input_value_returns_nil_for_custom_scalar_coerced_to_nil
    test_scalar = Class.new(GraphQL::Schema::Scalar) do
      graphql_name "NilScalar"

      class << self
        def coerce_input(_input, _context)
          nil
        end
      end
    end

    result = @input.coerce_input_value("any-value", test_scalar, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_coerce_input_value_adds_error_for_custom_scalar_exception
    test_scalar = Class.new(GraphQL::Schema::Scalar) do
      graphql_name "BrokenScalar"

      class << self
        def coerce_input(_input, _context)
          raise StandardError, "Something went wrong"
        end
      end
    end

    result = @input.coerce_input_value("any-value", test_scalar, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Expected type "BrokenScalar".', @state.coercion_errors[0].message)
  end

  def test_coerce_input_value_collects_errors_for_multiple_invalid_fields
    type = get_type("TestInput")
    result = @input.coerce_input_value({ "int" => "not-int", "boolean" => "not-bool" }, type, state: @state)

    assert_equal({ int: nil, boolean: nil }, result)
    assert_equal(2, @state.coercion_errors.size)

    assert_equal("Cannot represent non-Int value.", @state.coercion_errors[0].message)
    assert_equal(["int"], @state.coercion_errors[0].path)

    assert_equal("Cannot represent non-Boolean value.", @state.coercion_errors[1].message)
    assert_equal(["boolean"], @state.coercion_errors[1].path)
  end

  # === coerce_input_value validation ===

  def test_coerce_input_value_passes_validation
    type = get_type("ValidatedFieldsInput")
    result = @input.coerce_input_value({ "scalar" => "ab" }, type, state: @state)

    assert_equal({ scalar: "ab" }, result)
    assert_empty(@state.coercion_errors)
    assert_empty(@state.validator_errors)
  end

  def test_coerce_input_value_returns_validator_error_when_validation_fails
    type = get_type("ValidatedFieldsInput")
    result = @input.coerce_input_value({ "scalar" => "a" }, type, state: @state)

    assert_equal({ scalar: "a" }, result)
    assert_empty(@state.coercion_errors)
    assert_equal(1, @state.validator_errors.size)
    assert_equal("scalar is too short (minimum is 2)", @state.validator_errors.first&.message)
    assert_equal(["scalar"], @state.validator_errors.first.path)
  end

  def test_coerce_input_value_returns_validator_error_for_invalid_default_value
    input_type = Class.new(GraphQL::Schema::InputObject) do
      graphql_name "InputWithBadDefault"
      argument :invalid_default, String, default_value: "a", validates: { length: { minimum: 2 } }
    end

    result = @input.coerce_input_value({}, input_type, state: @state)

    assert_equal({ invalid_default: "a" }, result)
    assert_empty(@state.coercion_errors)
    assert_equal(1, @state.validator_errors.size)
    assert_equal("invalidDefault is too short (minimum is 2)", @state.validator_errors.first&.message)
    assert_equal(["invalidDefault"], @state.validator_errors.first.path)
  end

  def test_coerce_input_value_collects_validator_errors_for_deeply_nested_failures
    type = get_type("ValidatedFieldsInput")
    input = {
      "scalar" => "a",  # fails at root
      "input" => {
        "scalar" => "b",  # fails at input.scalar
        "inputList" => [
          { "scalar" => "ab" },  # passes
          { "scalar" => "c" },   # fails at input.inputList.1.scalar
        ],
      },
    }
    expected = {
      scalar: "a",
      input: {
        scalar: "b",
        input_list: [
          { scalar: "ab" },
          { scalar: "c" },
        ],
      },
    }

    result = @input.coerce_input_value(input, type, state: @state)
    assert_equal(expected, result)
    assert_empty(@state.coercion_errors)
    assert_equal(3, @state.validator_errors.size)
    assert_equal(["scalar"], @state.validator_errors[0].path)
    assert_equal(["input", "scalar"], @state.validator_errors[1].path)
    assert_equal(["input", "inputList", 1, "scalar"], @state.validator_errors[2].path)
  end

  # === value_from_ast ===

  def test_value_from_ast_adds_error_for_no_input_ast_node
    type = get_type("String")
    result = @input.value_from_ast(nil, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected value node to be non-null.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_coerces_string_scalar
    type = get_type("String")
    ast = get_input_value_node('"hello"')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal("hello", result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_coerces_int_scalar
    type = get_type("Int")
    ast = get_input_value_node("42")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(42, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_coerces_float_scalar
    type = get_type("Float")
    ast = get_input_value_node("3.14")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(3.14, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_coerces_boolean_scalar
    type = get_type("Boolean")
    ast = get_input_value_node("true")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(true, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_adds_error_for_invalid_scalar
    type = get_type("Int")
    ast = get_input_value_node('"not-an-int"')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-Int value.", @state.coercion_errors.first&.message)
  end

  def test_value_from_ast_coerces_valid_enum
    type = get_type("TestStatus")
    ast = get_input_value_node("ACTIVE")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal("ACTIVE", result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_adds_error_for_non_enum_node
    type = get_type("TestStatus")
    ast = get_input_value_node('"ACTIVE"')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected value node to be an enum.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_nil_for_null_value
    type = get_type("String")
    ast = get_input_value_node("null")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_adds_error_for_null_on_non_null_type
    type = get_type("String!")
    ast = get_input_value_node("null")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected value node to be non-null.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_coerces_valid_non_null_value
    type = get_type("String!")
    ast = get_input_value_node('"hello"')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal("hello", result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_coerces_array_for_list_type
    type = get_type("[String]")
    ast = get_input_value_node('["a", "b", "c"]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(["a", "b", "c"], result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_wraps_single_value_as_array_for_list_type
    type = get_type("[String]")
    ast = get_input_value_node('"single"')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(["single"], result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_nil_for_null_on_list_type
    type = get_type("[String]")
    ast = get_input_value_node("null")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_coerces_nested_list
    type = get_type("[[Int]]")
    ast = get_input_value_node("[[1, 2], [3]]")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal([[1, 2], [3]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_wraps_single_value_twice_for_nested_list
    type = get_type("[[Int]]")
    ast = get_input_value_node("42")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal([[42]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_wraps_each_item_for_nested_list
    type = get_type("[[Int]]")
    ast = get_input_value_node("[1, 2, 3]")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal([[1], [2], [3]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_preserves_null_values_in_nested_list
    type = get_type("[[Int]]")
    ast = get_input_value_node("[42, [null], null]")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal([[42], [nil], nil], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_invalidates_entire_list_for_invalid_item
    type = get_type("[Int]")
    ast = get_input_value_node('[1, "not-an-int", 3]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1], @state.coercion_errors[0].path)
  end

  def test_value_from_ast_invalidates_entire_list_for_null_as_non_null_list_item
    type = get_type("[String!]")
    ast = get_input_value_node('["ok", null, "also-ok"]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1], @state.coercion_errors[0].path)
  end

  def test_value_from_ast_returns_error_for_list_with_object_literal
    type = get_type("[Boolean]")
    ast = get_input_value_node("{ foo: true }")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Cannot represent non-Boolean value.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_coerces_input_object
    type = get_type("TestInput")
    ast = get_input_value_node('{ string: "hello", int: 42 }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal({ string: "hello", int: 42 }, result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_formats_keys_as_strings_when_symbolize_keys_disabled
    @input.symbolize_keys = false
    type = get_type("TestInput")
    ast = get_input_value_node('{ string: "hello", nestedList: [{ value: "a" }] }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal({ "string" => "hello", "nestedList" => [{ "value" => "a" }] }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_uses_graphql_name_in_static_error_path
    type = get_type("TestInput")
    ast = get_input_value_node('{ stringList: [true] }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(["stringList", 0], @state.coercion_errors.first.path)
  end

  def test_value_from_ast_adds_error_for_non_input_object_node
    type = get_type("TestInput")
    ast = get_input_value_node('"not-an-object"')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected value node to be an input object.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_adds_error_for_missing_required_field
    type = get_type("RequiredFieldsInput")
    ast = get_input_value_node('{ optional: "hello" }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal(["required"], @state.coercion_errors[0].path)
    assert_equal('Expected argument "required" to be non-null.', @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_undefined_for_nested_error
    type = get_type("TestInput")
    ast = get_input_value_node('{ nested: "not-an-object" }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal(["nested"], @state.coercion_errors[0].path)
    assert_equal("Expected value node to be an input object.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_substitutes_variable
    type = get_type("String")
    ast = get_input_value_node("$myVar")
    result = @input.value_from_ast(ast, type, variables: { "myVar" => "from-variable" }, state: @state)

    assert_equal("from-variable", result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_adds_error_for_undefined_variable
    type = get_type("String")
    ast = get_input_value_node("$myVar")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected variable $myVar to be defined.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_adds_error_for_null_variable_on_non_null_type
    type = get_type("String!")
    ast = get_input_value_node("$myVar")
    result = @input.value_from_ast(ast, type, variables: { "myVar" => nil }, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected variable $myVar to be non-null.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_nil_for_null_variable_on_nullable_type
    type = get_type("String")
    ast = get_input_value_node("$myVar")
    result = @input.value_from_ast(ast, type, variables: { "myVar" => nil }, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_substitutes_variable_in_list
    type = get_type("[String]")
    ast = get_input_value_node('["a", $myVar, "c"]')
    result = @input.value_from_ast(ast, type, variables: { "myVar" => "b" }, state: @state)

    assert_equal(["a", "b", "c"], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_adds_error_for_missing_variable_as_non_null_list_item
    type = get_type("[String!]")
    ast = get_input_value_node('["a", $missingVar, "c"]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1], @state.coercion_errors[0].path)
    assert_equal("Expected item to be non-null.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_nil_for_missing_variable_as_nullable_list_item
    type = get_type("[String]")
    ast = get_input_value_node('["a", $missingVar, "c"]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(["a", nil, "c"], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_substitutes_variable_in_input_object_field
    type = get_type("TestInput")
    ast = get_input_value_node('{ string: $myVar }')
    result = @input.value_from_ast(ast, type, variables: { "myVar" => "from-variable" }, state: @state)

    assert_equal({ string: "from-variable" }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_adds_error_for_missing_variable_on_required_object_field
    type = get_type("RequiredFieldsInput")
    ast = get_input_value_node('{ required: $missingVar }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal(["required"], @state.coercion_errors[0].path)
    assert_equal('Expected argument "required" to be non-null.', @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_undefined_for_deeply_nested_error
    type = get_type("[TestInput]")
    ast = get_input_value_node('[{ nested: { value: "ok" } }, { nestedList: [{ value: "a" }, "not-an-object"] }]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal([1, "nestedList", 1], @state.coercion_errors[0].path)
    assert_equal("Expected value node to be an input object.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_nil_for_custom_scalar_returning_nil
    test_scalar = Class.new(GraphQL::Schema::Scalar) do
      graphql_name "ReturnNilScalar"

      class << self
        def coerce_input(_node, _context)
          nil
        end
      end
    end

    ast = get_input_value_node("value")
    result = @input.value_from_ast(ast, test_scalar, variables: {}, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_message_for_custom_scalar_error
    test_scalar = Class.new(GraphQL::Schema::Scalar) do
      graphql_name "BrokenScalar"

      class << self
        def coerce_input(_node, _context)
          raise GraphQL::CoercionError, "Sorry, try again."
        end
      end
    end

    ast = get_input_value_node("value")
    result = @input.value_from_ast(ast, test_scalar, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Sorry, try again.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_opaque_error_for_custom_scalar_exception
    test_scalar = Class.new(GraphQL::Schema::Scalar) do
      graphql_name "BrokenScalar"

      class << self
        def coerce_input(_node, _context)
          raise StandardError, "Boom"
        end
      end
    end

    ast = get_input_value_node("value")
    result = @input.value_from_ast(ast, test_scalar, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Expected type "BrokenScalar".', @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_internal_value_for_mapped_enum
    test_enum = Class.new(GraphQL::Schema::Enum) do
      graphql_name "TestColor"
      value "RED", value: 1
      value "GREEN", value: 2
      value "BLUE", value: 3
    end

    ast = get_input_value_node("RED")
    result = @input.value_from_ast(ast, test_enum, variables: {}, state: @state)

    assert_equal(1, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_nil_for_enum_with_null_internal_value
    test_enum = Class.new(GraphQL::Schema::Enum) do
      graphql_name "NullableEnum"
      value "NULL_VALUE", value: nil
    end

    ast = get_input_value_node("NULL_VALUE")
    result = @input.value_from_ast(ast, test_enum, variables: {}, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_error_for_invalid_enum_value
    type = get_type("TestStatus")
    ast = get_input_value_node("123")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected value node to be an enum.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_applies_default_value_for_input_object
    test_input = Class.new(GraphQL::Schema::InputObject) do
      graphql_name "InputWithDefault"
      argument :value, GraphQL::Types::Int, required: false, default_value: 42
      argument :other, GraphQL::Types::String, required: false
    end

    ast = get_input_value_node('{ other: "hello" }')
    result = @input.value_from_ast(ast, test_input, variables: {}, state: @state)

    assert_equal({ value: 42, other: "hello" }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_error_for_input_object_with_array_literal
    type = get_type("TestInput")
    ast = get_input_value_node("[]")
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal("Expected value node to be an input object.", @state.coercion_errors[0].message)
  end

  def test_value_from_ast_does_not_wrap_list_variable_on_list_type
    type = get_type("[String]")
    ast = get_input_value_node("$myVar")
    result = @input.value_from_ast(ast, type, variables: { "myVar" => ["a", "b"] }, state: @state)

    assert_equal(["a", "b"], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_does_not_wrap_single_variable_on_list_type
    # Note: variables are expected to have already been coerced,
    # so we do NOT expect the singleton wrapping behavior for variables.
    type = get_type("[String]")
    ast = get_input_value_node("$myVar")
    result = @input.value_from_ast(ast, type, variables: { "myVar" => "single" }, state: @state)

    assert_equal("single", result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_null_for_missing_variable_on_nullable_list_item
    type = get_type("[String]")
    ast = get_input_value_node('[$missingVar]')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal([nil], result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_uses_default_for_missing_variable_in_input_object
    test_input = Class.new(GraphQL::Schema::InputObject) do
      graphql_name "InputWithDefault"
      argument :value, GraphQL::Types::Int, required: false, default_value: 42
      argument :other, GraphQL::Types::String, required: false
    end

    ast = get_input_value_node('{ value: $missing, other: "hello" }')
    result = @input.value_from_ast(ast, test_input, variables: {}, state: @state)

    assert_equal({ value: 42, other: "hello" }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_allows_one_of_with_single_non_null_value
    type = get_type("OneOfInput")
    ast = get_input_value_node('{ string: "a" }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal({ string: "a" }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_error_for_one_of_with_null_value
    type = get_type("OneOfInput")
    ast = get_input_value_node('{ string: null }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Exactly one value must be specified for OneOf type "OneOfInput", but "string" was null.', @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_error_for_one_of_with_multiple_keys
    type = get_type("OneOfInput")
    ast = get_input_value_node('{ string: "a", int: 1 }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Exactly one key must be specified for OneOf type "OneOfInput".', @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_error_for_one_of_with_no_keys
    type = get_type("OneOfInput")
    ast = get_input_value_node('{}')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Exactly one key must be specified for OneOf type "OneOfInput".', @state.coercion_errors[0].message)
  end

  def test_value_from_ast_returns_nan_for_enum_with_nan_value
    test_enum = Class.new(GraphQL::Schema::Enum) do
      graphql_name "NanEnum"
      value "NAN", value: Float::NAN
    end

    ast = get_input_value_node("NAN")
    result = @input.value_from_ast(ast, test_enum, variables: {}, state: @state)

    assert_predicate(result, :nan?)
    assert_empty(@state.coercion_errors)
  end

  def test_value_from_ast_returns_name_for_enum_with_no_internal_value
    test_enum = Class.new(GraphQL::Schema::Enum) do
      graphql_name "NoValueEnum"
      value "NO_CUSTOM_VALUE"
    end

    ast = get_input_value_node("NO_CUSTOM_VALUE")
    result = @input.value_from_ast(ast, test_enum, variables: {}, state: @state)

    assert_equal("NO_CUSTOM_VALUE", result)
    assert_empty(@state.coercion_errors)
  end

  # === value_from_ast validation ===

  def test_value_from_ast_passes_validation
    type = get_type("ValidatedFieldsInput")
    ast = get_input_value_node('{ scalar: "ab" }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal({ scalar: "ab" }, result)
    assert_empty(@state.coercion_errors)
    assert_empty(@state.validator_errors)
  end

  def test_value_from_ast_returns_validator_error_when_validation_fails
    type = get_type("ValidatedFieldsInput")
    ast = get_input_value_node('{ scalar: "a" }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    assert_equal({ scalar: "a" }, result)
    assert_empty(@state.coercion_errors)
    assert_equal(1, @state.validator_errors.size)
    assert_equal("scalar is too short (minimum is 2)", @state.validator_errors.first&.message)
    assert_equal(["scalar"], @state.validator_errors.first.path)
  end

  def test_value_from_ast_returns_validator_error_for_invalid_default_value
    input_type = Class.new(GraphQL::Schema::InputObject) do
      graphql_name "InputWithBadDefault"
      argument :invalid_default, String, default_value: "a", validates: { length: { minimum: 2 } }
    end

    ast = get_input_value_node('{}')
    result = @input.value_from_ast(ast, input_type, variables: {}, state: @state)

    assert_equal({ invalid_default: "a" }, result)
    assert_empty(@state.coercion_errors)
    assert_equal(1, @state.validator_errors.size)
    assert_equal("invalidDefault is too short (minimum is 2)", @state.validator_errors.first&.message)
    assert_equal(["invalidDefault"], @state.validator_errors.first.path)
  end

  def test_value_from_ast_collects_validator_errors_for_deeply_nested_failures
    type = get_type("ValidatedFieldsInput")
    ast = get_input_value_node('{ scalar: "a", input: { scalar: "b", inputList: [{ scalar: "ab" }, { scalar: "c" }] } }')
    result = @input.value_from_ast(ast, type, variables: {}, state: @state)

    expected = {
      scalar: "a",
      input: {
        scalar: "b",
        input_list: [
          { scalar: "ab" },
          { scalar: "c" },
        ],
      },
    }
    assert_equal(expected, result)
    assert_empty(@state.coercion_errors)
    assert_equal(3, @state.validator_errors.size)
    assert_equal(["scalar"], @state.validator_errors[0].path)
    assert_equal(["input", "scalar"], @state.validator_errors[1].path)
    assert_equal(["input", "inputList", 1, "scalar"], @state.validator_errors[2].path)
  end

  # === format_default_value ===

  def test_format_default_value_returns_nil_for_nil
    type = get_type("String")
    result = @input.format_default_value(nil, type, state: @state)

    assert_nil(result)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_returns_unchanged_scalar_value
    type = get_type("String")
    result = @input.format_default_value("hello", type, state: @state)

    assert_equal("hello", result)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_formats_wrapped_non_null_type
    type = get_type("String!")
    result = @input.format_default_value("hello", type, state: @state)

    assert_equal("hello", result)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_formats_array_for_list_type
    type = get_type("[String]")
    result = @input.format_default_value(["a", "b", "c"], type, state: @state)

    assert_equal(["a", "b", "c"], result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_wraps_non_list_value_for_list_type
    type = get_type("[String]")
    result = @input.format_default_value("single", type, state: @state)

    assert_equal(["single"], result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_formats_nested_list
    type = get_type("[[Int]]")
    result = @input.format_default_value([[1, 2], [3]], type, state: @state)

    assert_equal([[1, 2], [3]], result)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_formats_input_object
    type = get_type("TestInput")
    result = @input.format_default_value({ "string" => "hello", "int" => 42 }, type, state: @state)

    assert_equal({ string: "hello", int: 42 }, result)
    assert_predicate(result, :frozen?)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_formats_keys_as_strings_when_symbolize_keys_disabled
    @input.symbolize_keys = false
    type = get_type("TestInput")

    input = {
      "string" => "hello",
      "nested" => { "value" => "deep" },
      "nestedList" => [{ "value" => "a" }, { "value" => "b" }],
    }
    result = @input.format_default_value(input, type, state: @state)

    assert_equal(input, result)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_uses_graphql_name_in_static_error_path
    type = get_type("TestInput")
    result = @input.format_default_value({ "nestedList" => [{ "unknown" => "x" }] }, type, state: @state)

    assert_equal({ nested_list: [{}] }, result)
    assert_equal(["nestedList", 0], @state.coercion_errors.first.path)
  end

  def test_format_default_value_formats_nested_input_object
    type = get_type("TestInput")
    result = @input.format_default_value({ "nested" => { "value" => "deep" } }, type, state: @state)

    assert_equal({ nested: { value: "deep" } }, result)
    assert_empty(@state.coercion_errors)
  end

  def test_format_default_value_adds_error_for_invalid_input_object
    type = get_type("TestInput")
    result = @input.format_default_value("not-an-object", type, state: @state)

    assert_equal(UNDEFINED, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Expected default value for type "TestInput" to be an object.', @state.coercion_errors[0].message)
  end

  def test_format_default_value_adds_error_for_unknown_field
    type = get_type("TestInput")
    result = @input.format_default_value({ "unknownField" => "value" }, type, state: @state)

    assert_equal({}, result)
    assert_equal(1, @state.coercion_errors.size)
    assert_equal('Invalid default field "unknownField" for type "TestInput".', @state.coercion_errors[0].message)
  end

  def test_format_default_value_formats_list_of_input_objects
    type = get_type("[NestedInput]")
    result = @input.format_default_value([{ "value" => "a" }, { "value" => "b" }], type, state: @state)

    assert_equal([{ value: "a" }, { value: "b" }], result)
    assert_empty(@state.coercion_errors)
  end

  # === format_default_value validations ===

  def test_format_default_value_passes_validation
    type = get_type("ValidatedFieldsInput")
    result = @input.format_default_value({ "scalar" => "ab" }, type, state: @state)

    assert_equal({ scalar: "ab" }, result)
    assert_empty(@state.coercion_errors)
    assert_empty(@state.validator_errors)
  end

  def test_format_default_value_returns_validator_error_when_validation_fails
    type = get_type("ValidatedFieldsInput")
    result = @input.format_default_value({ "scalar" => "a" }, type, state: @state)

    assert_equal({ scalar: "a" }, result)
    assert_empty(@state.coercion_errors)
    assert_equal(1, @state.validator_errors.size)
    assert_equal("scalar is too short (minimum is 2)", @state.validator_errors.first&.message)
    assert_equal(["scalar"], @state.validator_errors.first.path)
  end

  def test_format_default_value_collects_validator_errors_for_deeply_nested_failures
    type = get_type("ValidatedFieldsInput")
    default_value = {
      "scalar" => "a",  # fails at root
      "input" => {
        "scalar" => "b",  # fails at input.scalar
        "inputList" => [
          { "scalar" => "ab" },  # passes
          { "scalar" => "c" },   # fails at input.inputList.1.scalar
        ],
      },
    }
    expected = {
      scalar: "a",
      input: {
        scalar: "b",
        input_list: [
          { scalar: "ab" },
          { scalar: "c" },
        ],
      },
    }

    result = @input.format_default_value(default_value, type, state: @state)
    assert_equal(expected, result)
    assert_empty(@state.coercion_errors)
    assert_equal(3, @state.validator_errors.size)
    assert_equal(["scalar"], @state.validator_errors[0].path)
    assert_equal(["input", "scalar"], @state.validator_errors[1].path)
    assert_equal(["input", "inputList", 1, "scalar"], @state.validator_errors[2].path)
  end

  private

  #: (String) -> GraphQL::Language::Nodes::AbstractNode
  def get_variables_ast(vars_string)
    query = vars_string.empty? ? "{ __typename }" : "query(#{vars_string}) { __typename }"
    GraphQL.parse(query).definitions.first.variables
  end

  #: (String, String) -> GraphQL::Schema::Field
  def get_root_field(operation_type, field_name)
    TEST_SCHEMA.root_type_for_operation(operation_type).fields[field_name]
  end

  #: (String) -> GraphQL::Language::Nodes::Field
  def get_field_node(field_string)
    GraphQL.parse("mutation { #{field_string} }").definitions.first.selections.first
  end

  #: (String) -> GraphQL::Language::Nodes::AbstractNode
  def get_input_value_node(input_string)
    GraphQL.parse("{ field(input: #{input_string}) }").definitions.first.selections.first.arguments.first.value
  end

  #: (String) -> GraphQL::Language::Nodes::AbstractNode
  def get_type_node(type_string)
    GraphQL.parse("type T { field: #{type_string} }").definitions.first.fields.first.type
  end

  #: (String) -> singleton(GraphQL::Schema::Member)
  def get_type(type_string)
    @input.type_from_ast(get_type_node(type_string))
  end
end

[rmosolgo]

Thanks so much for sharing this code and its tests -- I'm going to try adapting it soon!