graphql 2.3.7 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13269b31415c3c837e80ec0097b8162c65035119f16860a18012b15e71ace318
-  data.tar.gz: a3d1a936954352bd4ac46aab7f682377f3c219c477db32a65eb414d04655f099
+  metadata.gz: 26e43b0bc48317698ed17f8a11498c19a7a4a0df9d33fdc9785edc47ae1147b6
+  data.tar.gz: 74402e930ebe03a451bc2bdb82285642aeeba7222ab491dd9329400fc852eb41
 SHA512:
-  metadata.gz: 721413cdc90187b7348514ea90d65f25a22a88551c3665dee7ff7f5d986b515f535bb147fedc72fbee4942ac5fdea2f9c1ffb38f5751706a98cecef98e7f94e6
-  data.tar.gz: 4a1b47909ffbc71665ee2451002da4e2633dd010775b49e66e7a98068b73e60e5dc3c37e2491ee10f4f52bacc24d0c38f19d31a2cc9f436e8af2ebd6fac73d03
+  metadata.gz: f1d97c4397ca8410f6b62c3ea2de9a0a4b18ca610adcb92de9676c5377b00a071cbff4fbd0396760eea9ab359e4b0b8cdfff1630c9fa83de51cfd31b0b96307f
+  data.tar.gz: d9250a9ad1d57f40e7b0151484f77a66e11a361f8b0f50938f42219eb8322a9b4dc59c59102f4b49f62a28e90f03b8f9e0cf5b2799b5fd5080dbcf443cebac15

data/lib/generators/graphql/install_generator.rb

@@ -45,6 +45,13 @@ module Graphql
     # post "/graphql", to: "graphql#execute"
     # ```
     #
+    # Add ActiveRecord::QueryLogs metadata:
+    # ```ruby
+    #   current_graphql_operation: -> { GraphQL::Current.operation_name },
+    #   current_graphql_field: -> { GraphQL::Current.field&.path },
+    #   current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+    # ```
+    #
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
     # Use `--skip-graphiql` to skip `graphiql-rails` installation.
@@ -92,6 +99,11 @@ module Graphql
         default: false,
         desc: "Use GraphQL Playground over Graphiql as IDE"
 
+      class_option :skip_query_logs,
+        type: :boolean,
+        default: false,
+        desc: "Skip ActiveRecord::QueryLogs hooks in config/application.rb"
+
       # These two options are taken from Rails' own generators'
       class_option :api,
         type: :boolean,
@@ -180,6 +192,40 @@ RUBY
           install_relay
         end
 
+        if !options[:skip_query_logs]
+          config_file = "config/application.rb"
+          current_app_rb = File.read(Rails.root.join(config_file))
+          existing_log_tags_pattern = /config.active_record.query_log_tags = \[\n?(\s*:[a-z_]+,?\s*\n?|\s*#[^\]]*\n)*/m
+          existing_log_tags = existing_log_tags_pattern.match(current_app_rb)
+          if existing_log_tags && behavior == :invoke
+            code = <<-RUBY
+      # GraphQL-Ruby query log tags:
+      current_graphql_operation: -> { GraphQL::Current.operation_name },
+      current_graphql_field: -> { GraphQL::Current.field&.path },
+      current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+RUBY
+            if !existing_log_tags.to_s.end_with?(",")
+              code = ",\n#{code}    "
+            end
+            # Try to insert this code _after_ any plain symbol entries in the array of query log tags:
+            after_code = existing_log_tags_pattern
+          else
+            code = <<-RUBY
+    config.active_record.query_log_tags_enabled = true
+    config.active_record.query_log_tags = [
+      # Rails query log tags:
+      :application, :controller, :action, :job,
+      # GraphQL-Ruby query log tags:
+      current_graphql_operation: -> { GraphQL::Current.operation_name },
+      current_graphql_field: -> { GraphQL::Current.field&.path },
+      current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+    ]
+RUBY
+            after_code = "class Application < Rails::Application\n"
+          end
+          insert_into_file(config_file, code, after: after_code)
+        end
+
         if gemfile_modified?
           say "Gemfile has been modified, make sure you `bundle install`"
         end

data/lib/generators/graphql/orm_mutations_base.rb

@@ -18,7 +18,7 @@ module Graphql
       class_option :orm, banner: "NAME", type: :string, required: true,
                          desc: "ORM to generate the controller for"
 
-      class_option 'namespaced_types',
+      class_option :namespaced_types,
         type: :boolean,
         required: false,
         default: false,

data/lib/generators/graphql/templates/base_resolver.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Resolvers
   class BaseResolver < GraphQL::Schema::Resolver

data/lib/generators/graphql/type_generator.rb

@@ -11,7 +11,7 @@ module Graphql
     class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      class_option 'namespaced_types',
+      class_option :namespaced_types,
         type: :boolean,
         required: false,
         default: false,

data/lib/graphql/analysis/field_usage.rb

@@ -72,7 +72,7 @@ module GraphQL
       end
 
       def extract_deprecated_enum_value(enum_type, value)
-        enum_value = @query.warden.enum_values(enum_type).find { |ev| ev.value == value }
+        enum_value = @query.types.enum_values(enum_type).find { |ev| ev.value == value }
         if enum_value&.deprecation_reason
           @used_deprecated_enum_values << enum_value.path
         end

data/lib/graphql/analysis/query_complexity.rb

@@ -98,7 +98,7 @@ module GraphQL
         possible_scope_types.keys.each do |possible_scope_type|
           next unless possible_scope_type.kind.abstract?
 
-          query.possible_types(possible_scope_type).each do |impl_type|
+          query.types.possible_types(possible_scope_type).each do |impl_type|
             possible_scope_types[impl_type] ||= true
           end
           possible_scope_types.delete(possible_scope_type)
@@ -123,8 +123,8 @@ module GraphQL
       def types_intersect?(query, a, b)
         return true if a == b
 
-        a_types = query.possible_types(a)
-        query.possible_types(b).any? { |t| a_types.include?(t) }
+        a_types = query.types.possible_types(a)
+        query.types.possible_types(b).any? { |t| a_types.include?(t) }
       end
 
       # A hook which is called whenever a field's max complexity is calculated.

data/lib/graphql/analysis/visitor.rb

@@ -21,6 +21,7 @@ module GraphQL
         @rescued_errors = []
         @query = query
         @schema = query.schema
+        @types = query.types
         @response_path = []
         @skip_stack = [false]
         super(query.selected_operation)
@@ -131,7 +132,7 @@ module GraphQL
         @response_path.push(node.alias || node.name)
         parent_type = @object_types.last
         # This could be nil if the previous field wasn't found:
-        field_definition = parent_type && @schema.get_field(parent_type, node.name, @query.context)
+        field_definition = parent_type && @types.field(parent_type, node.name)
         @field_definitions.push(field_definition)
         if !field_definition.nil?
           next_object_type = field_definition.type.unwrap
@@ -167,14 +168,14 @@ module GraphQL
         argument_defn = if (arg = @argument_definitions.last)
           arg_type = arg.type.unwrap
           if arg_type.kind.input_object?
-            arg_type.get_argument(node.name, @query.context)
+            @types.argument(arg_type, node.name)
           else
             nil
           end
         elsif (directive_defn = @directive_definitions.last)
-          directive_defn.get_argument(node.name, @query.context)
+          @types.argument(directive_defn, node.name)
         elsif (field_defn = @field_definitions.last)
-          field_defn.get_argument(node.name, @query.context)
+          @types.argument(field_defn, node.name)
         else
           nil
         end
@@ -245,7 +246,7 @@ module GraphQL
         fragment_def = query.fragments[fragment_spread.name]
 
         object_type = if fragment_def.type
-          @query.warden.get_type(fragment_def.type.name)
+          @types.type(fragment_def.type.name)
         else
           object_types.last
         end
@@ -268,7 +269,7 @@ module GraphQL
 
       def on_fragment_with_type(node)
         object_type = if node.type
-          @query.warden.get_type(node.type.name)
+          @types.type(node.type.name)
         else
           @object_types.last
         end

data/lib/graphql/analysis.rb

@@ -81,7 +81,7 @@ module GraphQL
       end
     rescue Timeout::Error
       [GraphQL::AnalysisError.new("Timeout on validation of query")]
-    rescue GraphQL::UnauthorizedError
+    rescue GraphQL::UnauthorizedError, GraphQL::ExecutionError
       # This error was raised during analysis and will be returned the client before execution
       []
     end

data/lib/graphql/current.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # This module exposes Fiber-level runtime information.
+  #
+  # It won't work across unrelated fibers, although it will work in child Fibers.
+  #
+  # @example Setting Up ActiveRecord::QueryLogs
+  #
+  #   config.active_record.query_log_tags = [
+  #     :namespaced_controller,
+  #     :action,
+  #     :job,
+  #     # ...
+  #     {
+  #       # GraphQL runtime info:
+  #       current_graphql_operation: -> { GraphQL::Current.operation_name },
+  #       current_graphql_field: -> { GraphQL::Current.field&.path },
+  #       current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+  #       # ...
+  #     },
+  #   ]
+  #
+  module Current
+    # @return [String, nil] Comma-joined operation names for the currently-running {Multiplex}. `nil` if all operations are anonymous.
+    def self.operation_name
+      if (m = Fiber[:__graphql_current_multiplex])
+        m.context[:__graphql_current_operation_name] ||= begin
+          names = m.queries.map { |q| q.selected_operation_name }
+          if names.all?(&:nil?)
+            nil
+          else
+            names.join(",")
+          end
+        end
+      else
+        nil
+      end
+    end
+
+    # @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
+      Thread.current[:__graphql_runtime_info]&.values&.first&.current_field
+    end
+
+    # @return [Class, nil] The currently-running {Dataloader::Source} class, if there is one.
+    def self.dataloader_source_class
+      Fiber[:__graphql_current_dataloader_source]&.class
+    end
+  end
+end

data/lib/graphql/dataloader/async_dataloader.rb

@@ -12,6 +12,7 @@ module GraphQL
       end
 
       def run
+        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
         job_fibers = []
         next_job_fibers = []
         source_tasks = []
@@ -23,7 +24,7 @@ module GraphQL
             first_pass = false
             fiber_vars = get_fiber_variables
 
-            while (f = (job_fibers.shift || spawn_job_fiber))
+            while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber)))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -37,7 +38,7 @@ module GraphQL
             Sync do |root_task|
               set_fiber_variables(fiber_vars)
               while source_tasks.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-                while (task = source_tasks.shift || spawn_source_task(root_task, sources_condition))
+                while (task = (source_tasks.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size + next_source_tasks.size) < total_fiber_limit) && spawn_source_task(root_task, sources_condition))))
                   if task.alive?
                     root_task.yield # give the source task a chance to run
                     next_source_tasks << task

data/lib/graphql/dataloader/source.rb

@@ -98,7 +98,7 @@ module GraphQL
         while pending_result_keys.any? { |key| !@results.key?(key) }
           iterations += 1
           if iterations > MAX_ITERATIONS
-            raise "#{self.class}#sync tried #{MAX_ITERATIONS} times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency."
+            raise "#{self.class}#sync tried #{MAX_ITERATIONS} times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency#{@dataloader.fiber_limit ? " or `fiber_limit: #{@dataloader.fiber_limit}` is set too low" : ""}."
           end
           @dataloader.yield
         end
@@ -186,8 +186,11 @@ This key should have been loaded already. This is a bug in GraphQL::Dataloader,
 ERR
         end
         result = @results[key]
-
-        raise result if result.class <= StandardError
+        if result.is_a?(StandardError)
+          # Dup it because the rescuer may modify it.
+          # (This happens for GraphQL::ExecutionErrors, at least)
+          raise result.dup
+        end
 
         result
       end

data/lib/graphql/dataloader.rb

@@ -24,18 +24,23 @@ module GraphQL
   #
   class Dataloader
     class << self
-      attr_accessor :default_nonblocking
+      attr_accessor :default_nonblocking, :default_fiber_limit
     end
 
-    NonblockingDataloader = Class.new(self) { self.default_nonblocking = true }
-
-    def self.use(schema, nonblocking: nil)
-      schema.dataloader_class = if nonblocking
+    def self.use(schema, nonblocking: nil, fiber_limit: nil)
+      dataloader_class = if nonblocking
         warn("`nonblocking: true` is deprecated from `GraphQL::Dataloader`, please use `GraphQL::Dataloader::AsyncDataloader` instead. Docs: https://graphql-ruby.org/dataloader/async_dataloader.")
-        NonblockingDataloader
+        Class.new(self) { self.default_nonblocking = true }
       else
         self
       end
+
+      if fiber_limit
+        dataloader_class = Class.new(dataloader_class)
+        dataloader_class.default_fiber_limit = fiber_limit
+      end
+
+      schema.dataloader_class = dataloader_class
     end
 
     # Call the block with a Dataloader instance,
@@ -50,14 +55,18 @@ module GraphQL
       result
     end
 
-    def initialize(nonblocking: self.class.default_nonblocking)
+    def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.class.default_fiber_limit)
       @source_cache = Hash.new { |h, k| h[k] = {} }
       @pending_jobs = []
       if !nonblocking.nil?
         @nonblocking = nonblocking
       end
+      @fiber_limit = fiber_limit
     end
 
+    # @return [Integer, nil]
+    attr_reader :fiber_limit
+
     def nonblocking?
       @nonblocking
     end
@@ -178,6 +187,7 @@ module GraphQL
     end
 
     def run
+      jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
       next_job_fibers = []
       source_fibers = []
@@ -187,7 +197,7 @@ module GraphQL
         while first_pass || job_fibers.any?
           first_pass = false
 
-          while (f = (job_fibers.shift || spawn_job_fiber))
+          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber)))
             if f.alive?
               finished = run_fiber(f)
               if !finished
@@ -197,8 +207,8 @@ module GraphQL
           end
           join_queues(job_fibers, next_job_fibers)
 
-          while source_fibers.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-            while (f = source_fibers.shift || spawn_source_fiber)
+          while (source_fibers.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
+            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -242,6 +252,17 @@ module GraphQL
 
     private
 
+    def calculate_fiber_limit
+      total_fiber_limit = @fiber_limit || Float::INFINITY
+      if total_fiber_limit < 4
+        raise ArgumentError, "Dataloader fiber limit is too low (#{total_fiber_limit}), it must be at least 4"
+      end
+      total_fiber_limit -= 1 # deduct one fiber for `manager`
+      # Deduct at least one fiber for sources
+      jobs_fiber_limit = total_fiber_limit - 2
+      return jobs_fiber_limit, total_fiber_limit
+    end
+
     def join_queues(prev_queue, new_queue)
       @nonblocking && Fiber.scheduler.run
       prev_queue.concat(new_queue)
@@ -271,7 +292,10 @@ module GraphQL
 
       if pending_sources
         spawn_fiber do
-          pending_sources.each(&:run_pending_keys)
+          pending_sources.each do |source|
+            Fiber[:__graphql_current_dataloader_source] = source
+            source.run_pending_keys
+          end
         end
       end
     end

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

@@ -8,22 +8,17 @@ module GraphQL
           @query = query
           @dataloader = query.context.dataloader
           @storage = Hash.new do |h, argument_owner|
-            args_by_parent = if argument_owner.arguments_statically_coercible?
+            h[argument_owner] = if argument_owner.arguments_statically_coercible?
               shared_values_cache = {}
               Hash.new do |h2, ignored_parent_object|
                 h2[ignored_parent_object] = shared_values_cache
-              end
+              end.compare_by_identity
             else
               Hash.new do |h2, parent_object|
-                args_by_node = {}
-                args_by_node.compare_by_identity
-                h2[parent_object] = args_by_node
-              end
+                h2[parent_object] = {}.compare_by_identity
+              end.compare_by_identity
             end
-            args_by_parent.compare_by_identity
-            h[argument_owner] = args_by_parent
-          end
-          @storage.compare_by_identity
+          end.compare_by_identity
         end
 
         def fetch(ast_node, argument_owner, parent_object)

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

@@ -12,12 +12,16 @@ module GraphQL
         end
 
         def self.resolve_each_depth(lazies_at_depth, dataloader)
-          depths = lazies_at_depth.keys
-          depths.sort!
-          next_depth = depths.first
-          if next_depth
-            lazies = lazies_at_depth[next_depth]
-            lazies_at_depth.delete(next_depth)
+          smallest_depth = nil
+          lazies_at_depth.each_key do |depth_key|
+            smallest_depth ||= depth_key
+            if depth_key < smallest_depth
+              smallest_depth = depth_key
+            end
+          end
+
+          if smallest_depth
+            lazies = lazies_at_depth.delete(smallest_depth)
             if lazies.any?
               dataloader.append_job {
                 lazies.each(&:value) # resolve these Lazy instances

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

@@ -53,8 +53,7 @@ module GraphQL
             end
           end
           # { Class => Boolean }
-          @lazy_cache = {}
-          @lazy_cache.compare_by_identity
+          @lazy_cache = {}.compare_by_identity
         end
 
         def final_result
@@ -160,9 +159,9 @@ module GraphQL
               case node
               when GraphQL::Language::Nodes::InlineFragment
                 if node.type
-                  type_defn = schema.get_type(node.type.name, context)
+                  type_defn = query.types.type(node.type.name)
 
-                  if query.warden.possible_types(type_defn).include?(owner_type)
+                  if query.types.possible_types(type_defn).include?(owner_type)
                     result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
                     if !result.equal?(next_selections)
                       selections_to_run = result
@@ -177,8 +176,8 @@ module GraphQL
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
-                type_defn = query.get_type(fragment_def.type.name)
-                if query.warden.possible_types(type_defn).include?(owner_type)
+                type_defn = query.types.type(fragment_def.type.name)
+                if query.types.possible_types(type_defn).include?(owner_type)
                   result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
                   if !result.equal?(next_selections)
                     selections_to_run = result
@@ -208,22 +207,32 @@ module GraphQL
             finished_jobs = 0
             enqueued_jobs = gathered_selections.size
             gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
-              @dataloader.append_job {
-                evaluate_selection(
-                  result_name, field_ast_nodes_or_ast_node, selections_result
-                )
-                finished_jobs += 1
-                if target_result && finished_jobs == enqueued_jobs
-                  selections_result.merge_into(target_result)
-                end
-              }
+
               # Field resolution may pause the fiber,
               # so it wouldn't get to the `Resolve` call that happens below.
               # So instead trigger a run from this outer context.
               if selections_result.graphql_is_eager
                 @dataloader.clear_cache
-                @dataloader.run
-                @dataloader.clear_cache
+                @dataloader.run_isolated {
+                  evaluate_selection(
+                    result_name, field_ast_nodes_or_ast_node, selections_result
+                  )
+                  finished_jobs += 1
+                  if target_result && finished_jobs == enqueued_jobs
+                    selections_result.merge_into(target_result)
+                  end
+                  @dataloader.clear_cache
+                }
+              else
+                @dataloader.append_job {
+                  evaluate_selection(
+                    result_name, field_ast_nodes_or_ast_node, selections_result
+                  )
+                  finished_jobs += 1
+                  if target_result && finished_jobs == enqueued_jobs
+                    selections_result.merge_into(target_result)
+                  end
+                }
               end
             end
             selections_result
@@ -245,7 +254,7 @@ module GraphQL
           end
           field_name = ast_node.name
           owner_type = selections_result.graphql_result_type
-          field_defn = query.warden.get_field(owner_type, field_name)
+          field_defn = query.types.field(owner_type, field_name)
 
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           runtime_state = get_current_runtime_state
@@ -579,7 +588,7 @@ module GraphQL
                 resolved_value = value
               end
 
-              possible_types = query.possible_types(current_type)
+              possible_types = query.types.possible_types(current_type)
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
                 err_class = current_type::UnresolvedTypeError
@@ -727,12 +736,7 @@ module GraphQL
         end
 
         def get_current_runtime_state
-          current_state = Thread.current[:__graphql_runtime_info] ||= begin
-            per_query_state = {}
-            per_query_state.compare_by_identity
-            per_query_state
-          end
-
+          current_state = Thread.current[:__graphql_runtime_info] ||= {}.compare_by_identity
           current_state[@query] ||= CurrentState.new
         end
 

data/lib/graphql/execution/interpreter.rb

@@ -34,6 +34,7 @@ module GraphQL
           end
 
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          Fiber[:__graphql_current_multiplex] = multiplex
           multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
@@ -136,6 +137,7 @@ module GraphQL
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
+              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime

data/lib/graphql/execution/lookahead.rb

@@ -108,16 +108,16 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_defn = case field_name
         when String
-          @query.get_field(selected_type, field_name)
+          @query.types.field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
           all_fields = if selected_type.kind.fields?
-            @query.warden.fields(selected_type)
+            @query.types.fields(selected_type)
           else
             # Handle unions by checking possible
-            @query.warden
+            @query.types
               .possible_types(selected_type)
-              .map { |t| @query.warden.fields(t) }
+              .map { |t| @query.types.fields(t) }
               .tap(&:flatten!)
           end
 
@@ -128,7 +128,7 @@ module GraphQL
             # Symbol#name is only present on 3.0+
             sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
             guessed_name = Schema::Member::BuildType.camelize(sym_s)
-            @query.get_field(selected_type, guessed_name)
+            @query.types.field(selected_type, guessed_name)
           end
         end
         lookahead_for_selection(next_field_defn, selected_type, arguments)
@@ -144,7 +144,7 @@ module GraphQL
         alias_node = lookup_alias_node(ast_nodes, alias_name)
         return NULL_LOOKAHEAD unless alias_node
 
-        next_field_defn = @query.get_field(selected_type, alias_node.name)
+        next_field_defn = @query.types.field(selected_type, alias_node.name)
 
         alias_arguments = @query.arguments_for(alias_node, next_field_defn)
         if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
@@ -183,7 +183,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = @query.get_field(type, ast_nodes.first.name)
+            field_defn = @query.types.field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -266,7 +266,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = @query.get_field(selected_type, ast_selection.name)
+              field_defn = @query.types.field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -276,14 +276,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.get_type(t.name)
+              on_type = @query.types.type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
-            on_type = @query.get_type(frag_defn.type.name)
+            on_type = @query.types.type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else