graphql 2.5.7 → 2.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7178e1b984bd4ab4488c7ff283d0efc2014a947e3b6901a0f97614e06d2ead6a
-  data.tar.gz: bef137f0d523fc01840f9315c6af6703de75e63987fffd032920dbde909fba50
+  metadata.gz: 35ee0d9a05997b264c746c531a4ff8d86ae9c8a4990523319da5ffafc9c89246
+  data.tar.gz: e68bf5323cff52c65403b4ed34a90de85a1f8b660d95cd43c167aeba2bce2d51
 SHA512:
-  metadata.gz: e6b4410aaef9503db55c6264bc9c6bcdbc8130522c84dda20837b8adec00ff33d9b897f0a1e63385979907e7c8144270858184692e4299a66603fdcff7ae616f
-  data.tar.gz: 6db0fe8a27e99763dcf8f2f1478d6bbb2bc095ac19be34feaaf48f4bfe6c697a99e6e0d30ab37c095fa88ab0b71259b241b639f2efd8e83ea17d894baae21af5
+  metadata.gz: 7233e64a37086b088d22609117498fcc12992472bde573a0a08b31d579121e9062759deac9ca22394273d28f914c04042dbbe53ba94a90859d0e82d75cc3c25a
+  data.tar.gz: bdeefc1210bcac49daef9670cfb53047c1d048e07ca2c68d6b31936e737f11314ac4cb6dbb6dc3063200f472379980fca42dfa997b44202ee56e5e1a6c525a9e

data/lib/graphql/execution/interpreter/runtime.rb

@@ -123,14 +123,14 @@ module GraphQL
             case inner_type.kind.name
             when "SCALAR", "ENUM"
               result_name = ast_node.alias || ast_node.name
-              owner_type = query.field_definition.owner
+              field_defn = query.field_definition
+              owner_type = field_defn.owner
               selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
               selection_result.base_path = base_path
               selection_result.ordered_result_keys = [result_name]
               runtime_state = get_current_runtime_state
               runtime_state.current_result = selection_result
               runtime_state.current_result_name = result_name
-              field_defn = query.field_definition
               continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
               if HALT != continue_value
                 continue_field(continue_value, owner_type, field_defn, root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
@@ -156,14 +156,14 @@ module GraphQL
             end
           when "SCALAR", "ENUM"
             result_name = ast_node.alias || ast_node.name
-            owner_type = query.field_definition.owner
-            selection_result = GraphQLResultHash.new(nil, query.parent_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+            field_defn = query.field_definition
+            owner_type = field_defn.owner
+            selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
             selection_result.ordered_result_keys = [result_name]
             selection_result.base_path = base_path
             runtime_state = get_current_runtime_state
             runtime_state.current_result = selection_result
             runtime_state.current_result_name = result_name
-            field_defn = query.field_definition
             continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
             if HALT != continue_value
               continue_field(continue_value, owner_type, field_defn, query.root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
@@ -826,6 +826,13 @@ module GraphQL
           else
             dir_defn = @schema_directives.fetch(dir_node.name)
             raw_dir_args = arguments(nil, dir_defn, dir_node)
+            if !raw_dir_args.is_a?(GraphQL::ExecutionError)
+              begin
+                dir_defn.validate!(raw_dir_args, context)
+              rescue GraphQL::ExecutionError => err
+                raw_dir_args = err
+              end
+            end
             dir_args = continue_value(
               raw_dir_args, # value
               nil, # field

data/lib/graphql/query/partial.rb

@@ -18,7 +18,8 @@ module GraphQL
       # @param object [Object] A starting object for execution
       # @param query [GraphQL::Query] A full query instance that this partial is based on. Caches are shared.
       # @param context [Hash] Extra context values to merge into `query.context`, if provided
-      def initialize(path:, object:, query:, context: nil)
+      # @param fragment_node [GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::FragmentDefinition]
+      def initialize(path: nil, object:, query:, context: nil, fragment_node: nil, type: nil)
         @path = path
         @object = object
         @query = query
@@ -31,57 +32,18 @@ module GraphQL
         @multiplex = nil
         @result_values = nil
         @result = nil
-        selections = [@query.selected_operation]
-        type = @query.root_type
-        parent_type = nil
-        field_defn = nil
-        @path.each do |name_in_doc|
-          if name_in_doc.is_a?(Integer)
-            if type.list?
-              type = type.unwrap
-              next
-            else
-              raise ArgumentError, "Received path with index `#{name_in_doc}`, but type wasn't a list. Type: #{type.to_type_signature}, path: #{@path}"
-            end
-          end
-
-          next_selections = []
-          selections.each do |selection|
-            selections_to_check = []
-            selections_to_check.concat(selection.selections)
-            while (sel = selections_to_check.shift)
-              case sel
-              when GraphQL::Language::Nodes::InlineFragment
-                selections_to_check.concat(sel.selections)
-              when GraphQL::Language::Nodes::FragmentSpread
-                fragment = @query.fragments[sel.name]
-                selections_to_check.concat(fragment.selections)
-              when GraphQL::Language::Nodes::Field
-                if sel.alias == name_in_doc || sel.name == name_in_doc
-                  next_selections << sel
-                end
-              else
-                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
-              end
-            end
-          end
 
-          if next_selections.empty?
-            raise ArgumentError, "Path `#{@path.inspect}` is not present in this query. `#{name_in_doc.inspect}` was not found. Try a different path or rewrite the query to include it."
-          end
-          field_name = next_selections.first.name
-          field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
-          parent_type = type
-          type = field_defn.type
-          if type.non_null?
-            type = type.of_type
-          end
-          selections = next_selections
+        if fragment_node
+          @ast_nodes = [fragment_node]
+          @root_type = type || raise(ArgumentError, "Pass `type:` when using `node:`")
+          # This is only used when `@leaf`
+          @field_definition = nil
+        elsif path.nil?
+          raise ArgumentError, "`path:` is required if `node:` is not given; add `path:`"
+        else
+          set_type_info_from_path
         end
-        @parent_type = parent_type
-        @ast_nodes = selections
-        @root_type = type
-        @field_definition = field_defn
+
         @leaf = @root_type.unwrap.kind.leaf?
       end
 
@@ -89,7 +51,7 @@ module GraphQL
         @leaf
       end
 
-      attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :parent_type, :schema
+      attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :schema
 
       attr_accessor :multiplex, :result_values
 
@@ -155,6 +117,63 @@ module GraphQL
       def selected_operation_name
         @query.selected_operation_name
       end
+
+      private
+
+      def set_type_info_from_path
+        selections = [@query.selected_operation]
+        type = @query.root_type
+        parent_type = nil
+        field_defn = nil
+
+        @path.each do |name_in_doc|
+          if name_in_doc.is_a?(Integer)
+            if type.list?
+              type = type.unwrap
+              next
+            else
+              raise ArgumentError, "Received path with index `#{name_in_doc}`, but type wasn't a list. Type: #{type.to_type_signature}, path: #{@path}"
+            end
+          end
+
+          next_selections = []
+          selections.each do |selection|
+            selections_to_check = []
+            selections_to_check.concat(selection.selections)
+            while (sel = selections_to_check.shift)
+              case sel
+              when GraphQL::Language::Nodes::InlineFragment
+                selections_to_check.concat(sel.selections)
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment = @query.fragments[sel.name]
+                selections_to_check.concat(fragment.selections)
+              when GraphQL::Language::Nodes::Field
+                if sel.alias == name_in_doc || sel.name == name_in_doc
+                  next_selections << sel
+                end
+              else
+                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
+              end
+            end
+          end
+
+          if next_selections.empty?
+            raise ArgumentError, "Path `#{@path.inspect}` is not present in this query. `#{name_in_doc.inspect}` was not found. Try a different path or rewrite the query to include it."
+          end
+          field_name = next_selections.first.name
+          field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
+          parent_type = type
+          type = field_defn.type
+          if type.non_null?
+            type = type.of_type
+          end
+          selections = next_selections
+        end
+
+        @ast_nodes = selections
+        @root_type = type
+        @field_definition = field_defn
+      end
     end
   end
 end

data/lib/graphql/schema/directive.rb

@@ -9,6 +9,7 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::HasDirectiveArguments
+      extend GraphQL::Schema::Member::HasValidators
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -75,6 +76,10 @@ module GraphQL
           yield
         end
 
+        def validate!(arguments, context)
+          Schema::Validator.validate!(validators, self, context, arguments)
+        end
+
         def on_field?
           locations.include?(FIELD)
         end
@@ -111,6 +116,9 @@ module GraphQL
       # @return [GraphQL::Interpreter::Arguments]
       attr_reader :arguments
 
+      class InvalidArgumentError < GraphQL::Error
+      end
+
       def initialize(owner, **arguments)
         @owner = owner
         assert_valid_owner
@@ -119,7 +127,19 @@ module GraphQL
         # - lazy resolution
         # Probably, those won't be needed here, since these are configuration arguments,
         # not runtime arguments.
-        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext.instance)
+        context = Query::NullContext.instance
+        self.class.all_argument_definitions.each do |arg_defn|
+          value = arguments[arg_defn.keyword]
+          result = arg_defn.type.validate_input(value, context)
+          if !result.valid?
+            raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
+          end
+        end
+        self.class.validate!(arguments, context)
+        @arguments = self.class.coerce_arguments(nil, arguments, context)
+        if @arguments.is_a?(GraphQL::ExecutionError)
+          raise @arguments
+        end
       end
 
       def graphql_name

data/lib/graphql/schema/input_object.rb

@@ -182,6 +182,10 @@ module GraphQL
 
           input.each do |argument_name, value|
             argument = types.argument(self, argument_name)
+            if argument.nil? && ctx.is_a?(Query::NullContext) && argument_name.is_a?(Symbol)
+              # Validating definition directive arguments which come in as Symbols
+              argument = types.arguments(self).find { |arg| arg.keyword == argument_name }
+            end
             # Items in the input that are unexpected
             if argument.nil?
               result ||= Query::InputValidationResult.new

data/lib/graphql/schema/scalar.rb

@@ -50,12 +50,7 @@ module GraphQL
           end
 
           if coerced_result.nil?
-            str_value = if value == Float::INFINITY
-              ""
-            else
-              " #{GraphQL::Language.serialize(value)}"
-            end
-            Query::InputValidationResult.from_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{graphql_name}")
           elsif coerced_result.is_a?(GraphQL::CoercionError)
             Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
           else

data/lib/graphql/schema/timeout.rb

@@ -71,15 +71,23 @@ module GraphQL
         def execute_field(query:, field:, **_rest)
           timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
-          if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+          if timeout_state == false
+            super
+          elsif Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
             error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
               @timeout.handle_timeout(error, query)
+              timeout_state = query.context.namespace(@timeout).fetch(:state)
             end
 
-            error
+            # `handle_timeout` may have set this to be `false`
+            if timeout_state != false
+              error
+            else
+              super
+            end
           else
             super
           end
@@ -102,6 +110,15 @@ module GraphQL
         # override to do something interesting
       end
 
+      # Call this method (eg, from {#handle_timeout}) to disable timeout tracking
+      # for the given query.
+      # @param query [GraphQL::Query]
+      # @return [void]
+      def disable_timeout(query)
+        query.context.namespace(self)[:state] = false
+        nil
+      end
+
       # This error is raised when a query exceeds `max_seconds`.
       # Since it's a child of {GraphQL::ExecutionError},
       # its message will be added to the response's `errors` key.

data/lib/graphql/schema/validator/required_validator.rb

@@ -99,10 +99,10 @@ module GraphQL
           argument_definitions = @validated.arguments(context).values
           required_names = @one_of.map do |arg_keyword|
             if arg_keyword.is_a?(Array)
-              names = arg_keyword.map { |arg| arg_keyword_to_grapqhl_name(argument_definitions, arg) }
+              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
               "(" + names.join(" and ") + ")"
             else
-              arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+              arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
             end
           end
 
@@ -113,7 +113,7 @@ module GraphQL
           end
         end
 
-        def arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+        def arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
           argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
           argument_definition.graphql_name
         end

data/lib/graphql/schema/visibility/profile.rb

@@ -256,8 +256,7 @@ module GraphQL
         end
 
         def loadable?(t, _ctx)
-          load_all_types
-          !@all_types[t.graphql_name] && @cached_visible[t]
+          @cached_visible[t] && !referenced?(t)
         end
 
         def loadable_possible_types(t, _ctx)

data/lib/graphql/schema/warden.rb

@@ -232,7 +232,9 @@ module GraphQL
 
       # @return [Boolean] True if this type is used for `loads:` but not in the schema otherwise and not _explicitly_ hidden.
       def loadable?(type, _ctx)
-        !reachable_type_set.include?(type) && visible_type?(type)
+        visible_type?(type) &&
+          !referenced?(type) &&
+          (type.respond_to?(:interfaces) ? interfaces(type).all? { |i| loadable?(i, _ctx) } : true)
       end
 
       def loadable_possible_types(union_type, _ctx)

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.5.7"
+  VERSION = "2.5.8"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.7
+  version: 2.5.8
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-05-15 00:00:00.000000000 Z
+date: 2025-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64