graphql 1.13.25 → 2.0.0

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
@@ -229,10 +211,8 @@ module GraphQL
         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)
-        NameValidator.validate!(@name)
         @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."
@@ -260,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
@@ -285,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
@@ -479,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
@@ -522,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
 
@@ -652,64 +545,31 @@ module GraphQL
             arg_values = args
             using_arg_values = false
           end
-          if args.size > 0
-            args = context.warden.arguments(self)
-            args.each do |arg|
-              arg_key = arg.keyword
-              if arg_values.key?(arg_key)
-                arg_value = arg_values[arg_key]
-                if using_arg_values
-                  if arg_value.default_used?
-                    # pass -- no auth required for default used
-                    next
-                  else
-                    application_arg_value = arg_value.value
-                    if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
-                      application_arg_value.keyword_arguments
-                    end
-                  end
+          # Faster than `.any?`
+          arguments(context).each_value do |arg|
+            arg_key = arg.keyword
+            if arg_values.key?(arg_key)
+              arg_value = arg_values[arg_key]
+              if using_arg_values
+                if arg_value.default_used?
+                  # pass -- no auth required for default used
+                  next
                 else
-                  application_arg_value = arg_value
-                end
-
-                if !arg.authorized?(object, application_arg_value, context)
-                  return false
+                  application_arg_value = arg_value.value
+                  if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
+                    application_arg_value.keyword_arguments
+                  end
                 end
+              else
+                application_arg_value = arg_value
               end
-            end
-          end
-          true
-        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)
+              if !arg.authorized?(object, application_arg_value, context)
+                return false
               end
-            else
-              err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
-              query_ctx.schema.unauthorized_field(err)
             end
           end
+          true
         end
       end
 
@@ -745,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)
@@ -758,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
@@ -830,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.
             #
@@ -852,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,35 +107,18 @@ 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
-          define_accessor_method(argument_defn.keyword)
+          method_name = argument_defn.keyword
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
           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
@@ -168,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)
@@ -248,13 +207,6 @@ module GraphQL
 
           result
         end
-
-        private
-
-        def define_accessor_method(method_name)
-          define_method(method_name) { self[method_name] }
-          alias_method(method_name, method_name)
-        end
       end
 
       private

data/lib/graphql/schema/interface.rb

@@ -4,8 +4,6 @@ module GraphQL
     module Interface
       include GraphQL::Schema::Member::GraphQLTypeNames
       module DefinitionMethods
-        include GraphQL::Schema::Member::CachedGraphQLDefinition
-        include GraphQL::Relay::TypeExtensions
         include GraphQL::Schema::Member::BaseDSLMethods
         # ConfigurationExtension's responsibilities are in `def included` below
         include GraphQL::Schema::Member::TypeSystemHelpers
@@ -81,11 +79,7 @@ module GraphQL
             end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
-            backtrace_line = caller_locations(0, 10).find do |location|
-              location.base_label == "implements" &&
-                location.path.end_with?("schema/member/has_interfaces.rb")
-            end
-
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end
@@ -104,34 +98,11 @@ module GraphQL
           end
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::InterfaceType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.orphan_types = orphan_types
-          type_defn.type_membership_class = self.type_membership_class
-          type_defn.ast_node = ast_node
-          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.graphql_definition(silence_deprecation_warning: true)
-            type_defn.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-          end
-          type_defn.metadata[:type_class] = self
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::INTERFACE
         end
       end
 
-      # Extend this _after_ `DefinitionMethods` is defined, so it will be used
-      extend GraphQL::Schema::Member::AcceptsDefinition
-
       extend DefinitionMethods
 
       def unwrap

data/lib/graphql/schema/introspection_system.rb

@@ -89,9 +89,9 @@ module GraphQL
         case late_bound_type
         when GraphQL::Schema::LateBoundType
           @schema.get_type(late_bound_type.name)
-        when GraphQL::Schema::List, GraphQL::ListType
+        when GraphQL::Schema::List
           resolve_late_binding(late_bound_type.of_type).to_list_type
-        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+        when GraphQL::Schema::NonNull
           resolve_late_binding(late_bound_type.of_type).to_non_null_type
         when Module
           # It's a normal type -- no change required
@@ -103,12 +103,7 @@ module GraphQL
 
       def load_constant(class_name)
         const = @custom_namespace.const_get(class_name)
-        if @class_based
-          dup_type_class(const)
-        else
-          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.deprecated_to_graphql
-        end
+        dup_type_class(const)
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
         dup_type_class(@built_in_namespace.const_get(class_name))

data/lib/graphql/schema/late_bound_type.rb

@@ -16,11 +16,11 @@ module GraphQL
       end
 
       def to_non_null_type
-        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
       end
 
       def to_list_type
-        @to_list_type ||= GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::Schema::List.new(self)
       end
 
       def inspect

data/lib/graphql/schema/list.rb

@@ -8,12 +8,6 @@ module GraphQL
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
-      end
-
       # @return [GraphQL::TypeKinds::LIST]
       def kind
         GraphQL::TypeKinds::LIST
@@ -51,24 +45,15 @@ module GraphQL
         end
       end
 
-      def validate_non_null_input(value, ctx, max_errors: nil)
+      def validate_non_null_input(value, ctx)
         result = GraphQL::Query::InputValidationResult.new
         ensure_array(value).each_with_index do |item, index|
           item_result = of_type.validate_input(item, ctx)
-          unless item_result.valid?
-            if max_errors
-              if max_errors == 0
-                add_max_errros_reached_message(result)
-                break
-              end
-
-              max_errors -= 1
-            end
-
+          if !item_result.valid?
             result.merge_result!(index, item_result)
           end
         end
-        result.valid? ? nil : result
+        result
       end
 
       private
@@ -81,12 +66,6 @@ module GraphQL
           [value]
         end
       end
-
-      def add_max_errros_reached_message(result)
-        message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
-        item_result = GraphQL::Query::InputValidationResult.from_problem(message)
-        result.merge_result!(nil, item_result)
-      end
     end
   end
 end

data/lib/graphql/schema/loader.rb

@@ -202,7 +202,6 @@ module GraphQL
               description: arg["description"],
               deprecation_reason: arg["deprecationReason"],
               required: false,
-              method_access: false,
               camelize: false,
             }