graphql 2.5.22 → 2.5.23

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

@@ -17,10 +17,34 @@ module GraphQL
         end
       end
 
+      def resolve_next(context:, objects:, arguments:)
+        has_override_implementation = @field.execution_next_mode != :direct_send
+
+        if !has_override_implementation
+          if context.query.subscription_update?
+            objects
+          else
+            objects.map { |o| context.skip }
+          end
+        else
+          yield(objects, arguments)
+        end
+      end
+
       def after_resolve(value:, context:, object:, arguments:, **rest)
+        self.class.write_subscription(@field, value, arguments, context)
+      end
+
+      def after_resolve_next(values:, context:, objects:, arguments:, **rest)
+        values.map do |value|
+          self.class.write_subscription(@field, value, arguments, context)
+        end
+      end
+
+      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,26 @@ 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
+
     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/unauthorized_error.rb

@@ -29,5 +29,9 @@ module GraphQL
     end
 
     attr_accessor :path, :ast_nodes
+
+    def assign_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.22"
+  VERSION = "2.5.23"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.22
+  version: 2.5.23
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -831,7 +831,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.8
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []