graphql 2.5.9 → 2.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d6def5d638ca63c24df116117624ac5bd6e87555457a38fb893a43a1b15600f
-  data.tar.gz: c74e1ae2276871b07decc70422ff48992d8a5c9c9bdbce23164b367c707fe078
+  metadata.gz: 13d11e14c49ac11e7f851c104641f4234ea464aa5aeb33a4ae50961f4da03e83
+  data.tar.gz: afc9ba506e4cf724b5ff508a73593330d37527461186cb92c264c411204fe13c
 SHA512:
-  metadata.gz: 333fdffd66163025d3dce807a12f7b2aeaceb932b5bd739d077a4d6d9ccbee92e891a24e68a8fb94f3f1157edc93abc01ac71fbef4ef0b64e2fc043ea4119488
-  data.tar.gz: c22ba9de28b9124a1d758ffd9f71a7b49da20780c55bc9ceda9fdb74d93042df17eeccb8b74cf7eba9a095bd9852a19e0673c85e473da509379f4520cb695da7
+  metadata.gz: f3196f1a70900ee0f2597ad54a16ecb960a7f8cefadda7aff81dce760aae2fad6e3a43c29fa3cd9a6792b82edfd34f6be70f9ae61ab1d6c98be01363acf618d9
+  data.tar.gz: 45bfc9181659e24ca4b1e5844942093293f60a13206670ae2c8bc657288a1c025a4dc348b1a0c702aa7bc5aaf80e2a83616db3807d735eee286dd6be4d2144fb

data/lib/graphql/dataloader/active_record_association_source.rb

@@ -31,7 +31,12 @@ module GraphQL
       def fetch(records)
         record_classes = Set.new.compare_by_identity
         associated_classes = Set.new.compare_by_identity
+        scoped_fetch = !@scope.nil?
         records.each do |record|
+          if scoped_fetch
+            assoc = record.association(@association)
+            assoc.reset
+          end
           if record_classes.add?(record.class)
             reflection = record.class.reflect_on_association(@association)
             if !reflection.polymorphic? && reflection.klass
@@ -48,9 +53,16 @@ module GraphQL
 
         ::ActiveRecord::Associations::Preloader.new(records: records, associations: @association, available_records: available_records, scope: @scope).call
 
-        loaded_associated_records = records.map { |r| r.public_send(@association) }
+        loaded_associated_records = records.map { |r|
+          assoc = r.association(@association)
+          lar = assoc.target
+          if scoped_fetch
+            assoc.reset
+          end
+          lar
+        }
 
-        if @scope.nil?
+        if !scoped_fetch
           # Don't cache records loaded via scope because they might have reduced `SELECT`s
           # Could check .select_values here?
           records_by_model = {}

data/lib/graphql/dataloader/null_dataloader.rb

@@ -9,8 +9,11 @@ module GraphQL
     class NullDataloader < Dataloader
       # These are all no-ops because code was
       # executed synchronously.
+
+      def initialize(*); end
       def run; end
       def run_isolated; yield; end
+      def clear_cache; end
       def yield(_source)
         raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
       end
@@ -19,6 +22,10 @@ module GraphQL
         yield
         nil
       end
+
+      def with(*)
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
     end
   end
 end

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

@@ -298,8 +298,6 @@ module GraphQL
           end
 
           call_method_on_directives(:resolve, selections_result.graphql_application_value, directives) do
-            finished_jobs = 0
-            enqueued_jobs = gathered_selections.size
             gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
               # Field resolution may pause the fiber,
               # so it wouldn't get to the `Resolve` call that happens below.
@@ -310,12 +308,6 @@ module GraphQL
                   evaluate_selection(
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
-                  finished_jobs += 1
-                  if finished_jobs == enqueued_jobs
-                    if target_result
-                      selections_result.merge_into(target_result)
-                    end
-                  end
                   @dataloader.clear_cache
                 }
               else
@@ -323,15 +315,12 @@ module GraphQL
                   evaluate_selection(
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
-                  finished_jobs += 1
-                  if finished_jobs == enqueued_jobs
-                    if target_result
-                      selections_result.merge_into(target_result)
-                    end
-                  end
                 }
               end
             end
+            if target_result
+              selections_result.merge_into(target_result)
+            end
             selections_result
           end
         end
@@ -557,7 +546,7 @@ module GraphQL
           path
         end
 
-        HALT = Object.new
+        HALT = Object.new.freeze
         def continue_value(value, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
           when nil

data/lib/graphql/language/lexer.rb

@@ -20,6 +20,11 @@ module GraphQL
         @finished
       end
 
+      def freeze
+        @scanner = nil
+        super
+      end
+
       attr_reader :pos, :tokens_count
 
       def advance
@@ -242,7 +247,7 @@ module GraphQL
         :SCALAR,
         nil,
         :FRAGMENT
-      ]
+      ].freeze
 
       # This produces a unique integer for bytes 2 and 3 of each keyword string
       # See https://tenderlovemaking.com/2023/09/02/fast-tokenizers-with-stringscanner.html
@@ -271,7 +276,8 @@ module GraphQL
       PUNCTUATION_NAME_FOR_BYTE = Punctuation.constants.each_with_object([]) { |name, arr|
         punct = Punctuation.const_get(name)
         arr[punct.ord] = name
-      }
+      }.freeze
+
 
       QUOTE =         '"'
       UNICODE_DIGIT = /[0-9A-Za-z]/
@@ -321,6 +327,7 @@ module GraphQL
         punct = Punctuation.const_get(punct_name)
         FIRST_BYTES[punct.ord] = ByteFor::PUNCTUATION
       end
+      FIRST_BYTES.freeze
 
 
       # Replace any escaped unicode or whitespace with the _actual_ characters

data/lib/graphql/language/nodes.rb

@@ -83,7 +83,11 @@ module GraphQL
 
         def to_query_string(printer: GraphQL::Language::Printer.new)
           if printer.is_a?(GraphQL::Language::Printer)
-            @query_string ||= printer.print(self)
+            if frozen?
+              @query_string || printer.print(self)
+            else
+              @query_string ||= printer.print(self)
+            end
           else
             printer.print(self)
           end

data/lib/graphql/language/parser.rb

@@ -2,6 +2,7 @@
 
 require "strscan"
 require "graphql/language/nodes"
+require "graphql/tracing/null_trace"
 
 module GraphQL
   module Language

data/lib/graphql/query/context.rb

@@ -84,7 +84,7 @@ module GraphQL
 
       attr_writer :types
 
-      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path]).freeze
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 

data/lib/graphql/schema/addition.rb

@@ -258,7 +258,9 @@ module GraphQL
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
                   implementers = @possible_types[interface_type] ||= []
-                  implementers << type
+                  if !implementers.include?(type)
+                    implementers << type
+                  end
                 end
               when String, Schema::LateBoundType
                 interface_type = interface_type_membership

data/lib/graphql/schema/argument.rb

@@ -212,6 +212,11 @@ module GraphQL
         @statically_coercible = !requires_parent_object
       end
 
+      def freeze
+        statically_coercible?
+        super
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private

data/lib/graphql/schema/build_from_definition.rb

@@ -187,6 +187,10 @@ module GraphQL
 
             object_types.each do |t|
               t.interfaces.each do |int_t|
+                if int_t.is_a?(LateBoundType)
+                  int_t = types[int_t.graphql_name]
+                  t.implements(int_t)
+                end
                 int_t.orphan_types(t)
               end
             end
@@ -519,7 +523,7 @@ module GraphQL
 
         def define_field_resolve_method(owner, method_name, field_name)
           owner.define_method(method_name) { |**args|
-            field_instance = self.class.get_field(field_name)
+            field_instance = context.types.field(owner, field_name)
             context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
           }
         end

data/lib/graphql/schema/field.rb

@@ -616,6 +616,14 @@ module GraphQL
         end
       end
 
+      def freeze
+        type
+        owner_type
+        arguments_statically_coercible?
+        connection?
+        super
+      end
+
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 

data/lib/graphql/schema/member/has_interfaces.rb

@@ -8,8 +8,8 @@ module GraphQL
           new_memberships = []
           new_interfaces.each do |int|
             if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+              unless int.include?(GraphQL::Schema::Interface) && !int.is_a?(Class)
+                raise "#{int.respond_to?(:graphql_name) ? "#{int.graphql_name} (#{int})" : int.inspect} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
               new_memberships << int.type_membership_class.new(int, self, **options)

data/lib/graphql/schema/member/type_system_helpers.rb

@@ -12,12 +12,26 @@ module GraphQL
 
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
-          @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
+          @to_non_null_type || begin
+            t = GraphQL::Schema::NonNull.new(self)
+            if frozen?
+              t
+            else
+              @to_non_null_type = t
+            end
+          end
         end
 
         # @return [Schema::List] Make a list-type representation of this type
         def to_list_type
-          @to_list_type ||= GraphQL::Schema::List.new(self)
+          @to_list_type || begin
+            t = GraphQL::Schema::List.new(self)
+            if frozen?
+              t
+            else
+              @to_list_type = t
+            end
+          end
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.

data/lib/graphql/schema/ractor_shareable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module RactorShareable
+      def self.extended(schema_class)
+        schema_class.extend(SchemaExtension)
+        schema_class.freeze_schema
+      end
+
+      module SchemaExtension
+
+        def freeze_error_handlers(handlers)
+          handlers[:subclass_handlers].default_proc = nil
+          handlers[:subclass_handlers].each do |_class, subclass_handlers|
+            freeze_error_handlers(subclass_handlers)
+          end
+          Ractor.make_shareable(handlers)
+        end
+
+        def freeze_schema
+          # warm some ivars:
+          default_analysis_engine
+          default_execution_strategy
+          GraphQL.default_parser
+          default_logger
+          freeze_error_handlers(error_handlers)
+          # TODO: this freezes errors of parent classes which could cause trouble
+          parent_class = superclass
+          while parent_class.respond_to?(:error_handlers)
+            freeze_error_handlers(parent_class.error_handlers)
+            parent_class = parent_class.superclass
+          end
+
+          own_tracers.freeze
+          @frozen_tracers = tracers.freeze
+          own_trace_modes.each do |m|
+            trace_options_for(m)
+            build_trace_mode(m)
+          end
+          build_trace_mode(:default)
+          Ractor.make_shareable(@trace_options_for_mode)
+          Ractor.make_shareable(own_trace_modes)
+          Ractor.make_shareable(own_multiplex_analyzers)
+          @frozen_multiplex_analyzers = Ractor.make_shareable(multiplex_analyzers)
+          Ractor.make_shareable(own_query_analyzers)
+          @frozen_query_analyzers = Ractor.make_shareable(query_analyzers)
+          Ractor.make_shareable(own_plugins)
+          own_plugins.each do |(plugin, options)|
+            Ractor.make_shareable(plugin)
+            Ractor.make_shareable(options)
+          end
+          @frozen_plugins = Ractor.make_shareable(plugins)
+          Ractor.make_shareable(own_references_to)
+          @frozen_directives = Ractor.make_shareable(directives)
+
+          Ractor.make_shareable(visibility)
+          Ractor.make_shareable(introspection_system)
+          extend(FrozenMethods)
+
+          Ractor.make_shareable(self)
+          superclass.respond_to?(:freeze_schema) && superclass.freeze_schema
+        end
+
+        module FrozenMethods
+          def tracers; @frozen_tracers; end
+          def multiplex_analyzers; @frozen_multiplex_analyzers; end
+          def query_analyzers; @frozen_query_analyzers; end
+          def plugins; @frozen_plugins; end
+          def directives; @frozen_directives; end
+
+          # This actually accumulates info during execution...
+          # How to support it?
+          def lazy?(_obj); false; end
+          def sync_lazy(obj); obj; end
+        end
+      end
+    end
+  end
+end

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

@@ -96,17 +96,26 @@ module GraphQL
         end
 
         def build_message(context)
-          argument_definitions = @validated.arguments(context).values
+          argument_definitions = context.types.arguments(@validated)
+
           required_names = @one_of.map do |arg_keyword|
             if arg_keyword.is_a?(Array)
               names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
+              names.compact! # hidden arguments are `nil`
               "(" + names.join(" and ") + ")"
             else
               arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
             end
           end
+          required_names.compact! # remove entries for hidden arguments
+
 
-          if required_names.size == 1
+          case required_names.size
+          when 0
+            # The required definitions were hidden from the client.
+            # Another option here would be to raise an error in the application....
+            "%{validated} is missing a required argument."
+          when 1
             "%{validated} must include the following argument: #{required_names.first}."
           else
             "%{validated} must include exactly one of the following arguments: #{required_names.join(", ")}."
@@ -115,7 +124,7 @@ module GraphQL
 
         def arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
           argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
-          argument_definition.graphql_name
+          argument_definition&.graphql_name
         end
       end
     end

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

@@ -76,10 +76,10 @@ module GraphQL
           end
         end
 
-        def initialize(context:, schema:, name: nil)
+        def initialize(context:, schema:, name: nil, visibility:)
           @name = name
           @skip_error = context[:skip_visibility_migration_error] || context.is_a?(Query::NullContext) || context.is_a?(Hash)
-          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema)
+          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema, visibility: visibility)
           if !@skip_error
             context[:visibility_migration_running] = true
             warden_ctx_vals = context.to_h.dup

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

@@ -31,10 +31,37 @@ module GraphQL
         # @return [Symbol, nil]
         attr_reader :name
 
-        def initialize(name: nil, context:, schema:)
+        def freeze
+          @cached_visible.default_proc = nil
+          @cached_visible_fields.default_proc = nil
+          @cached_visible_fields.each do |type, fields|
+            fields.default_proc = nil
+          end
+          @cached_visible_arguments.default_proc = nil
+          @cached_visible_arguments.each do |type, fields|
+            fields.default_proc = nil
+          end
+          @cached_parent_fields.default_proc = nil
+          @cached_parent_fields.each do |type, fields|
+            fields.default_proc = nil
+          end
+          @cached_parent_arguments.default_proc = nil
+          @cached_parent_arguments.each do |type, args|
+            args.default_proc = nil
+          end
+          @cached_possible_types.default_proc = nil
+          @cached_enum_values.default_proc = nil
+          @cached_fields.default_proc = nil
+          @cached_arguments.default_proc = nil
+          @loadable_possible_types.default_proc = nil
+          super
+        end
+
+        def initialize(name: nil, context:, schema:, visibility:)
           @name = name
           @context = context
           @schema = schema
+          @visibility = visibility
           @all_types = {}
           @all_types_loaded = false
           @unvisited_types = []
@@ -122,7 +149,7 @@ module GraphQL
         end
 
         def type(type_name)
-          t = @schema.visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+          t = @visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
           if t
             if t.is_a?(Array)
               vis_t = nil
@@ -250,8 +277,8 @@ module GraphQL
         end
 
         def directives
-          @all_directives ||= @schema.visibility.all_directives.select { |dir|
-            @cached_visible[dir] && @schema.visibility.all_references[dir].any? { |ref| ref == true || (@cached_visible[ref] && referenced?(ref)) }
+          @all_directives ||= @visibility.all_directives.select { |dir|
+            @cached_visible[dir] && @visibility.all_references[dir].any? { |ref| ref == true || (@cached_visible[ref] && referenced?(ref)) }
           }
         end
 
@@ -276,6 +303,42 @@ module GraphQL
           @cached_visible[enum_value]
         end
 
+        def preload
+          load_all_types
+          @all_types.each do |type_name, type_defn|
+            if type_defn.kind.fields?
+              fields(type_defn).each do |f|
+                field(type_defn, f.graphql_name)
+                arguments(f).each do |arg|
+                  argument(f, arg.graphql_name)
+                end
+              end
+              @schema.introspection_system.dynamic_fields.each do |f|
+                field(type_defn, f.graphql_name)
+              end
+            elsif type_defn.kind.input_object?
+              arguments(type_defn).each do |arg|
+                argument(type_defn, arg.graphql_name)
+              end
+            elsif type_defn.kind.enum?
+              enum_values(type_defn)
+            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)
+            end
+            field(@schema.query, f.graphql_name)
+          end
+          @schema.introspection_system.dynamic_fields.each do |f|
+            arguments(f).each do |arg|
+              argument(f, arg.graphql_name)
+            end
+          end
+
+        end
+
         private
 
         def non_duplicate_items(definitions, visibility_cache)
@@ -322,7 +385,7 @@ module GraphQL
         end
 
         def referenced?(type_defn)
-          @schema.visibility.all_references[type_defn].any? do |ref|
+          @visibility.all_references[type_defn].any? do |ref|
             case ref
             when GraphQL::Schema::Argument
               @cached_visible_arguments[ref.owner][ref]
@@ -340,9 +403,11 @@ module GraphQL
           case type.kind.name
           when "INTERFACE"
             pts = []
-            @schema.visibility.all_interface_type_memberships[type].each do |(itm, impl_type)|
-              if @cached_visible[itm] && @cached_visible[impl_type] && referenced?(impl_type)
-                pts << impl_type
+            @visibility.all_interface_type_memberships[type].each do |impl_type, type_memberships|
+              if impl_type.kind.object? && referenced?(impl_type) && @cached_visible[impl_type]
+                if type_memberships.any? { |itm| @cached_visible[itm] }
+                  pts << impl_type
+                end
               end
             end
             pts

data/lib/graphql/schema/visibility.rb

@@ -18,9 +18,6 @@ module GraphQL
           ctx.freeze
         }
         schema.visibility = self.new(schema, dynamic: dynamic, preload: preload, profiles: profiles, migration_errors: migration_errors)
-        if preload
-          schema.visibility.preload
-        end
       end
 
       def initialize(schema, dynamic:, preload:, profiles:, migration_errors:)
@@ -43,6 +40,17 @@ module GraphQL
         @types = nil
         @all_references = nil
         @loaded_all = false
+        if preload
+          self.preload
+        end
+      end
+
+      def freeze
+        load_all
+        @visit = true
+        @interface_type_memberships.default_proc = nil
+        @all_references.default_proc = nil
+        super
       end
 
       def all_directives
@@ -65,6 +73,8 @@ module GraphQL
         @types[type_name]
       end
 
+      attr_accessor :types
+
       def preload?
         @preload
       end
@@ -86,7 +96,7 @@ module GraphQL
         ensure_all_loaded(types_to_visit)
         @profiles.each do |profile_name, example_ctx|
           prof = profile_for(example_ctx)
-          prof.all_types # force loading
+          prof.preload
         end
       end
 
@@ -153,12 +163,12 @@ module GraphQL
           visibility_profile = context[:visibility_profile]
           if @profiles.include?(visibility_profile)
             profile_ctx = @profiles[visibility_profile]
-            @cached_profiles[visibility_profile] ||= @schema.visibility_profile_class.new(name: visibility_profile, context: profile_ctx, schema: @schema)
+            @cached_profiles[visibility_profile] ||= @schema.visibility_profile_class.new(name: visibility_profile, context: profile_ctx, schema: @schema, visibility: self)
           elsif @dynamic
             if context.is_a?(Query::NullContext)
               top_level_profile
             else
-              @schema.visibility_profile_class.new(context: context, schema: @schema)
+              @schema.visibility_profile_class.new(context: context, schema: @schema, visibility: self)
             end
           elsif !context.key?(:visibility_profile)
             raise ArgumentError, "#{@schema} expects a visibility profile, but `visibility_profile:` wasn't passed. Provide a `visibility_profile:` value or add `dynamic: true` to your visibility configuration."
@@ -168,7 +178,7 @@ module GraphQL
         elsif context.is_a?(Query::NullContext)
           top_level_profile
         else
-          @schema.visibility_profile_class.new(context: context, schema: @schema)
+          @schema.visibility_profile_class.new(context: context, schema: @schema, visibility: self)
         end
       end
 
@@ -181,7 +191,7 @@ module GraphQL
         if refresh
           @top_level_profile = nil
         end
-        @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema)
+        @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema, visibility: self)
       end
 
       private
@@ -202,7 +212,11 @@ module GraphQL
       def load_all(types: nil)
         if @visit.nil?
           # Set up the visit system
-          @interface_type_memberships = Hash.new { |h, interface_type| h[interface_type] = [] }.compare_by_identity
+          @interface_type_memberships = Hash.new { |h, interface_type|
+            h[interface_type] = Hash.new { |h2, obj_type|
+              h2[obj_type] = []
+            }.compare_by_identity
+          }.compare_by_identity
           @directives = []
           @types = {} # String => Module
           @all_references = Hash.new { |h, member| h[member] = Set.new.compare_by_identity }.compare_by_identity
@@ -227,7 +241,7 @@ module GraphQL
                   @all_references[itm.abstract_type] << member
                   # `itm.object_type` may not actually be `member` if this implementation
                   # is inherited from a superclass
-                  @interface_type_memberships[itm.abstract_type] << [itm, member]
+                  @interface_type_memberships[itm.abstract_type][member] << itm
                 end
               elsif member < GraphQL::Schema::Union
                 @unions_for_references << member
@@ -276,12 +290,11 @@ module GraphQL
 
         # TODO: somehow don't iterate over all these,
         # only the ones that may have been modified
-        @interface_type_memberships.each do |int_type, type_membership_pairs|
-          referers = @all_references[int_type].select { |r| r.is_a?(GraphQL::Schema::Field) }
-          if !referers.empty?
-            type_membership_pairs.each do |(type_membership, impl_type)|
-              # Add new items only:
-              @all_references[impl_type] |= referers
+        @interface_type_memberships.each do |int_type, obj_type_memberships|
+          referrers = @all_references[int_type].select { |r| r.is_a?(GraphQL::Schema::Field) }
+          if !referrers.empty?
+            obj_type_memberships.each_key do |impl_type|
+              @all_references[impl_type] |= referrers
             end
           end
         end

data/lib/graphql/schema.rb

@@ -7,6 +7,7 @@ require "graphql/schema/find_inherited_value"
 require "graphql/schema/finder"
 require "graphql/schema/introspection_system"
 require "graphql/schema/late_bound_type"
+require "graphql/schema/ractor_shareable"
 require "graphql/schema/timeout"
 require "graphql/schema/type_expression"
 require "graphql/schema/unique_within_type"
@@ -148,10 +149,12 @@ module GraphQL
       end
 
       # @param new_mode [Symbol] If configured, this will be used when `context: { trace_mode: ... }` isn't set.
-      def default_trace_mode(new_mode = nil)
-        if new_mode
+      def default_trace_mode(new_mode = NOT_CONFIGURED)
+        if !NOT_CONFIGURED.equal?(new_mode)
           @default_trace_mode = new_mode
-        elsif defined?(@default_trace_mode)
+        elsif defined?(@default_trace_mode) &&
+            !@default_trace_mode.nil? # This `nil?` check seems necessary because of
+                                      # Ractors silently initializing @default_trace_mode somehow
           @default_trace_mode
         elsif superclass.respond_to?(:default_trace_mode)
           superclass.default_trace_mode
@@ -365,7 +368,8 @@ module GraphQL
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
       def get_type(type_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
-          return Visibility::Profile.from_context(context, self).type(type_name)
+          profile = Visibility::Profile.from_context(context, self)
+          return profile.type(type_name)
         end
         local_entry = own_types[type_name]
         type_defn = case local_entry
@@ -697,7 +701,21 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(context.query.types, ast_node)
       end
 
-      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+        if use_visibility_profile
+          profile = Visibility::Profile.from_context(context, self)
+          parent_type = case type_or_name
+          when String
+            profile.type(type_or_name)
+          when Module
+            type_or_name
+          when LateBoundType
+            profile.type(type_or_name.name)
+          else
+            raise GraphQL::InvariantError, "Unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
+          end
+          return profile.field(parent_type, field_name)
+        end
         parent_type = case type_or_name
         when LateBoundType
           get_type(type_or_name.name, context)
@@ -1105,20 +1123,21 @@ module GraphQL
         end
       end
 
-      NEW_HANDLER_HASH = ->(h, k) {
-        h[k] = {
-          class: k,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-         }
-      }
-
       def error_handlers
-        @error_handlers ||= {
-          class: nil,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-        }
+        @error_handlers ||= begin
+          new_handler_hash = ->(h, k) {
+            h[k] = {
+              class: k,
+              handler: nil,
+              subclass_handlers: Hash.new(&new_handler_hash),
+            }
+          }
+          {
+            class: nil,
+            handler: nil,
+            subclass_handlers: Hash.new(&new_handler_hash),
+          }
+        end
       end
 
       # @api private
@@ -1695,7 +1714,11 @@ module GraphQL
       # @return [true, false, nil]
       def allow_legacy_invalid_empty_selections_on_union(new_value = NOT_CONFIGURED)
         if NOT_CONFIGURED.equal?(new_value)
-          @allow_legacy_invalid_empty_selections_on_union
+          if defined?(@allow_legacy_invalid_empty_selections_on_union)
+            @allow_legacy_invalid_empty_selections_on_union
+          else
+            find_inherited_value(:allow_legacy_invalid_empty_selections_on_union)
+          end
         else
           @allow_legacy_invalid_empty_selections_on_union = new_value
         end
@@ -1726,7 +1749,11 @@ module GraphQL
       # @return [true, false, nil]
       def allow_legacy_invalid_return_type_conflicts(new_value = NOT_CONFIGURED)
         if NOT_CONFIGURED.equal?(new_value)
-          @allow_legacy_invalid_return_type_conflicts
+          if defined?(@allow_legacy_invalid_return_type_conflicts)
+            @allow_legacy_invalid_return_type_conflicts
+          else
+            find_inherited_value(:allow_legacy_invalid_return_type_conflicts)
+          end
         else
           @allow_legacy_invalid_return_type_conflicts = new_value
         end
@@ -1774,7 +1801,11 @@ module GraphQL
       #   complexity_cost_calculation_mode(:compare)
       def complexity_cost_calculation_mode(new_mode = NOT_CONFIGURED)
         if NOT_CONFIGURED.equal?(new_mode)
-          @complexity_cost_calculation_mode
+          if defined?(@complexity_cost_calculation_mode)
+            @complexity_cost_calculation_mode
+          else
+            find_inherited_value(:complexity_cost_calculation_mode)
+          end
         else
           @complexity_cost_calculation_mode = new_mode
         end

data/lib/graphql/static_validation/all_rules.rb

@@ -37,6 +37,6 @@ module GraphQL
       GraphQL::StaticValidation::SubscriptionRootExistsAndSingleSubscriptionSelection,
       GraphQL::StaticValidation::InputObjectNamesAreUnique,
       GraphQL::StaticValidation::OneOfInputObjectsAreValid,
-    ]
+    ].freeze
   end
 end

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

@@ -19,13 +19,17 @@ module GraphQL
         :on_field,
       ]
 
-      DIRECTIVE_NODE_HOOKS.each do |method_name|
-        define_method(method_name) do |node, parent|
+      VALIDATE_DIRECTIVE_LOCATION_ON_NODE = <<~RUBY
+        def %{method_name}(node, parent)
           if !node.directives.empty?
             validate_directive_location(node)
           end
           super(node, parent)
         end
+      RUBY
+      DIRECTIVE_NODE_HOOKS.each do |method_name|
+        # Can't use `define_method {...}` here  because the proc can't be isolated for use in non-main Ractors
+        module_eval(VALIDATE_DIRECTIVE_LOCATION_ON_NODE % { method_name: method_name }) # rubocop:disable Development/NoEvalCop
       end
 
       private

data/lib/graphql/tracing/null_trace.rb

@@ -4,6 +4,6 @@ require "graphql/tracing/trace"
 
 module GraphQL
   module Tracing
-    NullTrace = Trace.new
+    NullTrace = Trace.new.freeze
   end
 end

data/lib/graphql/type_kinds.rb

@@ -14,6 +14,7 @@ module GraphQL
         @leaf = leaf
         @composite = fields? || abstract?
         @description = description
+        freeze
       end
 
       # Does this TypeKind have multiple possible implementers?

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -72,7 +72,7 @@ This is probably a bug in GraphQL-Ruby, please report this error on GitHub: http
     GraphQL::Language::Lexer.tokenize(graphql_string)
   end
 
-  NOT_CONFIGURED = Object.new
+  NOT_CONFIGURED = Object.new.freeze
   private_constant :NOT_CONFIGURED
   module EmptyObjects
     EMPTY_HASH = {}.freeze

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.9
+  version: 2.5.10
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-06-06 00:00:00.000000000 Z
+date: 2025-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -622,6 +622,7 @@ files:
 - lib/graphql/schema/non_null.rb
 - lib/graphql/schema/object.rb
 - lib/graphql/schema/printer.rb
+- lib/graphql/schema/ractor_shareable.rb
 - lib/graphql/schema/relay_classic_mutation.rb
 - lib/graphql/schema/resolver.rb
 - lib/graphql/schema/resolver/has_payload_type.rb