graphql 2.5.20 → 2.6.0

data/lib/graphql/static_validation/rules/fields_will_merge_error.rb

@@ -28,10 +28,10 @@ module GraphQL
       end
 
       def add_conflict(node, conflict_str)
-        # Can't use `.include?` here because AST nodes implement `#==`
-        # based on string value, not including location. But sometimes,
-        # identical nodes conflict because of their differing return types.
-        if nodes.any? { |n| n == node && n.line == node.line && n.col == node.col }
+        # Check if we already have an error for this exact node.
+        # Use object identity first (fast path), then fall back to
+        # value + location comparison for duplicate AST nodes.
+        if nodes.any? { |n| n.equal?(node) || (n.line == node.line && n.col == node.col && n == node) }
           # already have an error for this node
           return
         end

data/lib/graphql/static_validation/rules/fragment_spreads_are_possible.rb

@@ -8,8 +8,8 @@ module GraphQL
       end
 
       def on_inline_fragment(node, parent)
-        fragment_parent = context.object_types[-2]
-        fragment_child = context.object_types.last
+        fragment_parent = @parent_object_type
+        fragment_child = @current_object_type
         if fragment_child
           validate_fragment_in_scope(fragment_parent, fragment_child, node, context, context.path)
         end
@@ -17,7 +17,7 @@ module GraphQL
       end
 
       def on_fragment_spread(node, parent)
-        fragment_parent = context.object_types.last
+        fragment_parent = @current_object_type
         @spreads_to_validate << FragmentSpread.new(node: node, parent_type: fragment_parent, path: context.path)
         super
       end

data/lib/graphql/static_validation/rules/fragment_types_exist.rb

@@ -23,18 +23,21 @@ module GraphQL
           type_name = fragment_node.type.name
           type = @types.type(type_name)
           if type.nil?
-            @all_possible_fragment_type_names ||= begin
-              names = []
-              context.types.all_types.each do |type|
-                if type.kind.fields?
-                  names << type.graphql_name
+            suggestion = if @schema.did_you_mean
+              @all_possible_fragment_type_names ||= begin
+                names = []
+                context.types.all_types.each do |type|
+                  if type.kind.fields?
+                    names << type.graphql_name
+                  end
                 end
+                names
               end
-              names
+              context.did_you_mean_suggestion(type_name, @all_possible_fragment_type_names)
             end
 
             add_error(GraphQL::StaticValidation::FragmentTypesExistError.new(
-              "No such type #{type_name}, so it can't be a fragment condition#{context.did_you_mean_suggestion(type_name, @all_possible_fragment_type_names)}",
+              "No such type #{type_name}, so it can't be a fragment condition#{suggestion}",
               nodes: fragment_node,
               type: type_name
             ))

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -2,8 +2,13 @@
 module GraphQL
   module StaticValidation
     module RequiredArgumentsArePresent
+      def initialize(*)
+        super
+        @required_args_cache = {}.compare_by_identity
+      end
+
       def on_field(node, _parent)
-        assert_required_args(node, field_definition)
+        assert_required_args(node, @current_field_definition)
         super
       end
 
@@ -16,13 +21,28 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
-        args = @context.query.types.arguments(defn)
-        return if args.empty?
-        present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = context.query.types.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? && context.query.types.argument(defn, a.name) }
-          .map!(&:name)
+        return unless defn
 
+        # Cache required argument names per definition to avoid re-iterating
+        # arguments for the same definition across field instances
+        if @required_args_cache.key?(defn)
+          required_argument_names = @required_args_cache[defn]
+        else
+          args = @types.arguments(defn)
+          required_argument_names = nil
+          if !args.empty?
+            args.each do |a|
+              if a.type.kind.non_null? && !a.default_value? && @types.argument(defn, a.name)
+                (required_argument_names ||= []) << a.graphql_name
+              end
+            end
+          end
+          @required_args_cache[defn] = required_argument_names
+        end
+
+        return if required_argument_names.nil?
+
+        present_argument_names = ast_node.arguments.map(&:name)
         missing_names = required_argument_names - present_argument_names
         if !missing_names.empty?
           add_error(GraphQL::StaticValidation::RequiredArgumentsArePresentError.new(

data/lib/graphql/static_validation/rules/variables_are_input_types.rb

@@ -7,17 +7,20 @@ module GraphQL
         type = context.query.types.type(type_name)
 
         if type.nil?
-          @all_possible_input_type_names ||= begin
-            names = []
-            context.types.all_types.each { |(t)|
-              if t.kind.input?
-                names << t.graphql_name
-              end
-            }
-            names
+          suggestion = if @schema.did_you_mean
+            @all_possible_input_type_names ||= begin
+              names = []
+              context.types.all_types.each { |(t)|
+                if t.kind.input?
+                  names << t.graphql_name
+                end
+              }
+              names
+            end
+            context.did_you_mean_suggestion(type_name, @all_possible_input_type_names)
           end
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
-            "#{type_name} isn't a defined input type (on $#{node.name})#{context.did_you_mean_suggestion(type_name, @all_possible_input_type_names)}",
+            "#{type_name} isn't a defined input type (on $#{node.name})#{suggestion}",
             nodes: node,
             name: node.name,
             type: type_name

data/lib/graphql/static_validation/validation_context.rb

@@ -32,7 +32,7 @@ module GraphQL
       # TODO stop using def_delegators because of Array allocations
       def_delegators :@visitor,
         :path, :type_definition, :field_definition, :argument_definition,
-        :parent_type_definition, :directive_definition, :object_types, :dependencies
+        :parent_type_definition, :directive_definition, :dependencies
 
       def on_dependency_resolve(&handler)
         @on_dependency_resolve_handlers << handler

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -2,25 +2,49 @@
 module GraphQL
   class Subscriptions
     class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
-      def resolve(context:, object:, arguments:)
-        has_override_implementation = @field.resolver ||
-          object.respond_to?(@field.resolver_method)
+      def resolve(context:, object: nil, objects: nil,  arguments:)
+        if objects
+          has_override_implementation = @field.execution_mode != :direct_send
 
-        if !has_override_implementation
-          if context.query.subscription_update?
-            object.object
+          if !has_override_implementation
+            if context.query.subscription_update?
+              objects
+            else
+              objects.map { |o| context.skip }
+            end
           else
-            context.skip
+            yield(objects, arguments)
           end
         else
-          yield(object, arguments)
+          has_override_implementation = @field.resolver ||
+            object.respond_to?(@field.resolver_method)
+
+          if !has_override_implementation
+            if context.query.subscription_update?
+              object.object
+            else
+              context.skip
+            end
+          else
+            yield(object, arguments)
+          end
+        end
+      end
+
+      def after_resolve(values: nil, value: nil, context:, objects: nil, object: nil, arguments:, **rest)
+        if values
+          values.map do |value|
+            self.class.write_subscription(@field, value, arguments, context)
+          end
+        else
+          self.class.write_subscription(@field, value, arguments, context)
         end
       end
 
-      def after_resolve(value:, context:, object:, arguments:, **rest)
+      def self.write_subscription(field, value, arguments, context)
         if value.is_a?(GraphQL::ExecutionError)
           value
-        elsif @field.resolver&.method_defined?(:subscription_written?) &&
+        elsif field.resolver&.method_defined?(:subscription_written?) &&
           (subscription_namespace = context.namespace(:subscriptions)) &&
           (subscriptions_by_path = subscription_namespace[:subscriptions])
           (subscription_instance = subscriptions_by_path[context.current_path])

data/lib/graphql/subscriptions/event.rb

@@ -104,6 +104,7 @@ module GraphQL
 
         def stringify_args(arg_owner, args, context)
           arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
+
           case args
           when Hash
             next_args = {}

data/lib/graphql/subscriptions.rb

@@ -239,6 +239,41 @@ module GraphQL
       query.context.namespace(:subscriptions)[:subscription_broadcastable]
     end
 
+    # Called during execution when a new `subscription ...` operation is received
+    # @param query [GraphQL::Query]
+    # @return [void]
+    def initialize_subscriptions(query)
+      subs_namespace = query.context.namespace(:subscriptions)
+      subs_namespace[:events] = []
+      subs_namespace[:subscriptions] = {}
+      nil
+    end
+
+    # Called during execution when a subscription operation has finished
+    # @param query [GraphQL::Query]
+    # @return [void]
+    def finish_subscriptions(query)
+      if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
+        write_subscription(query, events)
+      end
+      nil
+    end
+
+    def finalizer
+      Finalizer.new(self)
+    end
+
+    class Finalizer
+      include Execution::Finalizer
+      def initialize(subscriptions)
+        @subscriptions = subscriptions
+      end
+
+      def finalize_graphql_result(query, result_data, result_key)
+        @subscriptions.finish_subscriptions(query)
+      end
+    end
+
     private
 
     # Recursively normalize `args` as belonging to `arg_owner`:

data/lib/graphql/tracing/perfetto_trace.rb

@@ -253,7 +253,7 @@ module GraphQL
         packet = trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
-          name: query.context.current_path.join("."),
+          name: query.context.current_path&.join(".") || field.path,
           category_iids: FIELD_EXECUTE_CATEGORY_IIDS,
           extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
@@ -269,7 +269,7 @@ module GraphQL
         if @create_debug_annotations
           start_field.track_event = dup_with(start_field.track_event,{
             debug_annotations: [
-                payload_to_debug(nil, object.object, iid: DA_OBJECT_IID, intern_value: true),
+                payload_to_debug(nil, (object.is_a?(GraphQL::Schema::Object) ? object.object : object), iid: DA_OBJECT_IID, intern_value: true),
                 payload_to_debug(nil, arguments, iid: DA_ARGUMENTS_IID),
                 payload_to_debug(nil, app_result, iid: DA_RESULT_IID, intern_value: true)
               ]

data/lib/graphql/tracing/trace.rb

@@ -98,6 +98,12 @@ module GraphQL
         yield
       end
 
+      def objects(type, object, context)
+      end
+
+      def object_loaded(argument_definition, object, context)
+      end
+
       # A call to `.authorized?` is starting
       # @param type [Class<GraphQL::Schema::Object>]
       # @param object [Object]

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

@@ -7,10 +7,17 @@ module GraphQL
       module HasNodeField
         def self.included(child_class)
           child_class.field(**field_options, &field_block)
+          child_class.extend(ExecutionMethods)
+        end
+
+        module ExecutionMethods
+          def get_relay_node(context, id:)
+            context.schema.object_from_id(id, context)
+          end
         end
 
         def get_relay_node(id:)
-          context.schema.object_from_id(id, context)
+          self.class.get_relay_node(context, id: id)
         end
 
         class << self
@@ -21,7 +28,8 @@ module GraphQL
               null: true,
               description: "Fetches an object given its ID.",
               relay_node_field: true,
-              resolver_method: :get_relay_node
+              resolver_method: :get_relay_node,
+              resolve_static: :get_relay_node,
             }
           end
 

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

@@ -7,10 +7,17 @@ module GraphQL
       module HasNodesField
         def self.included(child_class)
           child_class.field(**field_options, &field_block)
+          child_class.extend(ExecutionMethods)
+        end
+
+        module ExecutionMethods
+          def get_relay_nodes(context, ids:)
+            ids.map { |id| context.schema.object_from_id(id, context) }
+          end
         end
 
         def get_relay_nodes(ids:)
-          ids.map { |id| context.schema.object_from_id(id, context) }
+          self.class.get_relay_nodes(context, ids: ids)
         end
 
         class << self
@@ -21,7 +28,8 @@ module GraphQL
               null: false,
               description: "Fetches a list of objects given a list of IDs.",
               relay_nodes_field: true,
-              resolver_method: :get_relay_nodes
+              resolver_method: :get_relay_nodes,
+              resolve_static: :get_relay_nodes
             }
           end
 

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

@@ -6,12 +6,13 @@ module GraphQL
       module NodeBehaviors
         def self.included(child_module)
           child_module.extend(ClassMethods)
+          child_module.extend(ExecutionMethods)
           child_module.description("An object with an ID.")
-          child_module.field(:id, ID, null: false, description: "ID of the object.", resolver_method: :default_global_id)
+          child_module.field(:id, ID, null: false, description: "ID of the object.", resolver_method: :default_global_id, resolve_each: :default_global_id)
         end
 
         def default_global_id
-          context.schema.id_from_object(object, self.class, context)
+          self.class.default_global_id(object, context)
         end
 
         module ClassMethods
@@ -19,6 +20,16 @@ module GraphQL
             true
           end
         end
+
+        module ExecutionMethods
+          def default_global_id(object, context)
+            context.schema.id_from_object(object, self, context)
+          end
+
+          def included(child_class)
+            child_class.extend(ExecutionMethods)
+          end
+        end
       end
     end
   end

data/lib/graphql/unauthorized_error.rb

@@ -29,5 +29,9 @@ module GraphQL
     end
 
     attr_accessor :path, :ast_nodes
+
+    def finalize_graphql_result(query, result_data, key)
+      result_data[key] = nil
+    end
   end
 end

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -21,9 +21,6 @@ module GraphQL
   class Error < StandardError
   end
 
-  class RuntimeError < Error
-  end
-
   # This error is raised when GraphQL-Ruby encounters a situation
   # that it *thought* would never happen. Please report this bug!
   class InvariantError < Error
@@ -122,6 +119,7 @@ This is probably a bug in GraphQL-Ruby, please report this error on GitHub: http
   autoload :ParseError, "graphql/parse_error"
   autoload :Backtrace, "graphql/backtrace"
 
+  autoload :RuntimeError, "graphql/runtime_error"
   autoload :UnauthorizedError, "graphql/unauthorized_error"
   autoload :UnauthorizedEnumValueError, "graphql/unauthorized_enum_value_error"
   autoload :UnauthorizedFieldError, "graphql/unauthorized_field_error"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.20
+  version: 2.6.0
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-02-23 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -491,14 +491,11 @@ files:
 - lib/graphql/dig.rb
 - lib/graphql/duration_encoding_error.rb
 - lib/graphql/execution.rb
-- lib/graphql/execution/batching.rb
-- lib/graphql/execution/batching/field_compatibility.rb
-- lib/graphql/execution/batching/field_resolve_step.rb
-- lib/graphql/execution/batching/prepare_object_step.rb
-- lib/graphql/execution/batching/runner.rb
-- lib/graphql/execution/batching/selections_step.rb
 - lib/graphql/execution/directive_checks.rb
 - lib/graphql/execution/errors.rb
+- lib/graphql/execution/field_resolve_step.rb
+- lib/graphql/execution/finalize.rb
+- lib/graphql/execution/input_values.rb
 - lib/graphql/execution/interpreter.rb
 - lib/graphql/execution/interpreter/argument_value.rb
 - lib/graphql/execution/interpreter/arguments.rb
@@ -510,8 +507,13 @@ files:
 - lib/graphql/execution/interpreter/runtime/graphql_result.rb
 - lib/graphql/execution/lazy.rb
 - lib/graphql/execution/lazy/lazy_method_map.rb
+- lib/graphql/execution/load_argument_step.rb
 - lib/graphql/execution/lookahead.rb
 - lib/graphql/execution/multiplex.rb
+- lib/graphql/execution/next.rb
+- lib/graphql/execution/prepare_object_step.rb
+- lib/graphql/execution/runner.rb
+- lib/graphql/execution/selections_step.rb
 - lib/graphql/execution_error.rb
 - lib/graphql/integer_decoding_error.rb
 - lib/graphql/integer_encoding_error.rb
@@ -577,6 +579,7 @@ files:
 - lib/graphql/rubocop/graphql/default_required_true.rb
 - lib/graphql/rubocop/graphql/field_type_in_block.rb
 - lib/graphql/rubocop/graphql/root_types_in_block.rb
+- lib/graphql/runtime_error.rb
 - lib/graphql/runtime_type_error.rb
 - lib/graphql/schema.rb
 - lib/graphql/schema/addition.rb
@@ -617,6 +620,7 @@ files:
 - lib/graphql/schema/member/graphql_type_names.rb
 - lib/graphql/schema/member/has_arguments.rb
 - lib/graphql/schema/member/has_ast_node.rb
+- lib/graphql/schema/member/has_authorization.rb
 - lib/graphql/schema/member/has_dataloader.rb
 - lib/graphql/schema/member/has_deprecation_reason.rb
 - lib/graphql/schema/member/has_directives.rb
@@ -830,7 +834,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []

data/lib/graphql/execution/batching/field_compatibility.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    module Batching
-      module FieldCompatibility
-        def resolve_all_load_arguments(frs, object_from_id_receiver, arguments, argument_owner, context)
-          arg_defns = context.types.arguments(argument_owner)
-          arg_defns.each do |arg_defn|
-            if arg_defn.loads
-              if arguments.key?(arg_defn.keyword)
-                id = arguments.delete(arg_defn.keyword)
-                if !id.nil?
-                  value = if arg_defn.type.list?
-                    id.map {  |inner_id|
-                      object_from_id_receiver.load_and_authorize_application_object(arg_defn, inner_id, context)
-                    }
-                  else
-                    object_from_id_receiver.load_and_authorize_application_object(arg_defn, id, context)
-                  end
-
-                  if frs.runner.resolves_lazies
-                    value = frs.sync(value)
-                  end
-                  if value.is_a?(GraphQL::Error)
-                    value.path = frs.path
-                    return value
-                  end
-                else
-                  value = nil
-                end
-                arguments[arg_defn.keyword] = value
-              end
-            elsif (input_type = arg_defn.type.unwrap).kind.input_object? &&
-                (value = arguments[arg_defn.keyword]) # TODO lists
-              resolve_all_load_arguments(frs, object_from_id_receiver, value, input_type, context)
-            end
-          end
-          nil
-        end
-
-        def resolve_batch(frs, objects, context, kwargs)
-          if @batch_mode && !:direct_send.equal?(@batch_mode)
-            return super
-          end
-
-          if !@resolver_class
-            maybe_err = resolve_all_load_arguments(frs, self, kwargs, self, context)
-            if maybe_err
-              return maybe_err
-            end
-          end
-          if extras.include?(:lookahead)
-            if kwargs.frozen?
-              kwargs = kwargs.dup
-            end
-            kwargs[:lookahead] = Execution::Lookahead.new(
-              query: context.query,
-              ast_nodes: frs.ast_nodes || Array(frs.ast_node),
-              field: self,
-            )
-          end
-
-          if extras.include?(:ast_node)
-            if kwargs.frozen?
-              kwargs = kwargs.dup
-            end
-            kwargs[:ast_node] = frs.ast_node
-          end
-
-          if @owner.method_defined?(@resolver_method)
-            results = []
-            frs.selections_step.graphql_objects.each_with_index do |obj_inst, idx|
-              if frs.object_is_authorized[idx]
-                if dynamic_introspection
-                  obj_inst = @owner.wrap(obj_inst, context)
-                end
-                results << with_extensions(obj_inst, kwargs, context) do |obj, ruby_kwargs|
-                  if ruby_kwargs.empty?
-                    obj.public_send(@resolver_method)
-                  else
-                    obj.public_send(@resolver_method, **ruby_kwargs)
-                  end
-                end
-              end
-            end
-            results
-          elsif @resolver_class
-            objects.map do |o|
-              resolver_inst_kwargs = kwargs.dup
-              resolver_inst = @resolver_class.new(object: o, context: context, field: self)
-              maybe_err = resolve_all_load_arguments(frs, resolver_inst, resolver_inst_kwargs, self, context)
-              if maybe_err
-                next maybe_err
-              end
-              resolver_inst_kwargs = if @resolver_class < Schema::HasSingleInputArgument
-                resolver_inst_kwargs[:input]
-              else
-                resolver_inst_kwargs
-              end
-              with_extensions(o, resolver_inst_kwargs, context) do |obj, ruby_kwargs|
-                resolver_inst.object = obj
-                resolver_inst.prepared_arguments = ruby_kwargs
-                is_authed, new_return_value = resolver_inst.authorized?(**ruby_kwargs)
-                if frs.runner.resolves_lazies && frs.runner.schema.lazy?(is_authed)
-                  is_authed, new_return_value = frs.runner.schema.sync_lazy(is_authed)
-                end
-                if is_authed
-                  resolver_inst.call_resolve(ruby_kwargs)
-                else
-                  new_return_value
-                end
-              end
-            rescue RuntimeError => err
-              err
-            rescue StandardError => stderr
-              begin
-                context.query.handle_or_reraise(stderr)
-              rescue GraphQL::ExecutionError => ex_err
-                ex_err
-              end
-            end
-          elsif objects.first.is_a?(Hash)
-            objects.map { |o| o[method_sym] || o[graphql_name] }
-          elsif objects.first.is_a?(Interpreter::RawValue)
-            objects
-          else
-            # need to use connection extension if present, and extensions expect object type instances
-            if extensions.empty?
-              objects.map { |o| o.public_send(@method_sym)}
-            else
-              results = []
-              frs.selections_step.graphql_objects.each_with_index do |obj_inst, idx|
-                if frs.object_is_authorized[idx]
-                  results << with_extensions(obj_inst, EmptyObjects::EMPTY_HASH, context) do |obj, arguments|
-                    if arguments.empty?
-                      obj.object.public_send(@method_sym)
-                    else
-                      obj.object.public_send(@method_sym, **arguments)
-                    end
-                  end
-                end
-              end
-              results
-            end
-          end
-        end
-      end
-    end
-  end
-end