graphql 1.9.5 → 1.13.19

data/lib/graphql/execution/interpreter.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
+require "fiber"
+require "graphql/execution/interpreter/argument_value"
+require "graphql/execution/interpreter/arguments"
+require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
-require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"
 require "graphql/execution/interpreter/resolve"
+require "graphql/execution/interpreter/handles_raw_value"
 
 module GraphQL
   module Execution
@@ -14,19 +18,18 @@ module GraphQL
       def execute(_operation, _root_type, query)
         runtime = evaluate(query)
         sync_lazies(query: query)
-        runtime.final_value
+        runtime.final_result
       end
 
-      def self.use(schema_defn)
-        schema_defn.target.interpreter = true
-        # Reach through the legacy objects for the actual class defn
-        schema_class = schema_defn.target.class
-        # This is not good, since both of these are holding state now,
-        # we have to update both :(
-        [schema_class, schema_defn].each do |schema_config|
-          schema_config.query_execution_strategy(GraphQL::Execution::Interpreter)
-          schema_config.mutation_execution_strategy(GraphQL::Execution::Interpreter)
-          schema_config.subscription_execution_strategy(GraphQL::Execution::Interpreter)
+      def self.use(schema_class)
+        if schema_class.interpreter?
+          definition_line = caller(2, 1).first
+          GraphQL::Deprecation.warn("GraphQL::Execution::Interpreter is now the default; remove `use GraphQL::Execution::Interpreter` from the schema definition (#{definition_line})")
+        else
+          schema_class.query_execution_strategy(self)
+          schema_class.mutation_execution_strategy(self)
+          schema_class.subscription_execution_strategy(self)
+          schema_class.add_subscription_extension_if_necessary
         end
       end
 
@@ -53,7 +56,7 @@ module GraphQL
 
       def self.finish_query(query, _multiplex)
         {
-          "data" => query.context.namespace(:interpreter)[:runtime].final_value
+          "data" => query.context.namespace(:interpreter)[:runtime].final_result
         }
       end
 
@@ -63,10 +66,7 @@ module GraphQL
         # Although queries in a multiplex _share_ an Interpreter instance,
         # they also have another item of state, which is private to that query
         # in particular, assign it here:
-        runtime = Runtime.new(
-          query: query,
-          response: HashResponse.new,
-        )
+        runtime = Runtime.new(query: query)
         query.context.namespace(:interpreter)[:runtime] = runtime
 
         query.trace("execute_query", {query: query}) do
@@ -87,11 +87,34 @@ module GraphQL
         final_values = queries.map do |query|
           runtime = query.context.namespace(:interpreter)[:runtime]
           # it might not be present if the query has an error
-          runtime ? runtime.final_value : nil
+          runtime ? runtime.final_result : nil
         end
         final_values.compact!
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-          Interpreter::Resolve.resolve_all(final_values)
+          Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
+        end
+        queries.each do |query|
+          runtime = query.context.namespace(:interpreter)[:runtime]
+          if runtime
+            runtime.delete_interpreter_context(:current_path)
+            runtime.delete_interpreter_context(:current_field)
+            runtime.delete_interpreter_context(:current_object)
+            runtime.delete_interpreter_context(:current_arguments)
+          end
+        end
+        nil
+      end
+
+      class ListResultFailedError < GraphQL::Error
+        def initialize(value:, path:, field:)
+          message = "Failed to build a GraphQL list result for field `#{field.path}` at path `#{path.join(".")}`.\n".dup
+
+          message << "Expected `#{value.inspect}` (#{value.class}) to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
+
+          if field.connection?
+            message << "\nThis field was treated as a Relay-style connection; add `connection: false` to the `field(...)` to disable this behavior."
+          end
+          super(message)
         end
       end
     end

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -36,6 +36,10 @@ module GraphQL
           @storage.compute_if_absent(value.class) { find_superclass_method(value.class) }
         end
 
+        def each
+          @storage.each_pair { |k, v| yield(k, v) }
+        end
+
         protected
 
         attr_reader :storage

data/lib/graphql/execution/lazy.rb

@@ -48,7 +48,11 @@ module GraphQL
           end
         end
 
-        if @value.is_a?(StandardError)
+        # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+        # (fewer clauses in a hot `case` block), but now it requires special handling here.
+        # I think it's still worth it for the performance win, but if the number of special
+        # cases grows, then maybe it's worth rethinking somehow.
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::Execute::SKIP
           raise @value
         else
           @value

data/lib/graphql/execution/lookahead.rb

@@ -51,7 +51,17 @@ module GraphQL
 
       # @return [Hash<Symbol, Object>]
       def arguments
-        @arguments ||= @field && ArgumentHelpers.arguments(@query, nil, @field, ast_nodes.first)
+        if defined?(@arguments)
+          @arguments
+        else
+          @arguments = if @field
+            @query.schema.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
+              args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
+            end
+          else
+            nil
+          end
+        end
       end
 
       # True if this node has a selection on `field_name`.
@@ -81,7 +91,7 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_name = normalize_name(field_name)
 
-        next_field_defn = FieldHelpers.get_field(@query.schema, selected_type, next_field_name)
+        next_field_defn = get_class_based_field(selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
@@ -127,7 +137,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 = FieldHelpers.get_field(@query.schema, type, ast_nodes.first.name)
+            field_defn = get_class_based_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
@@ -203,8 +213,29 @@ module GraphQL
         end
       end
 
+      # Wrap get_field and ensure that it returns a GraphQL::Schema::Field.
+      # Remove this when legacy execution is removed.
+      def get_class_based_field(type, name)
+        f = @query.get_field(type, name)
+        f && f.type_class
+      end
+
+      def skipped_by_directive?(ast_selection)
+        ast_selection.directives.each do |directive|
+          dir_defn = @query.schema.directives.fetch(directive.name)
+          directive_class = dir_defn.type_class
+          if directive_class
+            dir_args = @query.arguments_for(directive, dir_defn)
+            return true unless directive_class.static_include?(dir_args, @query.context)
+          end
+        end
+        false
+      end
+
       def find_selections(subselections_by_type, selections_on_type, selected_type, ast_selections, arguments)
         ast_selections.each do |ast_selection|
+          next if skipped_by_directive?(ast_selection)
+
           case ast_selection
           when GraphQL::Language::Nodes::Field
             response_key = ast_selection.alias || ast_selection.name
@@ -213,7 +244,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = FieldHelpers.get_field(@query.schema, selected_type, ast_selection.name)
+              field_defn = get_class_based_field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -223,14 +254,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.schema.types[t.name].metadata[:type_class]
+              on_type = @query.get_type(t.name).type_class
               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 = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
             # Again, assuming a valid AST
-            on_type = @query.schema.types[frag_defn.type.name].metadata[:type_class]
+            on_type = @query.get_type(frag_defn.type.name).type_class
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else
@@ -242,6 +273,7 @@ module GraphQL
       # If a selection on `node` matches `field_name` (which is backed by `field_defn`)
       # and matches the `arguments:` constraints, then add that node to `matches`
       def find_selected_nodes(node, field_name, field_defn, arguments:, matches:)
+        return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
           if node.name == field_name
@@ -263,120 +295,13 @@ module GraphQL
       end
 
       def arguments_match?(arguments, field_defn, field_node)
-        query_kwargs = ArgumentHelpers.arguments(@query, nil, field_defn, field_node)
+        query_kwargs = @query.arguments_for(field_node, field_defn)
         arguments.all? do |arg_name, arg_value|
           arg_name = normalize_keyword(arg_name)
           # Make sure the constraint is present with a matching value
           query_kwargs.key?(arg_name) && query_kwargs[arg_name] == arg_value
         end
       end
-
-      # TODO Dedup with interpreter
-      module ArgumentHelpers
-        module_function
-
-        def arguments(query, graphql_object, arg_owner, ast_node)
-          kwarg_arguments = {}
-          arg_defns = arg_owner.arguments
-          ast_node.arguments.each do |arg|
-            arg_defn = arg_defns[arg.name] || raise("Invariant: missing argument definition for #{arg.name.inspect} in #{arg_defns.keys} from #{arg_owner}")
-            # Need to distinguish between client-provided `nil`
-            # and nothing-at-all
-            is_present, value = arg_to_value(query, graphql_object, arg_defn.type, arg.value)
-            if is_present
-              # This doesn't apply to directives, which are legacy
-              # Can remove this when Skip and Include use classes or something.
-              if graphql_object
-                value = arg_defn.prepare_value(graphql_object, value)
-              end
-              kwarg_arguments[arg_defn.keyword] = value
-            end
-          end
-          arg_defns.each do |name, arg_defn|
-            if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              kwarg_arguments[arg_defn.keyword] = arg_defn.default_value
-            end
-          end
-          kwarg_arguments
-        end
-
-        # Get a Ruby-ready value from a client query.
-        # @param graphql_object [Object] The owner of the field whose argument this is
-        # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
-        # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
-        # @return [Array(is_present, value)]
-        def arg_to_value(query, graphql_object, arg_type, ast_value)
-          if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-            # If it's not here, it will get added later
-            if query.variables.key?(ast_value.name)
-              return true, query.variables[ast_value.name]
-            else
-              return false, nil
-            end
-          elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-            return true, nil
-          elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(query, graphql_object, arg_type.of_type, ast_value)
-          elsif arg_type.is_a?(GraphQL::Schema::List)
-            # Treat a single value like a list
-            arg_value = Array(ast_value)
-            list = []
-            arg_value.map do |inner_v|
-              _present, value = arg_to_value(query, graphql_object, arg_type.of_type, inner_v)
-              list << value
-            end
-            return true, list
-          elsif arg_type.is_a?(Class) && arg_type < GraphQL::Schema::InputObject
-            # For these, `prepare` is applied during `#initialize`.
-            # Pass `nil` so it will be skipped in `#arguments`.
-            # What a mess.
-            args = arguments(query, nil, arg_type, ast_value)
-            # We're not tracking defaults_used, but for our purposes
-            # we compare the value to the default value.
-            return true, arg_type.new(ruby_kwargs: args, context: query.context, defaults_used: nil)
-          else
-            flat_value = flatten_ast_value(query, ast_value)
-            return true, arg_type.coerce_input(flat_value, query.context)
-          end
-        end
-
-        def flatten_ast_value(query, v)
-          case v
-          when GraphQL::Language::Nodes::Enum
-            v.name
-          when GraphQL::Language::Nodes::InputObject
-            h = {}
-            v.arguments.each do |arg|
-              h[arg.name] = flatten_ast_value(query, arg.value)
-            end
-            h
-          when Array
-            v.map { |v2| flatten_ast_value(query, v2) }
-          when GraphQL::Language::Nodes::VariableIdentifier
-            flatten_ast_value(query.variables[v.name])
-          else
-            v
-          end
-        end
-      end
-
-      # TODO dedup with interpreter
-      module FieldHelpers
-        module_function
-
-        def get_field(schema, owner_type, field_name)
-          field_defn = owner_type.get_field(field_name)
-          field_defn ||= if owner_type == schema.query.metadata[:type_class] && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
-            entry_point_field.metadata[:type_class]
-          elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field.metadata[:type_class]
-          else
-            nil
-          end
-
-          field_defn
-        end
-      end
     end
   end
 end

data/lib/graphql/execution/multiplex.rb

@@ -29,13 +29,14 @@ module GraphQL
 
       include Tracing::Traceable
 
-      attr_reader :context, :queries, :schema, :max_complexity
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader
       def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
+        @queries.each { |q| q.multiplex = self }
         @context = context
-        # TODO remove support for global tracers
-        @tracers = schema.tracers + GraphQL::Tracing.tracers + (context[:tracers] || [])
+        @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
+        @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
           @tracers << GraphQL::Backtrace::Tracer
@@ -44,9 +45,9 @@ module GraphQL
       end
 
       class << self
-        def run_all(schema, query_options, *args)
-          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
-          run_queries(schema, queries, *args)
+        def run_all(schema, query_options, **kwargs)
+          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
+          run_queries(schema, queries, **kwargs)
         end
 
         # @param schema [GraphQL::Schema]
@@ -73,6 +74,24 @@ module GraphQL
           end
         end
 
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
         private
 
         def run_as_multiplex(multiplex)
@@ -80,43 +99,35 @@ module GraphQL
           multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
           queries = multiplex.queries
           # Do as much eager evaluation of the query as possible
-          results = queries.map do |query|
-            begin_query(query, multiplex)
+          results = []
+          queries.each_with_index do |query, idx|
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
           end
 
+          multiplex.dataloader.run
+
           # Then, work through lazy results in a breadth-first way
-          multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          multiplex.dataloader.append_job {
+            multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          }
+          multiplex.dataloader.run
 
           # Then, find all errors and assign the result to the query object
-          results.each_with_index.map do |data_result, idx|
+          results.each_with_index do |data_result, idx|
             query = queries[idx]
             finish_query(data_result, query, multiplex)
             # Get the Query::Result, not the Hash
-            query.result
+            results[idx] = query.result
           end
+
+          results
         rescue Exception
+          # TODO rescue at a higher level so it will catch errors in analysis, too
           # Assign values here so that the query's `@executed` becomes true
           queries.map { |q| q.result_values ||= {} }
           raise
         end
 
-        # @param query [GraphQL::Query]
-        # @return [Hash] The initial result (may not be finished if there are lazy values)
-        def begin_query(query, multiplex)
-          operation = query.selected_operation
-          if operation.nil? || !query.valid? || query.context.errors.any?
-            NO_OPERATION
-          else
-            begin
-              # These were checked to be the same in `#supports_multiplexing?`
-              query.schema.query_execution_strategy.begin_query(query, multiplex)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-        end
-
         # @param data_result [Hash] The result for the "data" key, if any
         # @param query [GraphQL::Query] The query which was run
         # @return [Hash] final result of this query, including all values and errors
@@ -140,10 +151,15 @@ module GraphQL
 
             result
           end
+          if query.context.namespace?(:__query_result_extensions__)
+            query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+          end
         end
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
+          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+
           query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors
             if all_errors.any?
@@ -173,9 +189,22 @@ module GraphQL
         def instrument_and_analyze(multiplex)
           GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
             schema = multiplex.schema
+            if schema.interpreter? && schema.analysis_engine != GraphQL::Analysis::AST
+              raise <<-ERR
+Can't use `GraphQL::Execution::Interpreter` without `GraphQL::Analysis::AST`, please add this plugin to your schema:
+
+    use GraphQL::Analysis::AST
+
+For information about the new analysis engine: https://graphql-ruby.org/queries/ast_analysis.html
+ERR
+            end
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
+              multiplex_analyzers += if schema.using_ast_analysis?
+                [GraphQL::Analysis::AST::MaxQueryComplexity]
+              else
+                [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
+              end
             end
 
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)

data/lib/graphql/execution.rb

@@ -8,3 +8,4 @@ require "graphql/execution/lazy"
 require "graphql/execution/lookahead"
 require "graphql/execution/multiplex"
 require "graphql/execution/typecast"
+require "graphql/execution/errors"

data/lib/graphql/execution_error.rb

@@ -48,8 +48,9 @@ module GraphQL
         hash.merge!(options)
       end
       if extensions
-        hash["extensions"] ||= {}
-        hash["extensions"].merge!(extensions)
+        hash["extensions"] = extensions.each_with_object({}) { |(key, value), ext|
+          ext[key.to_s] = value
+        }
       end
       hash
     end

data/lib/graphql/field.rb

@@ -2,126 +2,10 @@
 require "graphql/field/resolve"
 
 module GraphQL
-  # {Field}s belong to {ObjectType}s and {InterfaceType}s.
-  #
-  # They're usually created with the `field` helper. If you create it by hand, make sure {#name} is a String.
-  #
-  # A field must have a return type, but if you want to defer the return type calculation until later,
-  # you can pass a proc for the return type. That proc will be called when the schema is defined.
-  #
-  # @example Lazy type resolution
-  #   # If the field's type isn't defined yet, you can pass a proc
-  #   field :city, -> { TypeForModelName.find("City") }
-  #
-  # For complex field definition, you can pass a block to the `field` helper, eg `field :name do ... end`.
-  # This block is equivalent to calling `GraphQL::Field.define { ... }`.
-  #
-  # @example Defining a field with a block
-  #   field :city, CityType do
-  #     # field definition continues inside the block
-  #   end
-  #
-  # ## Resolve
-  #
-  # Fields have `resolve` functions to determine their values at query-time.
-  # The default implementation is to call a method on the object based on the field name.
-  #
-  # @example Create a field which calls a method with the same name.
-  #   GraphQL::ObjectType.define do
-  #     field :name, types.String, "The name of this thing "
-  #   end
-  #
-  # You can specify a custom proc with the `resolve` helper.
-  #
-  # There are some shortcuts for common `resolve` implementations:
-  #   - Provide `property:` to call a method with a different name than the field name
-  #   - Provide `hash_key:` to resolve the field by doing a key lookup, eg `obj[:my_hash_key]`
-  #
-  # @example Create a field that calls a different method on the object
-  #   GraphQL::ObjectType.define do
-  #     # use the `property` keyword:
-  #     field :firstName, types.String, property: :first_name
-  #   end
-  #
-  # @example Create a field looks up with `[hash_key]`
-  #   GraphQL::ObjectType.define do
-  #     # use the `hash_key` keyword:
-  #     field :firstName, types.String, hash_key: :first_name
-  #   end
-  #
-  # ## Arguments
-  #
-  # Fields can take inputs; they're called arguments. You can define them with the `argument` helper.
-  #
-  # @example Create a field with an argument
-  #   field :students, types[StudentType] do
-  #     argument :grade, types.Int
-  #     resolve ->(obj, args, ctx) {
-  #       Student.where(grade: args[:grade])
-  #     }
-  #   end
-  #
-  # They can have default values which will be provided to `resolve` if the query doesn't include a value.
-  #
-  # @example Argument with a default value
-  #   field :events, types[EventType] do
-  #     # by default, don't include past events
-  #     argument :includePast, types.Boolean, default_value: false
-  #     resolve ->(obj, args, ctx) {
-  #       args[:includePast] # => false if no value was provided in the query
-  #       # ...
-  #     }
-  #   end
-  #
-  # Only certain types maybe used for inputs:
-  #
-  # - Scalars
-  # - Enums
-  # - Input Objects
-  # - Lists of those types
-  #
-  # Input types may also be non-null -- in that case, the query will fail
-  # if the input is not present.
-  #
-  # ## Complexity
-  #
-  # Fields can have _complexity_ values which describe the computation cost of resolving the field.
-  # You can provide the complexity as a constant with `complexity:` or as a proc, with the `complexity` helper.
-  #
-  # @example Custom complexity values
-  #   # Complexity can be a number or a proc.
-  #
-  #   # Complexity can be defined with a keyword:
-  #   field :expensive_calculation, !types.Int, complexity: 10
-  #
-  #   # Or inside the block:
-  #   field :expensive_calculation_2, !types.Int do
-  #     complexity ->(ctx, args, child_complexity) { ctx[:current_user].staff? ? 0 : 10 }
-  #   end
-  #
-  # @example Calculating the complexity of a list field
-  #   field :items, types[ItemType] do
-  #     argument :limit, !types.Int
-  #     # Multiply the child complexity by the possible items on the list
-  #     complexity ->(ctx, args, child_complexity) { child_complexity * args[:limit] }
-  #   end
-  #
-  # @example Creating a field, then assigning it to a type
-  #   name_field = GraphQL::Field.define do
-  #     name("Name")
-  #     type(!types.String)
-  #     description("The name of this thing")
-  #     resolve ->(object, arguments, context) { object.name }
-  #   end
-  #
-  #   NamedType = GraphQL::ObjectType.define do
-  #     # The second argument may be a GraphQL::Field
-  #     field :name, name_field
-  #   end
-  #
+  # @api deprecated
   class Field
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :description, :deprecation_reason,
+    deprecated_accepts_definitions :name, :description, :deprecation_reason,
       :resolve, :lazy_resolve,
       :type, :arguments,
       :property, :hash_key, :complexity,
@@ -196,6 +80,10 @@ module GraphQL
 
     attr_accessor :ast_node
 
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
     # @return [Boolean]
     def connection?
       @connection
@@ -266,7 +154,7 @@ module GraphQL
     end
 
     def name=(new_name)
-      old_name = @name
+      old_name = defined?(@name) ? @name : nil
       @name = new_name
 
       if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)
@@ -315,6 +203,14 @@ module GraphQL
       }
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+
     private
 
     def build_default_resolver