graphql 2.6.2 → 2.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0c0b5ff2af84e07dab381443b1b62137074324bb3063c8387bf6dc777d51d00
-  data.tar.gz: 4e5383e45c9d62ea5a04782867a743d01d6db0d0bc853deadc7a229f26d440e4
+  metadata.gz: 16abc9c2a5eda0da251dbe7e14433241bc7d038d2527926832ceb29336fb857a
+  data.tar.gz: c89bd2a4b340ca30bfa7b823f51e4671972355d54bd56fdaed598c13a415c3b3
 SHA512:
-  metadata.gz: 86019205d2eb2dabd464dc615af28ab078c1a48e43c0701a1852dddfd13eded8954e42e91b7176c685eed10679b15bf4bcef2c86c48d9f9ad4b870cdc78bb19a
-  data.tar.gz: b95880ff00058b167fe7574ca5e267814fe7aa9be65df0d2691d658344a796dd1fdafedad6cc35b58c3299c5401b39a964353cb5ab0e3974296ca4c26f9ab504
+  metadata.gz: 6452d2a517c502b4a8934582d060885a5f6462de244a1f331433f1076dc57a879cdd081e147f70925064a99607e0794fcf6eadad7a3f4a9111a5ab979c552554
+  data.tar.gz: b6a0219606d905fc885ab2192596d1acb1d92bce407defc751bfafb1a7199e9c32275c1d3202f3246251e72b80554698b1f54920f76178f1ddc81b41d628bacd

data/lib/graphql/analysis/query_complexity.rb

@@ -9,6 +9,8 @@ module GraphQL
         super
         @skip_introspection_fields = !query.schema.max_complexity_count_introspection_fields
         @complexities_on_type_by_query = {}
+        @intersect_cache = Hash.new { |h, k| h[k] = {}.compare_by_identity }.compare_by_identity
+        @possible_types_cache = {}.compare_by_identity
       end
 
       # Override this method to use the complexity result
@@ -159,8 +161,22 @@ module GraphQL
 
       def types_intersect?(query, a, b)
         return true if a == b
-        a_types = query.types.possible_types(a)
-        query.types.possible_types(b).any? { |t| a_types.include?(t) }
+
+        if a.object_id < b.object_id
+          first_cache = @intersect_cache[a]
+          second_key = b
+        else
+          first_cache = @intersect_cache[b]
+          second_key = a
+        end
+
+        if first_cache.key?(second_key)
+          first_cache[second_key]
+        else
+          a_types = @possible_types_cache[a] ||= query.types.possible_types(a).to_set
+          b_types = @possible_types_cache[b] ||= query.types.possible_types(b).to_set
+          first_cache[second_key] = a_types.intersect?(b_types)
+        end
       end
 
       # A hook which is called whenever a field's max complexity is calculated.
@@ -175,18 +191,16 @@ module GraphQL
       # @param inner_selections [Array<Hash<String, ScopedTypeComplexity>>] Field selections for a scope
       # @return [Integer] Total complexity value for all these selections in the parent scope
       def merged_max_complexity(query, inner_selections)
-        # Aggregate a set of all unique field selection keys across all scopes.
-        # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-        unique_field_keys = inner_selections.each_with_object({}) do |inner_selection, memo|
-          memo.merge!(inner_selection)
+        child_scopes_by_key = {}
+        inner_selections.each do |inner_selection|
+          inner_selection.each do |k, v|
+            scopes = child_scopes_by_key[k] ||= []
+            scopes << v
+          end
         end
-
         # Add up the total cost for each unique field name's coalesced selections
-        unique_field_keys.each_key.reduce(0) do |total, field_key|
-          # Collect all child scopes for this field key;
-          # all keys come with at least one scope.
-          child_scopes = inner_selections.filter_map { _1[field_key] }
-
+        total = 0
+        child_scopes_by_key.each do |field_key, child_scopes|
           # Compute maximum possible cost of child selections;
           # composites merge their maximums, while leaf scopes are always zero.
           # FieldsWillMerge validation assures all scopes are uniformly composite or leaf.
@@ -214,8 +228,10 @@ module GraphQL
             child_complexity: maximum_children_cost,
           )
 
-          total + maximum_cost
+          total += maximum_cost
         end
+
+        total
       end
 
       def legacy_merged_max_complexity(query, inner_selections)

data/lib/graphql/backtrace/table.rb

@@ -90,7 +90,16 @@ module GraphQL
 
           if ast_node
             field_defn = query.get_field(result.graphql_result_type, ast_node.name)
-            args = query.arguments_for(ast_node, field_defn).to_h
+            args = begin
+              if (cached_args = query.arguments_cache.cached_arguments_for(ast_node, field_defn))
+                cached_args.to_h
+              else
+                EmptyObjects::EMPTY_HASH
+              end
+            rescue StandardError => err
+              "Failed to load arguments, #{err.class}: #{err.message}"
+            end
+
             field_path = field_defn.path
             if ast_node.alias
               field_path += " as #{ast_node.alias}"

data/lib/graphql/current.rb

@@ -41,7 +41,13 @@ module GraphQL
     # @see GraphQL::Field#path for a string identifying this field
     # @return [GraphQL::Field, nil] The currently-running field, if there is one.
     def self.field
-      Fiber[:__graphql_runtime_info]&.values&.first&.current_field
+      if (interpreter_info = Fiber[:__graphql_runtime_info])
+        interpreter_info.values&.first&.current_field
+      elsif (field = Fiber[:__graphql_current_field])
+        field
+      else
+        nil
+      end
     end
 
     # @return [Class, nil] The currently-running {Dataloader::Source} class, if there is one.

data/lib/graphql/execution/directive_checks.rb

@@ -18,11 +18,13 @@ module GraphQL
           case name
           when SKIP
             args = query.arguments_for(directive_ast_node, directive_defn)
+            next if args.is_a?(GraphQL::ExecutionError)
             if args[:if] == true
               return false
             end
           when INCLUDE
             args = query.arguments_for(directive_ast_node, directive_defn)
+            next if args.is_a?(GraphQL::ExecutionError)
             if args[:if] == false
               return false
             end

data/lib/graphql/execution/field_resolve_step.rb

@@ -50,11 +50,14 @@ module GraphQL
 
       def value
         query = @selections_step.query
+        set_current_field
         query.current_trace.begin_execute_field(@field_definition, @arguments, @field_results, query)
         sync(@field_results)
         query.current_trace.end_execute_field(@field_definition, @arguments, @field_results, query, @field_results)
         @runner.add_step(self)
         true
+      ensure
+        set_current_field(nil)
       end
 
       def sync(lazy)
@@ -76,6 +79,7 @@ module GraphQL
       end
 
       def call
+        set_current_field if @field_definition
         if @enqueued_authorization
           enqueue_next_steps
         elsif @finish_extension_idx
@@ -94,6 +98,8 @@ module GraphQL
         else
           raise
         end
+      ensure
+        set_current_field(nil)
       end
 
       def add_graphql_error(err)
@@ -121,6 +127,7 @@ module GraphQL
         query = @selections_step.query
         field_name = @ast_node.name
         @field_definition = query.types.field(@parent_type, field_name) || raise(GraphQL::Error, "No field definition found for #{@parent_type.to_type_signature}.#{ast_node.name} (at #{@ast_node.position})")
+        set_current_field
         @arguments, errors = @runner.input_values[query].argument_values(@field_definition, @ast_node.arguments, self) # rubocop:disable Development/ContextIsPassedCop
         if errors
           build_errors_result(errors, nil)
@@ -131,6 +138,8 @@ module GraphQL
             @field_results.nil? # Make sure the arguments flow didn't already call through
           execute_field
         end
+      ensure
+        set_current_field(nil)
       end
 
       # Used for compatibility in Schema::Subscription
@@ -552,6 +561,10 @@ module GraphQL
         @runner.schema.type_error(err, @selections_step.query.context)
       end
 
+      def set_current_field(new_value = @field_definition)
+        Fiber[:__graphql_current_field] = new_value
+      end
+
       private
 
       def build_graphql_result(graphql_result, key, field_result, return_type, is_nn, is_list, is_from_array) # rubocop:disable Metrics/ParameterLists

data/lib/graphql/execution/finalize.rb

@@ -117,7 +117,7 @@ module GraphQL
               @current_exec_path << key
               @current_result_path << key
 
-              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{static_type.to_type_signature}.#{ast_selection.name}")
+              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{parent_type.to_type_signature}.#{ast_selection.name}")
               result_type = field_defn.type
               if (result_type_non_null = result_type.non_null?)
                 result_type = result_type.of_type
@@ -154,12 +154,14 @@ module GraphQL
                 @runner.type_condition_applies?(@query.context, static_type_at_result, t.name)
               )
               result_h = check_object_result(result_h, parent_type, ast_selection.selections)
+              return nil if result_h.nil?
             end
           when Language::Nodes::FragmentSpread
             fragment_defn = @query.document.definitions.find { |defn| defn.is_a?(Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
             static_type_at_result = @static_type_at[result_h]
             if static_type_at_result && @runner.type_condition_applies?(@query.context, static_type_at_result, fragment_defn.type.name)
               result_h = check_object_result(result_h, parent_type, fragment_defn.selections)
+              return nil if result_h.nil?
             end
           end
         end

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

@@ -30,7 +30,10 @@ module GraphQL
               @storage[argument_owner][parent_object][ast_node] = resolved_args
             end
           end
+        end
 
+        def cached_arguments_for(ast_node, argument_owner)
+          @storage[argument_owner][nil][ast_node]
         end
 
         # @yield [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments

data/lib/graphql/execution/load_argument_step.rb

@@ -14,6 +14,7 @@ module GraphQL
       end
 
       def value
+        @field_resolve_step.set_current_field
         schema = @field_resolve_step.runner.schema
         @loaded_value = schema.sync_lazy(@loaded_value)
         assign_value
@@ -34,9 +35,12 @@ module GraphQL
           @loaded_value = ex_err
         end
         assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       def call
+        @field_resolve_step.set_current_field
         context = @field_resolve_step.selections_step.query.context
         @loaded_value = begin
           @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
@@ -64,6 +68,8 @@ module GraphQL
           ex_err
         end
         assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       private

data/lib/graphql/execution/prepare_object_step.rb

@@ -19,6 +19,7 @@ module GraphQL
       end
 
       def value
+        @field_resolve_step.set_current_field
         if @authorized_value
           query = @field_resolve_step.selections_step.query
           query.current_trace.begin_authorized(@resolved_type, @object, query.context)
@@ -36,9 +37,12 @@ module GraphQL
           ctx.query.current_trace.end_resolve_type(st, @object, ctx, @resolved_type)
         end
         @runner.add_step(self)
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       def call
+        @field_resolve_step.set_current_field
         case @next_step
         when :resolve_type
           static_type = @field_resolve_step.static_type
@@ -65,6 +69,8 @@ module GraphQL
         else
           raise ArgumentError, "This is a bug, unknown step: #{@next_step.inspect}"
         end
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       def authorize

data/lib/graphql/execution/runner.rb

@@ -116,7 +116,7 @@ module GraphQL
             query.context.add_error(err)
           end
 
-          trace.execute_query_lazy(query: nil, multiplex: @multiplex) do
+          trace.execute_query_lazy(query: @multiplex.queries.size == 1 ? @multiplex.queries.first : nil, multiplex: @multiplex) do
             while (next_isolated_steps = isolated_steps.shift)
               next_isolated_steps.each do |step|
                 add_step(step)

data/lib/graphql/language.rb

@@ -47,13 +47,19 @@ module GraphQL
     def self.escape_single_quoted_newlines(query_str)
       scanner = StringScanner.new(query_str)
       inside_single_quoted_string = false
+      inside_triple_quoted_string = false
       new_query_str = nil
       while !scanner.eos?
-        if scanner.skip(/(?:\\"|[^"\n\r]|""")+/m)
+        if scanner.skip('"""')
+          inside_triple_quoted_string = !inside_triple_quoted_string
+          new_query_str && (new_query_str << scanner.matched)
+        elsif scanner.skip(/(?:\\"|[^"\n\r])+/m)
           new_query_str && (new_query_str << scanner.matched)
         elsif scanner.skip('"')
           new_query_str && (new_query_str << '"')
-          inside_single_quoted_string = !inside_single_quoted_string
+          if !inside_triple_quoted_string
+            inside_single_quoted_string = !inside_single_quoted_string
+          end
         elsif scanner.skip("\n")
           if inside_single_quoted_string
             new_query_str ||= query_str[0, scanner.pos - 1]

data/lib/graphql/schema/argument.rb

@@ -94,7 +94,7 @@ module GraphQL
         end
 
         if required == :nullable
-          self.owner.validates(required: { argument: arg_name })
+          self.owner.validates(required: { argument: @keyword })
         end
 
         if definition_block

data/lib/graphql/schema/interface.rb

@@ -101,7 +101,7 @@ module GraphQL
             end
 
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:ResolverMethods)
+              if ancestor != child_class && ancestor <= GraphQL::Schema::Interface && ancestor.const_defined?(:ResolverMethods, false)
                 child_class.extend(ancestor::ResolverMethods)
               end
             end

data/lib/graphql/schema/introspection_system.rb

@@ -105,11 +105,13 @@ module GraphQL
       end
 
       def load_constant(class_name)
-        const = @custom_namespace.const_get(class_name)
+        const = begin
+          @custom_namespace.const_get(class_name)
+        rescue NameError
+          # Dup the built-in so that the cached fields aren't shared
+          @built_in_namespace.const_get(class_name)
+        end
         dup_type_class(const)
-      rescue NameError
-        # Dup the built-in so that the cached fields aren't shared
-        dup_type_class(@built_in_namespace.const_get(class_name))
       end
 
       def get_fields_from_class(class_sym:)
@@ -133,23 +135,6 @@ module GraphQL
           end
         end
       end
-
-      class PerFieldProxyResolve
-        def initialize(object_class:, inner_resolve:)
-          @object_class = object_class
-          @inner_resolve = inner_resolve
-        end
-
-        def call(obj, args, ctx)
-          query_ctx = ctx.query.context
-          # Remove the QueryType wrapper
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
-          end
-          wrapped_object = @object_class.wrap(obj, query_ctx)
-          @inner_resolve.call(wrapped_object, args, ctx)
-        end
-      end
     end
   end
 end

data/lib/graphql/schema/printer.rb

@@ -58,8 +58,8 @@ module GraphQL
           end
         end
         schema = Class.new(GraphQL::Schema) {
-          use GraphQL::Schema::Visibility
           query(query_root)
+          use GraphQL::Schema::Visibility
           def self.visible?(member, _ctx)
             member.graphql_name != "Root"
           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.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

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.2
+  version: 2.6.3
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64