graphql 2.4.3 → 2.4.13

data/lib/graphql/schema/visibility.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/schema/visibility/profile"
 require "graphql/schema/visibility/migration"
+require "graphql/schema/visibility/visit"
 
 module GraphQL
   class Schema
@@ -12,41 +13,80 @@ module GraphQL
       # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
       # @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) ? Rails.env.production? : nil), migration_errors: false)
+        profiles&.each { |name, ctx|
+          ctx[:visibility_profile] = name
+          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:)
         @schema = schema
         schema.use_visibility_profile = true
-        if migration_errors
-          schema.visibility_profile_class = Migration
+        schema.visibility_profile_class = if migration_errors
+          Visibility::Migration
+        else
+          Visibility::Profile
         end
         @preload = preload
         @profiles = profiles
         @cached_profiles = {}
         @dynamic = dynamic
         @migration_errors = migration_errors
-        if preload
-          # Traverse the schema now (and in the *_configured hooks below)
-          # To make sure things are loaded during boot
-          @preloaded_types = Set.new
-          types_to_visit = [
-            @schema.query,
-            @schema.mutation,
-            @schema.subscription,
-            *@schema.introspection_system.types.values,
-            *@schema.introspection_system.entry_points.map { |ep| ep.type.unwrap },
-            *@schema.orphan_types,
-          ]
-          # Root types may have been nil:
-          types_to_visit.compact!
-          ensure_all_loaded(types_to_visit)
-
-          profiles.each do |profile_name, example_ctx|
-            example_ctx[:visibility_profile] = profile_name
-            prof = profile_for(example_ctx, profile_name)
-            prof.all_types # force loading
-          end
+        # Top-level type caches:
+        @visit = nil
+        @interface_type_memberships = nil
+        @directives = nil
+        @types = nil
+        @all_references = nil
+        @loaded_all = false
+      end
+
+      def all_directives
+        load_all
+        @directives
+      end
+
+      def all_interface_type_memberships
+        load_all
+        @interface_type_memberships
+      end
+
+      def all_references
+        load_all
+        @all_references
+      end
+
+      def get_type(type_name)
+        load_all
+        @types[type_name]
+      end
+
+      def preload?
+        @preload
+      end
+
+      def preload
+        # Traverse the schema now (and in the *_configured hooks below)
+        # To make sure things are loaded during boot
+        @preloaded_types = Set.new
+        types_to_visit = [
+          @schema.query,
+          @schema.mutation,
+          @schema.subscription,
+          *@schema.introspection_system.types.values,
+          *@schema.introspection_system.entry_points.map { |ep| ep.type.unwrap },
+          *@schema.orphan_types,
+        ]
+        # Root types may have been nil:
+        types_to_visit.compact!
+        ensure_all_loaded(types_to_visit)
+        @profiles.each do |profile_name, example_ctx|
+          prof = profile_for(example_ctx)
+          prof.all_types # force loading
         end
       end
 
@@ -108,8 +148,8 @@ module GraphQL
 
       attr_reader :cached_profiles
 
-      def profile_for(context, visibility_profile)
-        if @profiles.any?
+      def profile_for(context, visibility_profile = context[:visibility_profile])
+        if !@profiles.empty?
           if visibility_profile.nil?
             if @dynamic
               if context.is_a?(Query::NullContext)
@@ -117,13 +157,14 @@ module GraphQL
               else
                 @schema.visibility_profile_class.new(context: context, schema: @schema)
               end
-            elsif @profiles.any?
+            elsif !@profiles.empty?
               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."
             end
           elsif !@profiles.include?(visibility_profile)
             raise ArgumentError, "`#{visibility_profile.inspect}` isn't allowed for `visibility_profile:` (must be one of #{@profiles.keys.map(&:inspect).join(", ")}). Or, add `#{visibility_profile.inspect}` to the list of profiles in the schema definition."
           else
-            @cached_profiles[visibility_profile] ||= @schema.visibility_profile_class.new(name: visibility_profile, context: context, schema: @schema)
+            profile_ctx = @profiles[visibility_profile]
+            @cached_profiles[visibility_profile] ||= @schema.visibility_profile_class.new(name: visibility_profile, context: profile_ctx, schema: @schema)
           end
         elsif context.is_a?(Query::NullContext)
           top_level_profile
@@ -132,7 +173,10 @@ module GraphQL
         end
       end
 
-      private
+      attr_reader :top_level
+
+      # @api private
+      attr_reader :unfiltered_interface_type_memberships
 
       def top_level_profile(refresh: false)
         if refresh
@@ -141,6 +185,8 @@ module GraphQL
         @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema)
       end
 
+      private
+
       def ensure_all_loaded(types_to_visit)
         while (type = types_to_visit.shift)
           if type.kind.fields? && @preloaded_types.add?(type)
@@ -153,6 +199,101 @@ module GraphQL
         top_level_profile(refresh: true)
         nil
       end
+
+      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
+          @directives = []
+          @types = {} # String => Module
+          @all_references = Hash.new { |h, member| h[member] = Set.new.compare_by_identity }.compare_by_identity
+          @unions_for_references = Set.new
+          @visit = Visibility::Visit.new(@schema) do |member|
+            if member.is_a?(Module)
+              type_name = member.graphql_name
+              if (prev_t = @types[type_name])
+                if prev_t.is_a?(Array)
+                  prev_t << member
+                else
+                  @types[type_name] = [member, prev_t]
+                end
+              else
+                @types[member.graphql_name] = member
+              end
+              member.directives.each { |dir| @all_references[dir.class] << member }
+              if member < GraphQL::Schema::Directive
+                @directives << member
+              elsif member.respond_to?(:interface_type_memberships)
+                member.interface_type_memberships.each do |itm|
+                  @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]
+                end
+              elsif member < GraphQL::Schema::Union
+                @unions_for_references << member
+              end
+            elsif member.is_a?(GraphQL::Schema::Argument)
+              member.validate_default_value
+              @all_references[member.type.unwrap] << member
+              if !(dirs = member.directives).empty?
+                dir_owner = member.owner
+                if dir_owner.respond_to?(:owner)
+                  dir_owner = dir_owner.owner
+                end
+                dirs.each { |dir| @all_references[dir.class] << dir_owner }
+              end
+            elsif member.is_a?(GraphQL::Schema::Field)
+              @all_references[member.type.unwrap] << member
+              if !(dirs = member.directives).empty?
+                dir_owner = member.owner
+                dirs.each { |dir| @all_references[dir.class] << dir_owner }
+              end
+            elsif member.is_a?(GraphQL::Schema::EnumValue)
+              if !(dirs = member.directives).empty?
+                dir_owner = member.owner
+                dirs.each { |dir| @all_references[dir.class] << dir_owner }
+              end
+            end
+            true
+          end
+
+          @schema.root_types.each { |t| @all_references[t] << true }
+          @schema.introspection_system.types.each_value { |t| @all_references[t] << true }
+          @schema.directives.each_value { |dir_class| @all_references[dir_class] << true }
+
+          @visit.visit_each(types: []) # visit default directives
+        end
+
+        if types
+          @visit.visit_each(types: types, directives: [])
+        elsif @loaded_all == false
+          @loaded_all = true
+          @visit.visit_each
+        else
+          # already loaded all
+          return
+        end
+
+        # 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
+            end
+          end
+        end
+
+        @unions_for_references.each do |union_type|
+          refs = @all_references[union_type]
+          union_type.all_possible_types.each do |object_type|
+            @all_references[object_type] |= refs # Add new items
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/warden.rb

@@ -72,6 +72,7 @@ module GraphQL
           def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
           def arguments(owner, ctx); owner.arguments(ctx); end
           def loadable?(type, ctx); type.visible?(ctx); end
+          def loadable_possible_types(type, ctx); type.possible_types(ctx); end
           def visibility_profile
             @visibility_profile ||= Warden::VisibilityProfile.new(self)
           end
@@ -106,6 +107,7 @@ module GraphQL
         def get_field(parent_type, field_name); @schema.get_field(parent_type, field_name); end
         def reachable_type?(type_name); true; end
         def loadable?(type, _ctx); true; end
+        def loadable_possible_types(union_type, _ctx); union_type.possible_types; end
         def reachable_types; @schema.types.values; end # rubocop:disable Development/ContextIsPassedCop
         def possible_types(type_defn); @schema.possible_types(type_defn, Query::NullContext.instance, false); end
         def interfaces(obj_type); obj_type.interfaces; end
@@ -180,6 +182,10 @@ module GraphQL
           @warden.loadable?(t, ctx)
         end
 
+        def loadable_possible_types(t, ctx)
+          @warden.loadable_possible_types(t, ctx)
+        end
+
         def reachable_type?(type_name)
           !!@warden.reachable_type?(type_name)
         end
@@ -204,7 +210,7 @@ module GraphQL
           @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =
           @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
           @visible_and_reachable_type = @unions = @unfiltered_interfaces =
-          @reachable_type_set = @visibility_profile =
+          @reachable_type_set = @visibility_profile = @loadable_possible_types =
             nil
         @skip_warning = schema.plugins.any? { |(plugin, _opts)| plugin == GraphQL::Schema::Warden }
       end
@@ -229,6 +235,13 @@ module GraphQL
         !reachable_type_set.include?(type) && visible_type?(type)
       end
 
+      def loadable_possible_types(union_type, _ctx)
+        @loadable_possible_types ||= read_through do |t|
+          t.possible_types # unfiltered
+        end
+        @loadable_possible_types[union_type]
+      end
+
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
       def get_type(type_name)
         @visible_types ||= read_through do |name|
@@ -297,7 +310,7 @@ module GraphQL
       def arguments(argument_owner, ctx = nil)
         @visible_arguments ||= read_through { |o|
           args = o.arguments(@context)
-          if args.any?
+          if !args.empty?
             args = args.values
             args.select! { |a| visible_argument?(a, @context) }
             args
@@ -329,7 +342,7 @@ module GraphQL
       def interfaces(obj_type)
         @visible_interfaces ||= read_through { |t|
           ints = t.interfaces(@context)
-          if ints.any?
+          if !ints.empty?
             ints.select! { |i| visible_type?(i) }
           end
           ints
@@ -389,9 +402,9 @@ module GraphQL
           next true if root_type?(type_defn) || type_defn.introspection?
 
           if type_defn.kind.union?
-            possible_types(type_defn).any? && (referenced?(type_defn) || orphan_type?(type_defn))
+            !possible_types(type_defn).empty? && (referenced?(type_defn) || orphan_type?(type_defn))
           elsif type_defn.kind.interface?
-            if possible_types(type_defn).any?
+            if !possible_types(type_defn).empty?
               true
             else
               if @context.respond_to?(:logger) && (logger = @context.logger)

data/lib/graphql/schema.rb

@@ -7,7 +7,6 @@ require "graphql/schema/find_inherited_value"
 require "graphql/schema/finder"
 require "graphql/schema/introspection_system"
 require "graphql/schema/late_bound_type"
-require "graphql/schema/null_mask"
 require "graphql/schema/timeout"
 require "graphql/schema/type_expression"
 require "graphql/schema/unique_within_type"
@@ -73,6 +72,9 @@ module GraphQL
   class Schema
     extend GraphQL::Schema::Member::HasAstNode
     extend GraphQL::Schema::FindInheritedValue
+    extend Autoload
+
+    autoload :BUILT_IN_TYPES, "graphql/schema/built_in_types"
 
     class DuplicateNamesError < GraphQL::Error
       attr_reader :duplicated_name
@@ -164,9 +166,6 @@ module GraphQL
           mods.each { |mod| new_class.include(mod) }
           new_class.include(DefaultTraceClass)
           trace_mode(:default, new_class)
-          backtrace_class = Class.new(new_class)
-          backtrace_class.include(GraphQL::Backtrace::Trace)
-          trace_mode(:default_backtrace, backtrace_class)
         end
         trace_class_for(:default, build: true)
       end
@@ -213,11 +212,6 @@ module GraphQL
           const_set(:DefaultTrace, Class.new(base_class) do
             include DefaultTraceClass
           end)
-        when :default_backtrace
-          schema_base_class = trace_class_for(:default, build: true)
-          const_set(:DefaultTraceBacktrace, Class.new(schema_base_class) do
-            include(GraphQL::Backtrace::Trace)
-          end)
         else
           # First, see if the superclass has a custom-defined class for this.
           # Then, if it doesn't, use this class's default trace
@@ -233,7 +227,7 @@ module GraphQL
           add_trace_options_for(mode, default_options)
 
           Class.new(base_class) do
-            mods.any? && include(*mods)
+            !mods.empty? && include(*mods)
           end
         end
       end
@@ -321,7 +315,7 @@ module GraphQL
       # @param plugin [#use] A Schema plugin
       # @return void
       def use(plugin, **kwargs)
-        if kwargs.any?
+        if !kwargs.empty?
           plugin.use(self, **kwargs)
         else
           plugin.use(self)
@@ -446,7 +440,12 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `query(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@query_object.inspect}"
           elsif use_visibility_profile?
             if block_given?
-              @query_object = lazy_load_block
+              if visibility.preload?
+                @query_object = lazy_load_block.call
+                self.visibility.query_configured(@query_object)
+              else
+                @query_object = lazy_load_block
+              end
             else
               @query_object = new_query_object
               self.visibility.query_configured(@query_object)
@@ -480,7 +479,12 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `mutation(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
           elsif use_visibility_profile?
             if block_given?
-              @mutation_object = lazy_load_block
+              if visibility.preload?
+                @mutation_object = lazy_load_block.call
+                self.visibility.mutation_configured(@mutation_object)
+              else
+                @mutation_object = lazy_load_block
+              end
             else
               @mutation_object = new_mutation_object
               self.visibility.mutation_configured(@mutation_object)
@@ -514,7 +518,12 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `subscription(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
           elsif use_visibility_profile?
             if block_given?
-              @subscription_object = lazy_load_block
+              if visibility.preload?
+                @subscription_object = lazy_load_block.call
+                visibility.subscription_configured(@subscription_object)
+              else
+                @subscription_object = lazy_load_block
+              end
             else
               @subscription_object = new_subscription_object
               self.visibility.subscription_configured(@subscription_object)
@@ -676,7 +685,7 @@ module GraphQL
           # and generally speaking, we won't inherit any values.
           # So optimize the most common case -- don't create a duplicate Hash.
           inherited_value = find_inherited_value(:references_to, EMPTY_HASH)
-          if inherited_value.any?
+          if !inherited_value.empty?
             inherited_value.merge(own_references_to)
           else
             own_references_to
@@ -812,13 +821,13 @@ module GraphQL
 
       attr_writer :validate_timeout
 
-      def validate_timeout(new_validate_timeout = nil)
-        if new_validate_timeout
+      def validate_timeout(new_validate_timeout = NOT_CONFIGURED)
+        if !NOT_CONFIGURED.equal?(new_validate_timeout)
           @validate_timeout = new_validate_timeout
         elsif defined?(@validate_timeout)
           @validate_timeout
         else
-          find_inherited_value(:validate_timeout)
+          find_inherited_value(:validate_timeout) || 3
         end
       end
 
@@ -962,7 +971,7 @@ module GraphQL
       # @param new_extra_types [Module] Type definitions to include in printing and introspection, even though they aren't referenced in the schema
       # @return [Array<Module>] Type definitions added to this schema
       def extra_types(*new_extra_types)
-        if new_extra_types.any?
+        if !new_extra_types.empty?
           new_extra_types = new_extra_types.flatten
           @own_extra_types ||= []
           @own_extra_types.concat(new_extra_types)
@@ -987,10 +996,10 @@ module GraphQL
       # @param new_orphan_types [Array<Class<GraphQL::Schema::Object>>] Object types to register as implementations of interfaces in the schema.
       # @return [Array<Class<GraphQL::Schema::Object>>] All previously-registered orphan types for this schema
       def orphan_types(*new_orphan_types)
-        if new_orphan_types.any?
+        if !new_orphan_types.empty?
           new_orphan_types = new_orphan_types.flatten
           non_object_types = new_orphan_types.reject { |ot| ot.is_a?(Class) && ot < GraphQL::Schema::Object }
-          if non_object_types.any?
+          if !non_object_types.empty?
             raise ArgumentError, <<~ERR
               Only object type classes should be added as `orphan_types(...)`.
 
@@ -1007,7 +1016,7 @@ module GraphQL
 
         inherited_ot = find_inherited_value(:orphan_types, nil)
         if inherited_ot
-          if own_orphan_types.any?
+          if !own_orphan_types.empty?
             inherited_ot + own_orphan_types
           else
             inherited_ot
@@ -1100,6 +1109,9 @@ module GraphQL
         }
       end
 
+      # @api private
+      attr_accessor :using_backtrace
+
       # @api private
       def handle_or_reraise(context, err)
         handler = Execution::Errors.find_handler_for(self, err.class)
@@ -1113,6 +1125,10 @@ module GraphQL
           end
           handler[:handler].call(err, obj, args, context, field)
         else
+          if (context[:backtrace] || using_backtrace) && !err.is_a?(GraphQL::ExecutionError)
+            err = GraphQL::Backtrace::TracedError.new(err, context)
+          end
+
           raise err
         end
       end
@@ -1282,7 +1298,10 @@ module GraphQL
       def type_error(type_error, ctx)
         case type_error
         when GraphQL::InvalidNullError
-          ctx.errors << type_error
+          execution_error = GraphQL::ExecutionError.new(type_error.message, ast_node: type_error.ast_node)
+          execution_error.path = ctx[:current_path]
+
+          ctx.errors << execution_error
         when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
         when GraphQL::IntegerDecodingError
@@ -1317,12 +1336,12 @@ module GraphQL
       # Add several directives at once
       # @param new_directives [Class]
       def directives(*new_directives)
-        if new_directives.any?
+        if !new_directives.empty?
           new_directives.flatten.each { |d| directive(d) }
         end
 
         inherited_dirs = find_inherited_value(:directives, default_directives)
-        if own_directives.any?
+        if !own_directives.empty?
           inherited_dirs.merge(own_directives)
         else
           inherited_dirs
@@ -1350,6 +1369,16 @@ module GraphQL
         }.freeze
       end
 
+      # @return [GraphQL::Tracing::DetailedTrace] if it has been configured for this schema
+      attr_accessor :detailed_trace
+
+      # @param query [GraphQL::Query, GraphQL::Execution::Multiplex] Called with a multiplex when multiple queries are executed at once (with {.multiplex})
+      # @return [Boolean] When `true`, save a detailed trace for this query.
+      # @see Tracing::DetailedTrace DetailedTrace saves traces when this method returns true
+      def detailed_trace?(query)
+        raise "#{self} must implement `def.detailed_trace?(query)` to use DetailedTrace. Implement this method in your schema definition."
+      end
+
       def tracer(new_tracer, silence_deprecation_warning: false)
         if !silence_deprecation_warning
           warn("`Schema.tracer(#{new_tracer.inspect})` is deprecated; use module-based `trace_with` instead. See: https://graphql-ruby.org/queries/tracing.html")
@@ -1367,14 +1396,22 @@ module GraphQL
         find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
       end
 
-      # Mix `trace_mod` into this schema's `Trace` class so that its methods
-      # will be called at runtime.
+      # Mix `trace_mod` into this schema's `Trace` class so that its methods will be called at runtime.
+      #
+      # You can attach a module to run in only _some_ circumstances by using `mode:`. When a module is added with `mode:`,
+      # it will only run for queries with a matching `context[:trace_mode]`.
+      #
+      # Any custom trace modes _also_ include the default `trace_with ...` modules (that is, those added _without_ any particular `mode: ...` configuration).
+      #
+      # @example Adding a trace in a special mode
+      #   # only runs when `query.context[:trace_mode]` is `:special`
+      #   trace_with SpecialTrace, mode: :special
       #
       # @param trace_mod [Module] A module that implements tracing methods
       # @param mode [Symbol] Trace module will only be used for this trade mode
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [void]
-      # @see GraphQL::Tracing::Trace for available tracing methods
+      # @see GraphQL::Tracing::Trace Tracing::Trace for available tracing methods
       def trace_with(trace_mod, mode: :default, **options)
         if mode.is_a?(Array)
           mode.each { |m| trace_with(trace_mod, mode: m, **options) }
@@ -1424,29 +1461,36 @@ module GraphQL
       #
       # If no `mode:` is given, then {default_trace_mode} will be used.
       #
+      # If this schema is using {Tracing::DetailedTrace} and {.detailed_trace?} returns `true`, then
+      # DetailedTrace's mode will override the passed-in `mode`.
+      #
       # @param mode [Symbol] Trace modules for this trade mode will be included
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [Tracing::Trace]
       def new_trace(mode: nil, **options)
-        target = options[:query] || options[:multiplex]
-        mode ||= target && target.context[:trace_mode]
-
-        trace_mode = if mode
-          mode
-        elsif target && target.context[:backtrace]
-          if default_trace_mode != :default
-            raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
-          else
-            own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
-            options_trace_mode = :default
-            :default_backtrace
+        should_sample = if detailed_trace
+          if (query = options[:query])
+            detailed_trace?(query)
+          elsif (multiplex = options[:multiplex])
+            if multiplex.queries.length == 1
+              detailed_trace?(multiplex.queries.first)
+            else
+              detailed_trace?(multiplex)
+            end
           end
         else
-          default_trace_mode
+          false
+        end
+
+        if should_sample
+          mode = detailed_trace.trace_mode
+        else
+          target = options[:query] || options[:multiplex]
+          mode ||= target && target.context[:trace_mode]
         end
 
-        options_trace_mode ||= trace_mode
-        base_trace_options = trace_options_for(options_trace_mode)
+        trace_mode = mode || default_trace_mode
+        base_trace_options = trace_options_for(trace_mode)
         trace_options = base_trace_options.merge(options)
         trace_class_for_mode = trace_class_for(trace_mode, build: true)
         trace_class_for_mode.new(**trace_options)
@@ -1787,3 +1831,6 @@ module GraphQL
     end
   end
 end
+
+require "graphql/schema/loader"
+require "graphql/schema/printer"

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

@@ -16,7 +16,7 @@ module GraphQL
 
       def validate_arguments(node)
         argument_defns = node.arguments
-        if argument_defns.any?
+        if !argument_defns.empty?
           args_by_name = Hash.new { |h, k| h[k] = [] }
           argument_defns.each { |a| args_by_name[a.name] << a }
           args_by_name.each do |name, defns|

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

@@ -25,7 +25,7 @@ module GraphQL
       def validate_field_selections(ast_node, resolved_type)
         msg = if resolved_type.nil?
           nil
-        elsif ast_node.selections.any? && resolved_type.kind.leaf?
+        elsif !ast_node.selections.empty? && resolved_type.kind.leaf?
           selection_strs = ast_node.selections.map do |n|
             case n
             when GraphQL::Language::Nodes::InlineFragment

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

@@ -345,7 +345,7 @@ module GraphQL
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? @types.type(node.type.name) : owner_type
-            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
+            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: fragment_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
           end

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

@@ -32,7 +32,7 @@ module GraphQL
 
       def on_document(node, parent)
         super
-        if @schema_definition_nodes.any?
+        if !@schema_definition_nodes.empty?
           add_error(GraphQL::StaticValidation::NoDefinitionsArePresentError.new(%|Query cannot contain schema definitions|, nodes: @schema_definition_nodes))
         end
       end