graphql 2.6.1 → 2.6.3

data/lib/graphql/schema/subscription.rb

@@ -30,14 +30,47 @@ module GraphQL
         end
       end
 
+      # @api private
+      def call_resolve(args_hash)
+        if @field_resolve_step.nil?
+          super
+        else
+          context.namespace(:subscriptions)[:update_event] = event
+          result = nil
+          unsubscribed = true
+          unsubscribed_result = nil
+          begin
+            result = super
+            unsubscribed = false
+          rescue EarlyUnsubscribe => err
+            unsubscribed_result = err.unsubscribed_result
+          end
+
+
+          if unsubscribed
+            if unsubscribed_result
+              context.namespace(:subscriptions)[:final_update] = true
+              unsubscribed_result
+            else
+              context.skip
+            end
+          else
+            result
+          end
+        end
+      end
+
       # @api private
       def resolve_with_support(**args)
         @original_arguments = args # before `loads:` have been run
         result = nil
         unsubscribed = true
-        unsubscribed_result = catch :graphql_subscription_unsubscribed do
+        unsubscribed_result = nil
+        begin
           result = super
           unsubscribed = false
+        rescue EarlyUnsubscribe => err
+          unsubscribed_result = err.unsubscribed_result
         end
 
 
@@ -114,7 +147,13 @@ module GraphQL
       # @return [void]
       def unsubscribe(update_value = nil)
         context.namespace(:subscriptions)[:unsubscribed] = true
-        throw :graphql_subscription_unsubscribed, update_value
+        err = EarlyUnsubscribe.new
+        err.unsubscribed_result = update_value
+        raise err
+      end
+
+      class EarlyUnsubscribe < GraphQL::RuntimeError
+        attr_accessor :unsubscribed_result
       end
 
       # Call this method to provide a new subscription_scope; OR
@@ -187,12 +226,18 @@ module GraphQL
 
       # @return [Subscriptions::Event] This object is used as a representation of this subscription for the backend
       def event
-        @event ||= Subscriptions::Event.new(
-          name: field.name,
-          arguments: @original_arguments,
-          context: context,
-          field: field,
-        )
+        @event ||= begin
+          if @original_arguments.nil? && @field_resolve_step
+            @original_arguments, _errors = @field_resolve_step.arguments_without_loads
+          end
+
+          Subscriptions::Event.new(
+            name: field.name,
+            arguments: @original_arguments,
+            context: context,
+            field: field,
+          )
+        end
       end
     end
   end

data/lib/graphql/schema/timeout.rb

@@ -68,7 +68,7 @@ module GraphQL
           super
         end
 
-        def execute_field(query:, field:, **_rest)
+        def begin_execute_field(field, _arguments, _objects, query)
           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
@@ -84,7 +84,7 @@ module GraphQL
 
             # `handle_timeout` may have set this to be `false`
             if timeout_state != false
-              error
+              raise error
             else
               super
             end

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

@@ -8,7 +8,7 @@ module GraphQL
       # @example Require a non-empty string for an argument
       #   argument :name, String, required: true, validate: { allow_blank: false }
       class AllowBlankValidator < Validator
-        def initialize(allow_blank_positional, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
+        def initialize(allow_blank_positional = nil, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
           @message = message
           super(**default_options)
           @allow_blank = allow_blank.nil? ? allow_blank_positional : allow_blank
@@ -16,10 +16,10 @@ module GraphQL
 
         def validate(_object, _context, value)
           if value.respond_to?(:blank?) && value.blank?
-            if (value.nil? && @allow_null) || @allow_blank
+            if (value.nil? && validation_parameter(@allow_null)) || validation_parameter(@allow_blank)
               # pass
             else
-              @message
+              validation_parameter(@message)
             end
           end
         end

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

@@ -9,15 +9,15 @@ module GraphQL
       #   argument :name, String, required: false, validates: { allow_null: false }
       class AllowNullValidator < Validator
         MESSAGE = "%{validated} can't be null"
-        def initialize(allow_null_positional, allow_null: nil, message: MESSAGE, **default_options)
+        def initialize(allow_null_positional = nil, allow_null: nil, message: MESSAGE, **default_options)
           @message = message
           super(**default_options)
           @allow_null = allow_null.nil? ? allow_null_positional : allow_null
         end
 
         def validate(_object, _context, value)
-          if value.nil? && !@allow_null
-            @message
+          if value.nil? && !validation_parameter(@allow_null)
+            validation_parameter(@message)
           end
         end
       end

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

@@ -23,8 +23,8 @@ module GraphQL
         def validate(_object, _context, value)
           if permitted_empty_value?(value)
             # pass
-          elsif @in_list.include?(value)
-            @message
+          elsif validation_parameter(@in_list).include?(value)
+            validation_parameter(@message)
           end
         end
       end

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

@@ -37,9 +37,9 @@ module GraphQL
           if permitted_empty_value?(value)
             # Do nothing
           elsif value.nil? ||
-              (@with_pattern && !value.match?(@with_pattern)) ||
-              (@without_pattern && value.match?(@without_pattern))
-            @message
+              (@with_pattern && !value.match?(validation_parameter(@with_pattern))) ||
+              (@without_pattern && value.match?(validation_parameter(@without_pattern)))
+            validation_parameter(@message)
           end
         end
       end

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

@@ -25,8 +25,8 @@ module GraphQL
         def validate(_object, _context, value)
           if permitted_empty_value?(value)
             # pass
-          elsif !@in_list.include?(value)
-            @message
+          elsif !validation_parameter(@in_list).include?(value)
+            validation_parameter(@message)
           end
         end
       end

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

@@ -45,12 +45,12 @@ module GraphQL
         def validate(_object, _context, value)
           return if permitted_empty_value?(value) # pass in this case
           length = value.nil? ? 0 : value.length
-          if @maximum && length > @maximum
-            partial_format(@too_long, { count: @maximum })
-          elsif @minimum && length < @minimum
-            partial_format(@too_short, { count: @minimum })
-          elsif @is && length != @is
-            partial_format(@wrong_length, { count: @is })
+          if (current_max = validation_parameter(@maximum)) && length > current_max
+            partial_format(validation_parameter(@too_long), { count: current_max })
+          elsif (current_min = validation_parameter(@minimum)) && length < current_min
+            partial_format(validation_parameter(@too_short), { count: current_min })
+          elsif (current_is = validation_parameter(@is)) && length != current_is
+            partial_format(validation_parameter(@wrong_length), { count: current_is })
           end
         end
       end

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

@@ -55,25 +55,25 @@ module GraphQL
           if permitted_empty_value?(value)
             # pass in this case
           elsif value.nil? # @allow_null is handled in the parent class
-            @null_message
-          elsif @greater_than && value <= @greater_than
-            partial_format(@message, { comparison: "greater than", target: @greater_than })
-          elsif @greater_than_or_equal_to && value < @greater_than_or_equal_to
-            partial_format(@message, { comparison: "greater than or equal to", target: @greater_than_or_equal_to })
-          elsif @less_than && value >= @less_than
-            partial_format(@message, { comparison: "less than", target: @less_than })
-          elsif @less_than_or_equal_to && value > @less_than_or_equal_to
-            partial_format(@message, { comparison: "less than or equal to", target: @less_than_or_equal_to })
-          elsif @equal_to && value != @equal_to
-            partial_format(@message, { comparison: "equal to", target: @equal_to })
-          elsif @other_than && value == @other_than
-            partial_format(@message, { comparison: "something other than", target: @other_than })
-          elsif @even && !value.even?
-            (partial_format(@message, { comparison: "even", target: "" })).strip
-          elsif @odd && !value.odd?
-            (partial_format(@message, { comparison: "odd", target: "" })).strip
-          elsif @within && !@within.include?(value)
-            partial_format(@message, { comparison: "within", target: @within })
+            validation_parameter(@null_message)
+          elsif (current_greater_than = validation_parameter(@greater_than)) && value <= current_greater_than
+            partial_format(validation_parameter(@message), { comparison: "greater than", target: current_greater_than })
+          elsif (current_greater_than_or_equal_to = validation_parameter(@greater_than_or_equal_to)) && value < current_greater_than_or_equal_to
+            partial_format(validation_parameter(@message), { comparison: "greater than or equal to", target: current_greater_than_or_equal_to })
+          elsif (current_less_than = validation_parameter(@less_than)) && value >= current_less_than
+            partial_format(validation_parameter(@message), { comparison: "less than", target: current_less_than })
+          elsif (current_less_than_or_equal_to = validation_parameter(@less_than_or_equal_to)) && value > current_less_than_or_equal_to
+            partial_format(validation_parameter(@message), { comparison: "less than or equal to", target: current_less_than_or_equal_to })
+          elsif (current_equal_to = validation_parameter(@equal_to)) && value != current_equal_to
+            partial_format(validation_parameter(@message), { comparison: "equal to", target: current_equal_to })
+          elsif (current_other_than = validation_parameter(@other_than)) && value == current_other_than
+            partial_format(validation_parameter(@message), { comparison: "something other than", target: current_other_than })
+          elsif validation_parameter(@even) && !value.even?
+            (partial_format(validation_parameter(@message), { comparison: "even", target: "" })).strip
+          elsif validation_parameter(@odd) && !value.odd?
+            (partial_format(validation_parameter(@message), { comparison: "odd", target: "" })).strip
+          elsif (current_within = validation_parameter(@within)) && !current_within.include?(value)
+            partial_format(validation_parameter(@message), { comparison: "within", target: current_within })
           end
         end
       end

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

@@ -67,7 +67,8 @@ module GraphQL
           no_visible_conditions = true
 
           if !value.nil?
-            @one_of.each do |one_of_condition|
+            validation_parameter(@one_of).each do |one_of_condition|
+              one_of_condition = validation_parameter(one_of_condition)
               case one_of_condition
               when Symbol
                 if no_visible_conditions && visible_keywords.include?(one_of_condition)
@@ -108,7 +109,7 @@ module GraphQL
           end
 
           if no_visible_conditions
-            if @allow_all_hidden
+            if validation_parameter(@allow_all_hidden)
               return nil
             else
               raise GraphQL::Error, <<~ERR
@@ -122,7 +123,7 @@ module GraphQL
           if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else
-            @message || build_message(context)
+            validation_parameter(@message) || build_message(context)
           end
         end
 
@@ -130,8 +131,9 @@ module GraphQL
           argument_definitions = context.types.arguments(@validated)
 
           required_names = @one_of.map do |arg_keyword|
+            arg_keyword = validation_parameter(arg_keyword)
             if arg_keyword.is_a?(Array)
-              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
+              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, validation_parameter(arg)) }
               names.compact! # hidden arguments are `nil`
               "(" + names.join(" and ") + ")"
             else

data/lib/graphql/schema/validator.rb

@@ -34,6 +34,15 @@ module GraphQL
         string
       end
 
+      # @return [Object] The current value to use for validation, based on `config_value` from configuration time. If a Proc is given, this calls it and returns it.
+      def validation_parameter(config_value)
+        if config_value.is_a?(Proc)
+          config_value.call
+        else
+          config_value
+        end
+      end
+
       # @return [Boolean] `true` if `value` is `nil` and this validator has `allow_null: true` or if value is `.blank?` and this validator has `allow_blank: true`
       def permitted_empty_value?(value)
         (value.nil? && @allow_null) ||

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

@@ -290,11 +290,13 @@ module GraphQL
             end
             # Lots more to do here
           end
-          @schema.introspection_system.entry_points.each do |f|
-            arguments(f).each do |arg|
-              argument(f, arg.graphql_name)
+          if @schema.query
+            @schema.introspection_system.entry_points.each do |f|
+              arguments(f).each do |arg|
+                argument(f, arg.graphql_name)
+              end
+              field(@schema.query, f.graphql_name)
             end
-            field(@schema.query, f.graphql_name)
           end
           @schema.introspection_system.dynamic_fields.each do |f|
             arguments(f).each do |arg|

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

@@ -102,7 +102,7 @@ module GraphQL
 
             missed_late_types_streak = 0
             while (owner, late_type = @late_bound_types.shift)
-              if (late_type.is_a?(String) && (type = Member::BuildType.constantize(type))) ||
+              if (late_type.is_a?(String) && (type = Member::BuildType.constantize(late_type))) ||
                   (late_type.is_a?(LateBoundType) && (type = @visited_types.find { |t| t.graphql_name == late_type.graphql_name }))
                 missed_late_types_streak = 0 # might succeed next round
                 update_type_owner(owner, type)

data/lib/graphql/schema/visibility.rb

@@ -8,11 +8,17 @@ module GraphQL
     # Use this plugin to make some parts of your schema hidden from some viewers.
     #
     class Visibility
+      class TypeConfigurationError < GraphQL::Error
+        def initialize(config_message, config_str)
+          message = "GraphQL::Schema::Visibility already preloaded, but #{config_message} added to the schema. Move this `#{config_str}` configuration above `use(GraphQL::Schema::Visibility)"
+          super(message)
+        end
+      end
       # @param schema [Class<GraphQL::Schema>]
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
       # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging?) : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging? || nil) : false), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze
@@ -20,7 +26,7 @@ module GraphQL
         schema.visibility = self.new(schema, dynamic: dynamic, preload: preload, profiles: profiles, migration_errors: migration_errors)
       end
 
-      def initialize(schema, dynamic:, preload:, profiles:, migration_errors:)
+      def initialize(schema, dynamic:, preload:, profiles:, migration_errors:, configuration_inherited: false)
         @schema = schema
         schema.use_visibility_profile = true
         schema.visibility_profile_class = if migration_errors
@@ -40,6 +46,7 @@ module GraphQL
         @types = nil
         @all_references = nil
         @loaded_all = false
+        @configuration_inherited = configuration_inherited
         if preload
           self.preload
         end
@@ -94,6 +101,7 @@ module GraphQL
         # Root types may have been nil:
         types_to_visit.compact!
         ensure_all_loaded(types_to_visit)
+        @cached_profiles.clear
         @profiles.each do |profile_name, example_ctx|
           prof = profile_for(example_ctx)
           prof.preload
@@ -102,41 +110,27 @@ module GraphQL
 
       # @api private
       def query_configured(query_type)
-        if @preload
-          ensure_all_loaded([query_type])
-        end
+        require_if_preloaded("a query type was", "query(...)")
       end
 
       # @api private
       def mutation_configured(mutation_type)
-        if @preload
-          ensure_all_loaded([mutation_type])
-        end
+        require_if_preloaded("a mutation type was", "mutation(...)")
       end
 
       # @api private
       def subscription_configured(subscription_type)
-        if @preload
-          ensure_all_loaded([subscription_type])
-        end
+        require_if_preloaded("a mutation type was", "subscription(...)")
       end
 
       # @api private
       def orphan_types_configured(orphan_types)
-        if @preload
-          ensure_all_loaded(orphan_types)
-        end
+        require_if_preloaded("orphan types were", "orphan_types(...)")
       end
 
       # @api private
       def introspection_system_configured(introspection_system)
-        if @preload
-          introspection_types = [
-            *@schema.introspection_system.types.values,
-            *@schema.introspection_system.entry_points.map { |ep| ep.type.unwrap },
-          ]
-          ensure_all_loaded(introspection_types)
-        end
+        require_if_preloaded("custom introspection was", "introspection(...)")
       end
 
       # Make another Visibility for `schema` based on this one
@@ -148,7 +142,8 @@ module GraphQL
           dynamic: @dynamic,
           preload: @preload,
           profiles: @profiles,
-          migration_errors: @migration_errors
+          migration_errors: @migration_errors,
+          configuration_inherited: true,
         )
       end
 
@@ -196,6 +191,19 @@ module GraphQL
 
       private
 
+      def require_if_preloaded(config_message, config_code)
+        case @preload
+        when false
+          # Rails.env wasn't defined, so this won't try to preload unless manually set to true
+        when true, nil
+          if @configuration_inherited
+            preload
+          else
+            raise TypeConfigurationError.new(config_message, config_code)
+          end
+        end
+      end
+
       def ensure_all_loaded(types_to_visit)
         while (type = types_to_visit.shift)
           if type.kind.fields? && @preloaded_types.add?(type)

data/lib/graphql/schema.rb

@@ -757,6 +757,7 @@ module GraphQL
           # reset this cached value:
           @introspection_system = nil
           introspection_system
+          self.visibility&.introspection_system_configured(introspection_system)
           @introspection
         else
           @introspection || find_inherited_value(:introspection)
@@ -768,7 +769,6 @@ module GraphQL
         if !@introspection_system
           @introspection_system = Schema::IntrospectionSystem.new(self)
           @introspection_system.resolve_late_bindings
-          self.visibility&.introspection_system_configured(@introspection_system)
         end
         @introspection_system
       end
@@ -1150,17 +1150,14 @@ module GraphQL
       attr_accessor :using_backtrace
 
       # @api private
-      def handle_or_reraise(context, err)
+      def handle_or_reraise(context, err, object: context[:current_object], arguments: context[:current_arguments], field: context[:current_field])
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
-          obj = context[:current_object]
-          args = context[:current_arguments]
-          args = args && args.respond_to?(:keyword_arguments) ? args.keyword_arguments : nil
-          field = context[:current_field]
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
+          arguments = arguments.respond_to?(:keyword_arguments) ? arguments.keyword_arguments : arguments
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
           end
-          handler[:handler].call(err, obj, args, context, field)
+          handler[:handler].call(err, object, arguments, context, field)
         else
           if (context[:backtrace] || using_backtrace) && !err.is_a?(GraphQL::ExecutionError)
             err = GraphQL::Backtrace::TracedError.new(err, context)
@@ -1587,6 +1584,14 @@ module GraphQL
       # @see {Query#initialize} for arguments.
       # @return [GraphQL::Query::Result] query result, ready to be serialized as JSON
       def execute(query_str = nil, **kwargs)
+        if default_execution_next
+          execute_next(query_str, **kwargs)
+        else
+          execute_legacy(query_str, **kwargs)
+        end
+      end
+
+      def execute_legacy(query_str = nil, **kwargs)
         if query_str
           kwargs[:query] = query_str
         end
@@ -1628,7 +1633,23 @@ module GraphQL
       # @option kwargs [nil, Integer] :max_complexity (nil)
       # @return [Array<GraphQL::Query::Result>] One result for each query in the input
       def multiplex(queries, **kwargs)
-        GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
+        if @default_execution_next
+          multiplex_next(queries, **kwargs)
+        else
+          GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
+        end
+      end
+
+      def default_execution_next(new_value = NOT_CONFIGURED)
+        if !NOT_CONFIGURED.equal?(new_value)
+          @default_execution_next = new_value
+        elsif instance_variable_defined?(:@default_execution_next)
+          @default_execution_next
+        elsif superclass.respond_to?(:default_execution_next)
+          superclass.default_execution_next
+        else
+          false
+        end
       end
 
       def instrumenters

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -54,6 +54,12 @@ module GraphQL
             events << subscription_instance.event
           end
           value
+        elsif (exec_next_update_event = context.namespace(:subscriptions)[:update_event])
+          if context.query.subscription_topic == exec_next_update_event.topic
+            value
+          else
+            context.skip
+          end
         elsif (events = context.namespace(:subscriptions)[:events])
           # This is the first execution, so gather an Event
           # for the backend to register:

data/lib/graphql/subscriptions/event.rb

@@ -104,7 +104,6 @@ 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/tracing/perfetto_trace.rb

@@ -67,6 +67,8 @@ module GraphQL
         DA_FETCH_KEYS_IID => "fetch keys",
       }
 
+      ANON_CLASS_NAME = "(anonymous)"
+
       DEBUG_INSPECT_CATEGORY_IIDS = [15]
       DA_DEBUG_INSPECT_CLASS_IID = 16
       DEBUG_INSPECT_EVENT_NAME_IID = 17
@@ -118,7 +120,7 @@ module GraphQL
         }
 
         @source_name_iids = Hash.new do |h, source_class|
-          h[source_class] = @interned_event_name_iids[source_class.name]
+          h[source_class] = @interned_event_name_iids[source_class.name || ANON_CLASS_NAME]
         end.compare_by_identity
 
         @auth_name_iids = Hash.new do |h, graphql_type|
@@ -144,7 +146,7 @@ module GraphQL
         end
 
         @class_name_iids = Hash.new do |h, k|
-          h[k] = @interned_da_string_values[k.name]
+          h[k] = @interned_da_string_values[k.name || ANON_CLASS_NAME]
         end.compare_by_identity
 
         @starting_objects = GC.stat(:total_allocated_objects)
@@ -682,7 +684,7 @@ module GraphQL
         when GraphQL::Schema::InputObject
           payload_to_debug(k, v.to_h, iid: iid, intern_value: intern_value)
         else
-          class_name_iid = @interned_da_string_values[(v.class.name || "(anonymous)")]
+          class_name_iid = @interned_da_string_values[(v.class.name || ANON_CLASS_NAME)]
           da = [
             debug_annotation(DA_DEBUG_INSPECT_CLASS_IID, :string_value_iid, class_name_iid),
           ]

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.6.3
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-04-27 00:00:00.000000000 Z
+date: 2026-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -512,6 +512,7 @@ files:
 - lib/graphql/execution/multiplex.rb
 - lib/graphql/execution/next.rb
 - lib/graphql/execution/prepare_object_step.rb
+- lib/graphql/execution/resolve_type_step.rb
 - lib/graphql/execution/runner.rb
 - lib/graphql/execution/selections_step.rb
 - lib/graphql/execution_error.rb