graphql 1.13.18 → 2.0.0

data/lib/graphql/relay.rb

@@ -1,18 +1,3 @@
 # frozen_string_literal: true
 
-require 'graphql/relay/page_info'
-require 'graphql/relay/edge'
-require 'graphql/relay/edge_type'
-require 'graphql/relay/edges_instrumentation'
-require 'graphql/relay/base_connection'
-require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'
-require 'graphql/relay/relation_connection'
-require 'graphql/relay/mongo_relation_connection'
-require 'graphql/relay/global_id_resolve'
-require 'graphql/relay/mutation'
-require 'graphql/relay/node'
-require 'graphql/relay/connection_instrumentation'
-require 'graphql/relay/connection_resolve'
-require 'graphql/relay/connection_type'
-require 'graphql/relay/type_extensions'

data/lib/graphql/schema/addition.rb

@@ -136,14 +136,7 @@ module GraphQL
       end
 
       def add_type(type, owner:, late_types:, path:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
         end

data/lib/graphql/schema/argument.rb

@@ -2,8 +2,6 @@
 module GraphQL
   class Schema
     class Argument
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasDirectives
@@ -44,12 +42,11 @@ module GraphQL
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
-      # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
       # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -70,7 +67,6 @@ module GraphQL
         @prepare = prepare
         @ast_node = ast_node
         @from_resolver = from_resolver
-        @method_access = method_access
         self.deprecation_reason = deprecation_reason
 
         if directives
@@ -169,26 +165,6 @@ module GraphQL
         true
       end
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        argument = GraphQL::Argument.new
-        argument.name = @name
-        argument.type = -> { type }
-        argument.description = @description
-        argument.metadata[:type_class] = self
-        argument.as = @as
-        argument.ast_node = ast_node
-        argument.method_access = @method_access
-        if NO_DEFAULT != @default_value
-          argument.default_value = @default_value
-        end
-        if self.deprecation_reason
-          argument.deprecation_reason = self.deprecation_reason
-        end
-        argument
-      end
-
       def type=(new_type)
         validate_input_type(new_type)
         # This isn't true for LateBoundTypes, but we can assume those will

data/lib/graphql/schema/build_from_definition.rb

@@ -365,7 +365,6 @@ module GraphQL
               deprecation_reason: builder.build_deprecation_reason(argument_defn.directives),
               ast_node: argument_defn,
               camelize: false,
-              method_access: false,
               directives: prepare_directives(argument_defn, type_resolver),
               **default_value_kwargs
             )

data/lib/graphql/schema/directive.rb

@@ -8,7 +8,6 @@ module GraphQL
     # - {.resolve}: Wraps field resolution (so it should call `yield` to continue)
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
-      extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -55,26 +54,6 @@ module GraphQL
           default_directive
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          defn = GraphQL::Directive.new
-          defn.name = self.graphql_name
-          defn.description = self.description
-          defn.locations = self.locations
-          defn.default_directive = self.default_directive
-          defn.ast_node = ast_node
-          defn.metadata[:type_class] = self
-          all_argument_definitions.each do |arg_defn|
-            arg_graphql = arg_defn.to_graphql(silence_deprecation_warning: true)
-            defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-          end
-          # Make a reference to a classic-style Arguments class
-          defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(defn)
-
-          defn
-        end
-
         # If false, this part of the query won't be evaluated
         def include?(_object, arguments, context)
           static_include?(arguments, context)

data/lib/graphql/schema/enum.rb

@@ -20,10 +20,9 @@ module GraphQL
   #   end
   class Schema
     class Enum < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
-      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      class UnresolvedValueError < GraphQL::Error
         def initialize(value:, enum:, context:)
           fix_message = ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
           message = if (cp = context[:current_path]) && (cf = context[:current_field])
@@ -108,22 +107,6 @@ module GraphQL
           enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        # @return [GraphQL::EnumType]
-        def to_graphql
-          enum_type = GraphQL::EnumType.new
-          enum_type.name = graphql_name
-          enum_type.description = description
-          enum_type.introspection = introspection
-          enum_type.ast_node = ast_node
-          values.each do |name, val|
-            enum_type.add_value(val.deprecated_to_graphql)
-          end
-          enum_type.metadata[:type_class] = self
-          enum_type
-        end
-
         # @return [Class] for handling `value(...)` inputs and building `GraphQL::Enum::EnumValue`s out of them
         def enum_value_class(new_enum_value_class = nil)
           if new_enum_value_class
@@ -139,8 +122,9 @@ module GraphQL
           GraphQL::TypeKinds::ENUM
         end
 
-        def validate_non_null_input(value_name, ctx, max_errors: nil)
+        def validate_non_null_input(value_name, ctx)
           result = GraphQL::Query::InputValidationResult.new
+
           allowed_values = ctx.warden.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 

data/lib/graphql/schema/enum_value.rb

@@ -13,12 +13,6 @@ module GraphQL
     #       # arguments to `value(...)` in Enum classes are passed here
     #       super
     #     end
-    #
-    #     def to_graphql
-    #       enum_value = super
-    #       # customize the derived GraphQL::EnumValue here
-    #       enum_value
-    #     end
     #   end
     #
     #   class BaseEnum < GraphQL::Schema::Enum
@@ -26,8 +20,6 @@ module GraphQL
     #     enum_value_class CustomEnumValue
     #   end
     class EnumValue < GraphQL::Schema::Member
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasDirectives
@@ -73,20 +65,6 @@ module GraphQL
         @value
       end
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      # @return [GraphQL::EnumType::EnumValue] A runtime-ready object derived from this object
-      def to_graphql
-        enum_value = GraphQL::EnumType::EnumValue.new
-        enum_value.name = @graphql_name
-        enum_value.description = @description
-        enum_value.value = @value
-        enum_value.deprecation_reason = self.deprecation_reason
-        enum_value.metadata[:type_class] = self
-        enum_value.ast_node = ast_node
-        enum_value
-      end
-
       def inspect
         "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}>"
       end

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
@@ -84,16 +82,6 @@ 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)
@@ -106,9 +94,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})"
@@ -176,8 +161,6 @@ module GraphQL
 
       # @return Boolean
       attr_reader :relay_node_field
-      # @return Boolean
-      attr_reader :relay_nodes_field
 
       # @return [Boolean] Should we warn if this field's name conflicts with a built-in method?
       def method_conflict_warning?
@@ -214,8 +197,7 @@ 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, 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, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -258,10 +240,6 @@ module GraphQL
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
         method_name = method || hash_key || name_s
         @dig_keys = dig
-        if hash_key
-          @hash_key = hash_key
-        end
-
         resolver_method ||= name_s.to_sym
 
         @method_str = -method_name.to_s
@@ -283,7 +261,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
@@ -477,13 +454,7 @@ module GraphQL
           case defined_complexity
           when Proc
             arguments = query.arguments_for(nodes.first, self)
-            if arguments.is_a?(GraphQL::ExecutionError)
-              return child_complexity
-            elsif arguments.respond_to?(:keyword_arguments)
-              arguments = arguments.keyword_arguments
-            end
-
-            defined_complexity.call(query.context, arguments, child_complexity)
+            defined_complexity.call(query.context, arguments.keyword_arguments, child_complexity)
           when Numeric
             defined_complexity + child_complexity
           else
@@ -520,82 +491,6 @@ module GraphQL
       # @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
-      end
-
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 
@@ -678,37 +573,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
@@ -741,7 +605,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)
@@ -754,63 +618,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
@@ -826,7 +633,7 @@ module GraphQL
             # Find a way to resolve this field, checking:
             #
             # - A method on the type instance;
-            # - Hash keys, if the wrapped object is a hash or responds to `#[]`
+            # - Hash keys, if the wrapped object is a hash;
             # - A method on the wrapped object;
             # - Or, raise not implemented.
             #
@@ -848,8 +655,6 @@ module GraphQL
               else
                 inner_object[@method_str]
               end
-            elsif defined?(@hash_key) && obj.object.respond_to?(:[])
-              obj.object[@hash_key]
             elsif obj.object.respond_to?(@method_sym)
               method_to_call = @method_sym
               method_receiver = obj.object

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
@@ -83,7 +59,6 @@ module GraphQL
         # Authorize each argument (but this doesn't apply if `prepare` is implemented):
         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
@@ -173,8 +126,9 @@ module GraphQL
         # @api private
         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, max_errors: nil)
+        def validate_non_null_input(input, ctx)
           result = GraphQL::Query::InputValidationResult.new
+
           warden = ctx.warden
 
           if input.is_a?(Array)