graphql 1.13.8 → 2.0.1

data/lib/graphql/schema/field.rb

@@ -5,8 +5,6 @@ require "graphql/schema/field/scope_extension"
 module GraphQL
   class Schema
     class Field
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
@@ -31,7 +29,13 @@ module GraphQL
       attr_reader :method_str
 
       # @return [Symbol] The method on the type to look up
-      attr_reader :resolver_method
+      def resolver_method
+        if @resolver_class
+          @resolver_class.resolver_method
+        else
+          @resolver_method
+        end
+      end
 
       # @return [Class] The thing this field was defined on (type, mutation, resolver)
       attr_accessor :owner
@@ -70,7 +74,10 @@ module GraphQL
       attr_reader :trace
 
       # @return [String, nil]
-      attr_accessor :subscription_scope
+      def subscription_scope
+        @subscription_scope || (@resolver_class.respond_to?(:subscription_scope) ? @resolver_class.subscription_scope : nil)
+      end
+      attr_writer :subscription_scope
 
       # Create a field instance from a list of arguments, keyword arguments, and a block.
       #
@@ -84,21 +91,9 @@ module GraphQL
       # @return [GraphQL::Schema:Field] an instance of `self
       # @see {.initialize} for other options
       def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
-        if kwargs[:field]
-          if kwargs[:field].is_a?(GraphQL::Field) && kwargs[:field] == GraphQL::Types::Relay::NodeField.graphql_definition
-            GraphQL::Deprecation.warn("Legacy-style `GraphQL::Relay::Node.field` is being added to a class-based type. See `GraphQL::Types::Relay::NodeField` for a replacement.")
-            return GraphQL::Types::Relay::NodeField
-          elsif kwargs[:field].is_a?(GraphQL::Field) && kwargs[:field] == GraphQL::Types::Relay::NodesField.graphql_definition
-            GraphQL::Deprecation.warn("Legacy-style `GraphQL::Relay::Node.plural_field` is being added to a class-based type. See `GraphQL::Types::Relay::NodesField` for a replacement.")
-            return GraphQL::Types::Relay::NodesField
-          end
-        end
-
-        if (parent_config = resolver || mutation || subscription)
-          # Get the parent config, merge in local overrides
-          kwargs = parent_config.field_options.merge(kwargs)
+        if (resolver_class = resolver || mutation || subscription)
           # Add a reference to that parent class
-          kwargs[:resolver_class] = parent_config
+          kwargs[:resolver_class] = resolver_class
         end
 
         if name
@@ -106,9 +101,6 @@ module GraphQL
         end
 
         if !type.nil?
-          if type.is_a?(GraphQL::Field)
-            raise ArgumentError, "A GraphQL::Field was passed as the second argument, use the `field:` keyword for this instead."
-          end
           if desc
             if kwargs[:description]
               raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{kwargs[:description].inspect})"
@@ -116,8 +108,8 @@ module GraphQL
 
             kwargs[:description] = desc
             kwargs[:type] = type
-          elsif (kwargs[:field] || kwargs[:function] || resolver || mutation) && type.is_a?(String)
-            # The return type should be copied from `field` or `function`, and the second positional argument is the description
+          elsif (resolver || mutation) && type.is_a?(String)
+            # The return type should be copied from the resolver, and the second positional argument is the description
             kwargs[:description] = type
           else
             kwargs[:type] = type
@@ -134,8 +126,8 @@ module GraphQL
       def connection?
         if @connection.nil?
           # Provide default based on type name
-          return_type_name = if (contains_type = @field || @function)
-            Member::BuildType.to_type_name(contains_type.type)
+          return_type_name = if @resolver_class && @resolver_class.type
+            Member::BuildType.to_type_name(@resolver_class.type)
           elsif @return_type_expr
             Member::BuildType.to_type_name(@return_type_expr)
           else
@@ -196,9 +188,6 @@ module GraphQL
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
       # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
-      # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
-      # @param field [GraphQL::Field, GraphQL::Schema::Field] **deprecated** for compatibility with <1.8.0
-      # @param function [GraphQL::Function] **deprecated** for compatibility with <1.8.0
       # @param resolver_class [Class] (Private) A {Schema::Resolver} which this field was derived from. Use `resolver:` to create a field with a resolver.
       # @param arguments [{String=>GraphQL::Schema::Argument, Hash}] Arguments for this field (may be added in the block, also)
       # @param camelize [Boolean] If true, the field name will be camelized when building the schema
@@ -212,31 +201,20 @@ module GraphQL
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
-      # @param legacy_edge_class [Class, nil] (DEPRECATED) If present, pass this along to the legacy field definition
-      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, legacy_edge_class: nil, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
-        if !(field || function || resolver_class)
+        if !(resolver_class)
           if type.nil?
             raise ArgumentError, "missing second `type` argument or keyword `type:`"
           end
         end
-        if (field || function || resolve) && extras.any?
-          raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
-        end
         @original_name = name
         name_s = -name.to_s
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
         @description = description
-        if field.is_a?(GraphQL::Schema::Field)
-          raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
-        else
-          @field = field
-        end
-        @function = function
-        @resolve = resolve
         self.deprecation_reason = deprecation_reason
 
         if method && hash_key && dig
@@ -269,7 +247,9 @@ module GraphQL
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
         @introspection = introspection
         @extras = extras
-        @broadcastable = broadcastable
+        if !broadcastable.nil?
+          @broadcastable = broadcastable
+        end
         @resolver_class = resolver_class
         @scope = scope
         @trace = trace
@@ -277,7 +257,6 @@ module GraphQL
         @relay_nodes_field = relay_nodes_field
         @ast_node = ast_node
         @method_conflict_warning = method_conflict_warning
-        @legacy_edge_class = legacy_edge_class
 
         arguments.each do |name, arg|
           case arg
@@ -314,6 +293,10 @@ module GraphQL
           self.extensions(extensions)
         end
 
+        if resolver_class && resolver_class.extensions.any?
+          self.extensions(resolver_class.extensions)
+        end
+
         if directives.any?
           directives.each do |(dir_class, options)|
             self.directive(dir_class, **options)
@@ -338,7 +321,13 @@ module GraphQL
       # @return [Boolean, nil]
       # @see GraphQL::Subscriptions::BroadcastAnalyzer
       def broadcastable?
-        @broadcastable
+        if defined?(@broadcastable)
+          @broadcastable
+        elsif @resolver_class
+          @resolver_class.broadcastable?
+        else
+          nil
+        end
       end
 
       # @param text [String]
@@ -346,6 +335,8 @@ module GraphQL
       def description(text = nil)
         if text
           @description = text
+        elsif @resolver_class
+          @description || @resolver_class.description
         else
           @description
         end
@@ -411,7 +402,12 @@ module GraphQL
       def extras(new_extras = nil)
         if new_extras.nil?
           # Read the value
-          @extras
+          field_extras = @extras
+          if @resolver_class && @resolver_class.extras.any?
+            field_extras + @resolver_class.extras
+          else
+            field_extras
+          end
         else
           if @extras.frozen?
             @extras = @extras.dup
@@ -428,11 +424,14 @@ module GraphQL
         elsif connection?
           arguments = query.arguments_for(nodes.first, self)
           max_possible_page_size = nil
-          if arguments[:first]
-            max_possible_page_size = arguments[:first]
-          end
-          if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
-            max_possible_page_size = arguments[:last]
+          if arguments.respond_to?(:[]) # It might have been an error
+            if arguments[:first]
+              max_possible_page_size = arguments[:first]
+            end
+
+            if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
+              max_possible_page_size = arguments[:last]
+            end
           end
 
           if max_possible_page_size.nil?
@@ -491,7 +490,11 @@ module GraphQL
         when Numeric
           @complexity = new_complexity
         when nil
-          @complexity
+          if @resolver_class
+            @complexity || @resolver_class.complexity || 1
+          else
+            @complexity || 1
+          end
         else
           raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
         end
@@ -499,105 +502,31 @@ module GraphQL
 
       # @return [Boolean] True if this field's {#max_page_size} should override the schema default.
       def has_max_page_size?
-        @has_max_page_size
+        @has_max_page_size || (@resolver_class && @resolver_class.has_max_page_size?)
       end
 
       # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
-      attr_reader :max_page_size
-
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      # @return [GraphQL::Field]
-      def to_graphql
-        field_defn = if @field
-          @field.dup
-        elsif @function
-          GraphQL::Function.build_field(@function)
-        else
-          GraphQL::Field.new
-        end
-
-        field_defn.name = @name
-        if @return_type_expr
-          field_defn.type = -> { type }
-        end
-
-        if @description
-          field_defn.description = @description
-        end
-
-        if self.deprecation_reason
-          field_defn.deprecation_reason = self.deprecation_reason
-        end
-
-        if @resolver_class
-          if @resolver_class < GraphQL::Schema::Mutation
-            field_defn.mutation = @resolver_class
-          end
-          field_defn.metadata[:resolver] = @resolver_class
-        end
-
-        if !@trace.nil?
-          field_defn.trace = @trace
-        end
-
-        if @relay_node_field
-          field_defn.relay_node_field = @relay_node_field
-        end
-
-        if @relay_nodes_field
-          field_defn.relay_nodes_field = @relay_nodes_field
-        end
-
-        if @legacy_edge_class
-          field_defn.edge_class = @legacy_edge_class
-        end
-
-        field_defn.resolve = self.method(:resolve_field)
-        field_defn.connection = connection?
-        field_defn.connection_max_page_size = max_page_size
-        field_defn.introspection = @introspection
-        field_defn.complexity = @complexity
-        field_defn.subscription_scope = @subscription_scope
-        field_defn.ast_node = ast_node
-
-        all_argument_definitions.each do |defn|
-          arg_graphql = defn.deprecated_to_graphql
-          field_defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-        end
-
-        # Support a passed-in proc, one way or another
-        @resolve_proc = if @resolve
-          @resolve
-        elsif @function
-          @function
-        elsif @field
-          @field.resolve_proc
-        end
-
-        # Ok, `self` isn't a class, but this is for consistency with the classes
-        field_defn.metadata[:type_class] = self
-        field_defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(field_defn)
-        field_defn
+      def max_page_size
+        @max_page_size || (@resolver_class && @resolver_class.max_page_size)
       end
 
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 
       def type
-        @type ||= if @function
-          Member::BuildType.parse_type(@function.type, null: false)
-        elsif @field
-          Member::BuildType.parse_type(@field.type, null: false)
-        elsif @return_type_expr.nil?
-          # Not enough info to determine type
-          message = "Can't determine the return type for #{self.path}"
-          if @resolver_class
-            message += " (it has `resolver: #{@resolver_class}`, consider configuration a `type ...` for that class)"
-          end
-          raise MissingReturnTypeError, message
+        if @resolver_class && (t = @resolver_class.type)
+          t
         else
-          Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          @type ||= if @return_type_expr.nil?
+            # Not enough info to determine type
+            message = "Can't determine the return type for #{self.path}"
+            if @resolver_class
+              message += " (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
+            end
+            raise MissingReturnTypeError, message
+          else
+            Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          end
         end
       rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up
@@ -663,37 +592,6 @@ module GraphQL
         end
       end
 
-      # Implement {GraphQL::Field}'s resolve API.
-      #
-      # Eventually, we might hook up field instances to execution in another way. TBD.
-      # @see #resolve for how the interpreter hooks up to it
-      def resolve_field(obj, args, ctx)
-        ctx.schema.after_lazy(obj) do |after_obj|
-          # First, apply auth ...
-          query_ctx = ctx.query.context
-          # Some legacy fields can have `nil` here, not exactly sure why.
-          # @see https://github.com/rmosolgo/graphql-ruby/issues/1990 before removing
-          inner_obj = after_obj && after_obj.object
-          ctx.schema.after_lazy(to_ruby_args(after_obj, args, ctx)) do |ruby_args|
-            if authorized?(inner_obj, ruby_args, query_ctx)
-              # Then if it passed, resolve the field
-              if @resolve_proc
-                # Might be nil, still want to call the func in that case
-                with_extensions(inner_obj, ruby_args, query_ctx) do |extended_obj, extended_args|
-                  # Pass the GraphQL args here for compatibility:
-                  @resolve_proc.call(extended_obj, args, ctx)
-                end
-              else
-                public_send_field(after_obj, ruby_args, query_ctx)
-              end
-            else
-              err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
-              query_ctx.schema.unauthorized_field(err)
-            end
-          end
-        end
-      end
-
       # This method is called by the interpreter for each field.
       # You can extend it in your base field classes.
       # @param object [GraphQL::Schema::Object] An instance of some type class, wrapping an application object
@@ -726,7 +624,7 @@ module GraphQL
         err
       end
 
-      # @param ctx [GraphQL::Query::Context::FieldResolutionContext]
+      # @param ctx [GraphQL::Query::Context]
       def fetch_extra(extra_name, ctx)
         if extra_name != :path && extra_name != :ast_node && respond_to?(extra_name)
           self.public_send(extra_name)
@@ -739,63 +637,6 @@ module GraphQL
 
       private
 
-      NO_ARGS = {}.freeze
-
-      # Convert a GraphQL arguments instance into a Ruby-style hash.
-      #
-      # @param obj [GraphQL::Schema::Object] The object where this field is being resolved
-      # @param graphql_args [GraphQL::Query::Arguments]
-      # @param field_ctx [GraphQL::Query::Context::FieldResolutionContext]
-      # @return [Hash<Symbol => Any>]
-      def to_ruby_args(obj, graphql_args, field_ctx)
-        if graphql_args.any? || @extras.any?
-          # Splat the GraphQL::Arguments to Ruby keyword arguments
-          ruby_kwargs = graphql_args.to_kwargs
-          maybe_lazies = []
-          # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
-          arguments(field_ctx).each do |name, arg_defn|
-            ruby_kwargs_key = arg_defn.keyword
-
-            if ruby_kwargs.key?(ruby_kwargs_key)
-              loads = arg_defn.loads
-              value = ruby_kwargs[ruby_kwargs_key]
-              loaded_value = if loads && !arg_defn.from_resolver?
-                if arg_defn.type.list?
-                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
-                  field_ctx.schema.after_any_lazies(loaded_values) { |result| result }
-                else
-                  load_application_object(arg_defn, loads, value, field_ctx.query.context)
-                end
-              elsif arg_defn.type.list? && value.is_a?(Array)
-                field_ctx.schema.after_any_lazies(value, &:itself)
-              else
-                value
-              end
-
-              maybe_lazies << field_ctx.schema.after_lazy(loaded_value) do |loaded_value|
-                prepared_value = if arg_defn.prepare
-                  arg_defn.prepare_value(obj, loaded_value)
-                else
-                  loaded_value
-                end
-
-                ruby_kwargs[ruby_kwargs_key] = prepared_value
-              end
-            end
-          end
-
-          @extras.each do |extra_arg|
-            ruby_kwargs[extra_arg] = fetch_extra(extra_arg, field_ctx)
-          end
-
-          field_ctx.schema.after_any_lazies(maybe_lazies) do
-            ruby_kwargs
-          end
-        else
-          NO_ARGS
-        end
-      end
-
       def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
         with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
           begin
@@ -815,14 +656,14 @@ module GraphQL
             # - A method on the wrapped object;
             # - Or, raise not implemented.
             #
-            if obj.respond_to?(@resolver_method)
-              method_to_call = @resolver_method
+            if obj.respond_to?(resolver_method)
+              method_to_call = resolver_method
               method_receiver = obj
               # Call the method with kwargs, if there are any
               if ruby_kwargs.any?
-                obj.public_send(@resolver_method, **ruby_kwargs)
+                obj.public_send(resolver_method, **ruby_kwargs)
               else
-                obj.public_send(@resolver_method)
+                obj.public_send(resolver_method)
               end
             elsif obj.object.is_a?(Hash)
               inner_object = obj.object
@@ -845,7 +686,7 @@ module GraphQL
               raise <<-ERR
             Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
-            - `#{obj.class}##{@resolver_method}`, which did not exist
+            - `#{obj.class}##{resolver_method}`, which did not exist
             - `#{obj.object.class}##{@method_sym}`, which did not exist
             - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
 

data/lib/graphql/schema/input_object.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class InputObject < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
@@ -13,49 +12,28 @@ module GraphQL
 
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
-      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
+      # @return [GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
       def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
 
-      def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
+      def initialize(arguments, ruby_kwargs:, context:, defaults_used:)
         @context = context
-        if ruby_kwargs
-          @ruby_style_hash = ruby_kwargs
-          @arguments = arguments
-        else
-          @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used)
-          # Symbolized, underscored hash:
-          @ruby_style_hash = @arguments.to_kwargs
-        end
+        @ruby_style_hash = ruby_kwargs
+        @arguments = arguments
         # Apply prepares, not great to have it duplicated here.
-        maybe_lazies = []
         self.class.arguments(context).each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
-
           if @ruby_style_hash.key?(ruby_kwargs_key)
-            loads = arg_defn.loads
-            # Resolvers do this loading themselves;
-            # With the interpreter, it's done during `coerce_arguments`
-            if loads && !arg_defn.from_resolver? && !context.interpreter?
-              value = @ruby_style_hash[ruby_kwargs_key]
-              loaded_value = arg_defn.load_and_authorize_value(self, value, context)
-              maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
-                overwrite_argument(ruby_kwargs_key, loaded_value)
-              end
-            end
-
             # Weirdly, procs are applied during coercion, but not methods.
             # Probably because these methods require a `self`.
-            if arg_defn.prepare.is_a?(Symbol) || context.nil? || !context.interpreter?
+            if arg_defn.prepare.is_a?(Symbol) || context.nil?
               prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
               overwrite_argument(ruby_kwargs_key, prepared_value)
             end
           end
         end
-
-        @maybe_lazies = maybe_lazies
       end
 
       def to_h
@@ -68,12 +46,10 @@ module GraphQL
 
       def prepare
         if @context
-          @context.schema.after_any_lazies(@maybe_lazies) do
-            object = @context[:current_object]
-            # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
-            Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
-            self
-          end
+          object = @context[:current_object]
+          # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+          Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
+          self
         else
           self
         end
@@ -81,9 +57,8 @@ module GraphQL
 
       def self.authorized?(obj, value, ctx)
         # Authorize each argument (but this doesn't apply if `prepare` is implemented):
-        if value.is_a?(InputObject)
+        if value.respond_to?(:key?)
           arguments(ctx).each do |_name, input_obj_arg|
-            input_obj_arg = input_obj_arg.type_class
             if value.key?(input_obj_arg.keyword) &&
               !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
               return false
@@ -132,9 +107,6 @@ module GraphQL
       end
 
       class << self
-        # @return [Class<GraphQL::Arguments>]
-        attr_accessor :arguments_class
-
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
@@ -147,25 +119,6 @@ module GraphQL
           argument_defn
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::InputObjectType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.metadata[:type_class] = self
-          type_defn.mutation = mutation
-          type_defn.ast_node = ast_node
-          all_argument_definitions.each do |arg|
-            type_defn.arguments[arg.graphql_definition(silence_deprecation_warning: true).name] = arg.graphql_definition(silence_deprecation_warning: true) # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-          end
-          # Make a reference to a classic-style Arguments class
-          self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)
-          # But use this InputObject class at runtime
-          type_defn.arguments_class = self
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::INPUT_OBJECT
         end
@@ -174,19 +127,15 @@ module GraphQL
         INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
 
         def validate_non_null_input(input, ctx)
-          result = GraphQL::Query::InputValidationResult.new
-
           warden = ctx.warden
 
           if input.is_a?(Array)
-            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-            return result
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
           if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
             # We're not sure it'll act like a hash, so reject it:
-            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-            return result
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
           # Inject missing required arguments
@@ -198,18 +147,22 @@ module GraphQL
             m
           end
 
-
+          result = nil
           [input, missing_required_inputs].each do |args_to_validate|
             args_to_validate.each do |argument_name, value|
               argument = warden.get_argument(self, argument_name)
               # Items in the input that are unexpected
-              unless argument
+              if argument.nil?
+                result ||= Query::InputValidationResult.new
                 result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-                next
+              else
+                # Items in the input that are expected, but have invalid values
+                argument_result = argument.type.validate_input(value, ctx)
+                result ||= Query::InputValidationResult.new
+                if !argument_result.valid?
+                  result.merge_result!(argument_name, argument_result)
+                end
               end
-              # Items in the input that are expected, but have invalid values
-              argument_result = argument.type.validate_input(value, ctx)
-              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
             end
           end