graphql 1.9.17 → 1.10.0

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

@@ -46,12 +46,11 @@ module GraphQL
 
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
-          legacy_root_type = schema.root_type_for_operation(root_op_type)
-          root_type = legacy_root_type.metadata[:type_class] || raise("Invariant: type must be class-based: #{legacy_root_type}")
+          root_type = schema.root_type_for_operation(root_op_type)
           path = []
           @interpreter_context[:current_object] = query.root_value
           @interpreter_context[:current_path] = path
-          object_proxy = root_type.authorized_new(query.root_value, context)
+          object_proxy = authorized_new(root_type, query.root_value, context, path)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
             # Root .authorized? returned false.
@@ -89,11 +88,10 @@ module GraphQL
               end
             when GraphQL::Language::Nodes::InlineFragment
               if node.type
-                type_defn = schema.types[node.type.name]
-                type_defn = type_defn.metadata[:type_class]
+                type_defn = schema.get_type(node.type.name)
                 # Faster than .map{}.include?()
                 query.warden.possible_types(type_defn).each do |t|
-                  if t.metadata[:type_class] == owner_type
+                  if t == owner_type
                     gather_selections(owner_object, owner_type, node.selections, selections_by_name)
                     break
                   end
@@ -104,10 +102,10 @@ module GraphQL
               end
             when GraphQL::Language::Nodes::FragmentSpread
               fragment_def = query.fragments[node.name]
-              type_defn = schema.types[fragment_def.type.name]
-              type_defn = type_defn.metadata[:type_class]
-              schema.possible_types(type_defn).each do |t|
-                if t.metadata[:type_class] == owner_type
+              type_defn = schema.get_type(fragment_def.type.name)
+              possible_types = query.warden.possible_types(type_defn)
+              possible_types.each do |t|
+                if t == owner_type
                   gather_selections(owner_object, owner_type, fragment_def.selections, selections_by_name)
                   break
                 end
@@ -138,18 +136,18 @@ module GraphQL
             field_defn = @fields_cache[owner_type][field_name] ||= owner_type.get_field(field_name)
             is_introspection = false
             if field_defn.nil?
-              field_defn = if owner_type == schema.query.metadata[:type_class] && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
+              field_defn = if owner_type == schema.query && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
                 is_introspection = true
-                entry_point_field.metadata[:type_class]
+                entry_point_field
               elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
                 is_introspection = true
-                dynamic_field.metadata[:type_class]
+                dynamic_field
               else
                 raise "Invariant: no field for #{owner_type}.#{field_name}"
               end
             end
 
-            return_type = resolve_if_late_bound_type(field_defn.type)
+            return_type = field_defn.type
 
             next_path = path.dup
             next_path << result_name
@@ -167,7 +165,7 @@ module GraphQL
             object = owner_object
 
             if is_introspection
-              object = field_defn.owner.authorized_new(object, context)
+              object = authorized_new(field_defn.owner, object, context, next_path)
             end
 
             begin
@@ -295,8 +293,8 @@ module GraphQL
             write_in_response(path, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy = query.resolve_type(type, value)
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
+            resolved_type_or_lazy = resolve_type(type, value, path)
+            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
@@ -306,17 +304,16 @@ module GraphQL
                 write_in_response(path, nil)
                 nil
               else
-                resolved_type = resolved_type.metadata[:type_class]
                 continue_field(path, value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
           when "OBJECT"
             object_proxy = begin
-              type.authorized_new(value, context)
+              authorized_new(type, value, context, path)
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
+            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
               continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
@@ -349,8 +346,6 @@ module GraphQL
             response_list
           when "NON_NULL"
             inner_type = type.of_type
-            # For fields like `__schema: __Schema!`
-            inner_type = resolve_if_late_bound_type(inner_type)
             # Don't `set_type_at_path` because we want the static type,
             # we're going to use that to determine whether a `nil` should be propagated or not.
             continue_field(path, value, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
@@ -370,7 +365,7 @@ module GraphQL
           else
             dir_defn = schema.directives.fetch(dir_node.name)
             if !dir_defn.is_a?(Class)
-              dir_defn = dir_defn.metadata[:type_class] || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
+              dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
             dir_args = arguments(nil, dir_defn, dir_node)
             dir_defn.resolve(object, dir_args, context) do
@@ -382,7 +377,7 @@ module GraphQL
         # Check {Schema::Directive.include?} for each directive that's present
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
-            dir_defn = schema.directives.fetch(dir_node.name).metadata[:type_class] || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
+            dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
             args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false
@@ -391,20 +386,13 @@ module GraphQL
           true
         end
 
-        def resolve_if_late_bound_type(type)
-          if type.is_a?(GraphQL::Schema::LateBoundType)
-            query.warden.get_type(type.name).metadata[:type_class]
-          else
-            type
-          end
-        end
-
         # @param obj [Object] Some user-returned value that may want to be batched
         # @param path [Array<String>]
         # @param field [GraphQL::Schema::Field]
         # @param eager [Boolean] Set to `true` for mutation root fields only
+        # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false)
+        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false, trace: true)
           @interpreter_context[:current_object] = owner_object
           @interpreter_context[:current_arguments] = arguments
           @interpreter_context[:current_path] = path
@@ -420,7 +408,11 @@ module GraphQL
               # but don't wrap the continuation below
               inner_obj = begin
                 query.with_error_handling do
-                  query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments}) do
+                  if trace
+                    query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments}) do
+                      schema.sync_lazy(lazy_obj)
+                    end
+                  else
                     schema.sync_lazy(lazy_obj)
                   end
                 end
@@ -466,7 +458,7 @@ module GraphQL
             arg_defn = arg_defns[arg_name]
             # Need to distinguish between client-provided `nil`
             # and nothing-at-all
-            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_value)
+            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_value, already_arguments: false)
             if is_present
               # This doesn't apply to directives, which are legacy
               # Can remove this when Skip and Include use classes or something.
@@ -478,54 +470,78 @@ module GraphQL
           end
           arg_defns.each do |name, arg_defn|
             if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              _is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_defn.default_value)
+              _is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_defn.default_value, already_arguments: false)
               kwarg_arguments[arg_defn.keyword] = value
             end
           end
           kwarg_arguments
         end
 
+        # TODO CAN THIS USE `.coerce_input` ???
+
         # 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]
+        # @param already_arguments [Boolean] if true, don't re-coerce these with `arguments(...)`
         # @return [Array(is_present, value)]
-        def arg_to_value(graphql_object, arg_type, ast_value)
+        def arg_to_value(graphql_object, arg_type, ast_value, already_arguments:)
           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]
+              variable_value = query.variables[ast_value.name]
+              arg_to_value(graphql_object, arg_type, variable_value, already_arguments: true)
             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(graphql_object, arg_type.of_type, ast_value)
+            arg_to_value(graphql_object, arg_type.of_type, ast_value, already_arguments: already_arguments)
           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(graphql_object, arg_type.of_type, inner_v)
-              list << value
-            end
-            return true, list
+            if ast_value.nil?
+              return true, nil
+            else
+              # Treat a single value like a list
+              arg_value = Array(ast_value)
+              list = []
+              arg_value.map do |inner_v|
+                _present, value = arg_to_value(graphql_object, arg_type.of_type, inner_v, already_arguments: already_arguments)
+                list << value
+              end
+              return true, list
+            end
           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(nil, arg_type, ast_value)
-            # We're not tracking defaults_used, but for our purposes
-            # we compare the value to the default value.
+            if already_arguments
+              # This came from a variable, already prepared.
+              # But replace `nil` with `{}` like we would for `arg_type`
+              if ast_value.nil?
+                return false, nil
+              else
+                args = ast_value
+              end
+            else
+              # For these, `prepare` is applied during `#initialize`.
+              # Pass `nil` so it will be skipped in `#arguments`.
+              # What a mess.
+              args = arguments(nil, arg_type, ast_value)
+            end
 
             input_obj = query.with_error_handling do
+              # We're not tracking defaults_used, but for our purposes
+              # we compare the value to the default value.
               arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
             end
             return true, input_obj
           else
-            flat_value = flatten_ast_value(ast_value)
-            return true, arg_type.coerce_input(flat_value, context)
+            flat_value = if already_arguments
+              # It was coerced by variable handling
+              ast_value
+            else
+              v = flatten_ast_value(ast_value)
+              arg_type.coerce_input(v, context)
+            end
+            return true, flat_value
           end
         end
 
@@ -628,6 +644,41 @@ module GraphQL
           end
           res && res[:__dead]
         end
+
+        def resolve_type(type, value, path)
+          trace_payload = { context: context, type: type, object: value, path: path }
+          resolved_type = query.trace("resolve_type", trace_payload) do
+            query.resolve_type(type, value)
+          end
+
+          if schema.lazy?(resolved_type)
+            GraphQL::Execution::Lazy.new do
+              query.trace("resolve_type_lazy", trace_payload) do
+                schema.sync_lazy(resolved_type)
+              end
+            end
+          else
+            resolved_type
+          end
+        end
+
+        def authorized_new(type, value, context, path)
+          trace_payload = { context: context, type: type, object: value, path: path }
+
+          auth_val = context.query.trace("authorized", trace_payload) do
+            type.authorized_new(value, context)
+          end
+
+          if context.schema.lazy?(auth_val)
+            GraphQL::Execution::Lazy.new do
+              context.query.trace("authorized_lazy", trace_payload) do
+                context.schema.sync_lazy(auth_val)
+              end
+            end
+          else
+            auth_val
+          end
+        end
       end
     end
   end

data/lib/graphql/execution/interpreter.rb

@@ -17,17 +17,11 @@ module GraphQL
         runtime.final_value
       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)
-        end
+      def self.use(schema_class)
+        schema_class.interpreter = true
+        schema_class.query_execution_strategy(GraphQL::Execution::Interpreter)
+        schema_class.mutation_execution_strategy(GraphQL::Execution::Interpreter)
+        schema_class.subscription_execution_strategy(GraphQL::Execution::Interpreter)
       end
 
       def self.begin_multiplex(multiplex)

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/lookahead.rb

@@ -223,14 +223,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.schema.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.schema.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
@@ -366,10 +366,10 @@ module GraphQL
 
         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]
+          field_defn ||= if owner_type == schema.query.type_class && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
+            entry_point_field.type_class
           elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field.metadata[:type_class]
+            dynamic_field.type_class
           else
             nil
           end

data/lib/graphql/execution/multiplex.rb

@@ -44,9 +44,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]
@@ -95,6 +95,7 @@ module GraphQL
             query.result
           end
         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
@@ -173,6 +174,15 @@ 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 += if schema.using_ast_analysis?

data/lib/graphql/field.rb

@@ -2,123 +2,7 @@
 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,
@@ -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
@@ -315,6 +203,10 @@ module GraphQL
       }
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
     private
 
     def build_default_resolver

data/lib/graphql/filter.rb

@@ -33,7 +33,7 @@ module GraphQL
       end
 
       def self.build(onlies)
-        case onlies
+        case onlies.size
         when 0
           nil
         when 1

data/lib/graphql/function.rb

@@ -1,35 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # A reusable container for field logic, including arguments, resolve, return type, and documentation.
-  #
-  # Class-level values defined with the DSL will be inherited,
-  # so {GraphQL::Function}s can extend one another.
-  #
-  # It's OK to override the instance methods here in order to customize behavior of instances.
-  #
-  # @example A reusable GraphQL::Function attached as a field
-  #   class FindRecord < GraphQL::Function
-  #     attr_reader :type
-  #
-  #     def initialize(model:, type:)
-  #       @model = model
-  #       @type = type
-  #     end
-  #
-  #     argument :id, GraphQL::ID_TYPE
-  #
-  #     def call(obj, args, ctx)
-  #        @model.find(args.id)
-  #     end
-  #   end
-  #
-  #   QueryType = GraphQL::ObjectType.define do
-  #     name "Query"
-  #     field :post, function: FindRecord.new(model: Post, type: PostType)
-  #     field :comment, function: FindRecord.new(model: Comment, type: CommentType)
-  #   end
-  #
-  # @see {GraphQL::Schema::Resolver} for a replacement for `GraphQL::Function`
+  # @api deprecated
   class Function
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
     def arguments

data/lib/graphql/input_object_type.rb

@@ -1,28 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # {InputObjectType}s are key-value inputs for fields.
-  #
-  # Input objects have _arguments_ which are identical to {GraphQL::Field} arguments.
-  # They map names to types and support default values.
-  # Their input types can be any input types, including {InputObjectType}s.
-  #
-  # @example An input type with name and number
-  #   PlayerInput = GraphQL::InputObjectType.define do
-  #     name("Player")
-  #     argument :name, !types.String
-  #     argument :number, !types.Int
-  #   end
-  #
-  # In a `resolve` function, you can access the values by making nested lookups on `args`.
-  #
-  # @example Accessing input values in a resolve function
-  #   resolve ->(obj, args, ctx) {
-  #     args[:player][:name]    # => "Tony Gwynn"
-  #     args[:player][:number]  # => 19
-  #     args[:player].to_h      # { "name" => "Tony Gwynn", "number" => 19 }
-  #     # ...
-  #   }
-  #
+  # @api deprecated
   class InputObjectType < GraphQL::BaseType
     accepts_definitions(
       :arguments, :mutation,
@@ -136,7 +114,7 @@ module GraphQL
       # Items in the input that are unexpected
       input.each do |name, value|
         if visible_arguments_map[name].nil?
-          result.add_problem("Field is not defined on #{self.name}", [name])
+          result.add_problem("Field is not defined on #{self.graphql_name}", [name])
         end
       end