graphql 2.6.14 → 2.6.15

data/lib/graphql/types/relay/page_info_behaviors.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Types
     module Relay
       module PageInfoBehaviors
+        #: (singleton(GraphQL::Schema::Object) child_class) -> void
         def self.included(child_class)
           child_class.extend ClassMethods
           child_class.description "Information about pagination in a connection."
@@ -22,10 +23,12 @@ module GraphQL
       end
 
       module ClassMethods
+        #: () -> bool
         def default_relay?
           true
         end
 
+        #: () -> bool
         def default_broadcastable?
           true
         end

data/lib/graphql/types/relay.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 # behavior modules:
 require "graphql/types/relay/connection_behaviors"

data/lib/graphql/types/string.rb

@@ -20,6 +20,7 @@ module GraphQL
         ctx.schema.type_error(err, ctx)
       end
 
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String?
       def self.coerce_input(value, _ctx)
         value.is_a?(::String) ? value : nil
       end

data/lib/graphql/types.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module GraphQL
   module Types

data/lib/graphql/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
-  VERSION = "2.6.14"
+  VERSION = "2.6.15"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.14
+  version: 2.6.15
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-10-29 00:00:00.000000000 Z
+date: 2026-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -543,6 +543,7 @@ files:
 - lib/graphql/execution/resolve_type_step.rb
 - lib/graphql/execution/runner.rb
 - lib/graphql/execution/selections_step.rb
+- lib/graphql/execution/variable_values.rb
 - lib/graphql/execution_error.rb
 - lib/graphql/float_decoding_error.rb
 - lib/graphql/float_encoding_error.rb
@@ -598,7 +599,6 @@ files:
 - lib/graphql/query/result.rb
 - lib/graphql/query/validation_pipeline.rb
 - lib/graphql/query/variable_validation_error.rb
-- lib/graphql/query/variables.rb
 - lib/graphql/railtie.rb
 - lib/graphql/rake_task.rb
 - lib/graphql/rake_task/validate.rb
@@ -701,7 +701,6 @@ files:
 - lib/graphql/static_validation/definition_dependencies.rb
 - lib/graphql/static_validation/error.rb
 - lib/graphql/static_validation/interpreter_visitor.rb
-- lib/graphql/static_validation/literal_validator.rb
 - lib/graphql/static_validation/rules/argument_literals_are_compatible.rb
 - lib/graphql/static_validation/rules/argument_literals_are_compatible_error.rb
 - lib/graphql/static_validation/rules/argument_names_are_unique.rb

data/lib/graphql/query/variables.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-module GraphQL
-  class Query
-    # Read-only access to query variables, applying default values if needed.
-    class Variables
-      extend Forwardable
-
-      # **Returns**
-      #
-      # - `Array<GraphQL::Query::VariableValidationError>` — Any errors encountered when parsing the provided variables and literal values
-      attr_reader :errors
-
-      attr_reader :context
-
-      def initialize(ctx, ast_variables, provided_variables)
-        schema = ctx.schema
-        @context = ctx
-
-        @provided_variables = deep_stringify(provided_variables)
-        @errors = []
-        @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
-          if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
-            add_max_errors_reached_message
-            break memo
-          end
-          # Find the right value for this variable:
-          # - First, use the value provided at runtime
-          # - Then, fall back to the default value from the query string
-          # If it's still nil, raise an error if it's required.
-          variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
-          if variable_type.nil? || !variable_type.unwrap.kind.input?
-            # Pass -- it will get handled by a validator
-          else
-            variable_name = ast_variable.name
-            default_value = ast_variable.default_value
-            provided_value = @provided_variables[variable_name]
-            value_was_provided =  @provided_variables.key?(variable_name)
-            max_errors = schema.validate_max_errors - @errors.count if schema.validate_max_errors
-            begin
-              validation_result = if value_was_provided || default_value.nil?
-                variable_type.validate_input(provided_value, ctx, max_errors: max_errors)
-              else
-                GraphQL::Query::InputValidationResult::VALID
-              end
-              if validation_result.valid?
-                if value_was_provided
-                  # Add the variable if a value was provided
-                  memo[variable_name] = provided_value
-                elsif default_value != nil
-                  memo[variable_name] = if default_value.is_a?(Language::Nodes::NullValue)
-                    nil
-                  else
-                    default_value
-                  end
-                end
-              end
-            rescue GraphQL::ExecutionError => ex
-              # TODO: This should really include the path to the problematic node in the variable value
-              # like InputValidationResults generated by validate_non_null_input but unfortunately we don't
-              # have this information available in the coerce_input call chain. Note this path is the path
-              # that appears under errors.extensions.problems.path and NOT the result path under errors.path.
-              validation_result = GraphQL::Query::InputValidationResult.from_problem(ex.message)
-            end
-
-            if !validation_result.valid?
-              @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
-            end
-          end
-        end
-      end
-
-      def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
-
-      private
-
-      def deep_stringify(val)
-        case val
-        when Array
-          val.map { |v| deep_stringify(v) }
-        when Hash
-          new_val = {}
-          val.each do |k, v|
-            new_val[k.to_s] = deep_stringify(v)
-          end
-          new_val
-        else
-          val
-        end
-      end
-
-      def add_max_errors_reached_message
-        message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
-        validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
-        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message)
-      end
-    end
-  end
-end

data/lib/graphql/static_validation/literal_validator.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-module GraphQL
-  module StaticValidation
-    # Test whether `ast_value` is a valid input for `type`
-    class LiteralValidator
-      def initialize(context:)
-        @context = context
-        @types = context.types
-        @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
-        @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
-      end
-
-      def validate(ast_value, type)
-        catch(:invalid) do
-          recursively_validate(ast_value, type)
-        end
-      end
-
-      private
-
-      def replace_nulls_in(ast_value)
-        case ast_value
-        when Array
-          ast_value.map { |v| replace_nulls_in(v) }
-        when GraphQL::Language::Nodes::InputObject
-          ast_value.to_h
-        when GraphQL::Language::Nodes::NullValue
-          nil
-        else
-          ast_value
-        end
-      end
-
-      def recursively_validate(ast_value, type)
-        if type.nil?
-          # this means we're an undefined argument, see #present_input_field_values_are_valid
-          maybe_raise_if_invalid(ast_value) do
-            @invalid_response
-          end
-        elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-          maybe_raise_if_invalid(ast_value) do
-            type.kind.non_null? ? @invalid_response : @valid_response
-          end
-        elsif type.kind.non_null?
-          maybe_raise_if_invalid(ast_value) do
-            ast_value.nil? ?
-              @invalid_response :
-              recursively_validate(ast_value, type.of_type)
-          end
-        elsif type.kind.list?
-          item_type = type.of_type
-          results = ensure_array(ast_value).map { |val| recursively_validate(val, item_type) }
-          merge_results(results)
-        elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          @valid_response
-        elsif type.kind.scalar? && constant_scalar?(ast_value)
-          maybe_raise_if_invalid(ast_value) do
-            ruby_value = replace_nulls_in(ast_value)
-            type.validate_input(ruby_value, @context)
-          end
-        elsif type.kind.enum?
-          maybe_raise_if_invalid(ast_value) do
-            if ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-              type.validate_input(ast_value.name, @context)
-            else
-              # if our ast_value isn't an Enum it's going to be invalid so return false
-              @invalid_response
-            end
-          end
-        elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
-          maybe_raise_if_invalid(ast_value) do
-            merge_results([
-              required_input_fields_are_present(type, ast_value),
-              present_input_field_values_are_valid(type, ast_value)
-            ])
-          end
-        else
-          maybe_raise_if_invalid(ast_value) do
-            @invalid_response
-          end
-        end
-      end
-
-      # When `error_bubbling` is false, we want to bail on the first failure that we find.
-      # Use `throw` to escape the current call stack, returning the invalid response.
-      def maybe_raise_if_invalid(ast_value)
-        ret = yield
-        if !@context.schema.error_bubbling && !ret.valid?
-          throw(:invalid, ret)
-        else
-          ret
-        end
-      end
-
-      # The GraphQL grammar supports variables embedded within scalars but graphql.js
-      # doesn't support it so we won't either for simplicity
-      def constant_scalar?(ast_value)
-        if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          false
-        elsif ast_value.is_a?(Array)
-          ast_value.all? { |element| constant_scalar?(element) }
-        elsif ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
-          ast_value.arguments.all? { |arg| constant_scalar?(arg.value) }
-        else
-          true
-        end
-      end
-
-      def required_input_fields_are_present(type, ast_node)
-        # TODO - would be nice to use these to create an error message so the caller knows
-        # that required fields are missing
-        required_field_names = @types.arguments(type)
-          .select { |argument| argument.type.kind.non_null? && !argument.default_value? }
-          .map!(&:name)
-
-        present_field_names = ast_node.arguments.map(&:name)
-        missing_required_field_names = required_field_names - present_field_names
-        if @context.schema.error_bubbling
-          missing_required_field_names.empty? ? @valid_response : @invalid_response
-        else
-          results = missing_required_field_names.map do |name|
-            arg_type = @types.argument(type, name).type
-            recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
-          end
-          if type.one_of? && ast_node.arguments.size != 1
-            results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
-          end
-          merge_results(results)
-        end
-      end
-
-      def present_input_field_values_are_valid(type, ast_node)
-        results = ast_node.arguments.map do |value|
-          field = @types.argument(type, value.name)
-          # we want to call validate on an argument even if it's an invalid one
-          # so that our raise exception is on it instead of the entire InputObject
-          field_type = field && field.type
-          recursively_validate(value.value, field_type)
-        end
-        merge_results(results)
-      end
-
-      def ensure_array(value)
-        value.is_a?(Array) ? value : [value]
-      end
-
-      def merge_results(results_list)
-        merged_result = Query::InputValidationResult.new
-        results_list.each do |inner_result|
-          merged_result.merge_result!([], inner_result)
-        end
-        merged_result
-      end
-    end
-  end
-end