graphql 1.11.10 → 1.12.0

data/lib/graphql/schema/validator/length_validator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to enforce a `.length` restriction on incoming values. It works for both Strings and Lists.
+      #
+      # @example Allow no more than 10 IDs
+      #
+      #   argument :ids, [ID], required: true, validates: { length: { maximum: 10 } }
+      #
+      # @example Require three selections
+      #
+      #   argument :ice_cream_preferences, [ICE_CREAM_FLAVOR], required: true, validates: { length: { is: 3 } }
+      #
+      class LengthValidator < Validator
+        # @param maximum [Integer]
+        # @param too_long [String] Used when `maximum` is exceeded or value is greater than `within`
+        # @param minimum [Integer]
+        # @param too_short [String] Used with value is less than `minimum` or less than `within`
+        # @param is [Integer] Exact length requirement
+        # @param wrong_length [String] Used when value doesn't match `is`
+        # @param within [Range] An allowed range (becomes `minimum:` and `maximum:` under the hood)
+        # @param message [String]
+        def initialize(
+          maximum: nil, too_long: "%{validated} is too long (maximum is %{count})",
+          minimum: nil, too_short: "%{validated} is too short (minimum is %{count})",
+          is: nil, within: nil, wrong_length: "%{validated} is the wrong length (should be %{count})",
+          message: nil,
+          **default_options
+        )
+          if within && (minimum || maximum)
+            raise ArgumentError, "`length: { ... }` may include `within:` _or_ `minimum:`/`maximum:`, but not both"
+          end
+          # Under the hood, `within` is decomposed into `minimum` and `maximum`
+          @maximum = maximum || (within && within.max)
+          @too_long = message || too_long
+          @minimum = minimum || (within && within.min)
+          @too_short = message || too_short
+          @is = is
+          @wrong_length = message || wrong_length
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          if @maximum && value.length > @maximum
+            partial_format(@too_long, { count: @maximum })
+          elsif @minimum && value.length < @minimum
+            partial_format(@too_short, { count: @minimum })
+          elsif @is && value.length != @is
+            partial_format(@wrong_length, { count: @is })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator/numericality_validator.rb

@@ -0,0 +1,71 @@
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to assert numerical comparisons hold true for inputs.
+      #
+      # @example Require a number between 0 and 1
+      #
+      #   argument :batting_average, Float, required: true, validates: { numericality: { within: 0..1 } }
+      #
+      # @example Require the number 42
+      #
+      #   argument :the_answer, Integer, required: true, validates: { numericality: { equal_to: 42 } }
+      #
+      # @example Require a real number
+      #
+      #   argument :items_count, Integer, required: true, validates: { numericality: { greater_than_or_equal_to: 0 } }
+      #
+      class NumericalityValidator < Validator
+        # @param greater_than [Integer]
+        # @param greater_than_or_equal_to [Integer]
+        # @param less_than [Integer]
+        # @param less_than_or_equal_to [Integer]
+        # @param equal_to [Integer]
+        # @param other_than [Integer]
+        # @param odd [Boolean]
+        # @param even [Boolean]
+        # @param message [String] used for all validation failures
+        def initialize(
+            greater_than: nil, greater_than_or_equal_to: nil,
+            less_than: nil, less_than_or_equal_to: nil,
+            equal_to: nil, other_than: nil,
+            odd: nil, even: nil,
+            message: "%{validated} must be %{comparison} %{target}",
+            **default_options
+          )
+
+          @greater_than = greater_than
+          @greater_than_or_equal_to = greater_than_or_equal_to
+          @less_than = less_than
+          @less_than_or_equal_to = less_than_or_equal_to
+          @equal_to = equal_to
+          @other_than = other_than
+          @odd = odd
+          @even = even
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(object, context, value)
+          if @greater_than && value <= @greater_than
+            partial_format(@message, { comparison: "greater than", target: @greater_than })
+          elsif @greater_than_or_equal_to && value < @greater_than_or_equal_to
+            partial_format(@message, { comparison: "greater than or equal to", target: @greater_than_or_equal_to })
+          elsif @less_than && value >= @less_than
+            partial_format(@message, { comparison: "less than", target: @less_than })
+          elsif @less_than_or_equal_to && value > @less_than_or_equal_to
+            partial_format(@message, { comparison: "less than or equal to", target: @less_than_or_equal_to })
+          elsif @equal_to && value != @equal_to
+            partial_format(@message, { comparison: "equal to", target: @equal_to })
+          elsif @other_than && value == @other_than
+            partial_format(@message, { comparison: "something other than", target: @other_than })
+          elsif @even && !value.even?
+            (partial_format(@message, { comparison: "even", target: "" })).strip
+          elsif @odd && !value.odd?
+            (partial_format(@message, { comparison: "odd", target: "" })).strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator/required_validator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this validator to require _one_ of the named arguments to be present.
+      # Or, use Arrays of symbols to name a valid _set_ of arguments.
+      #
+      # (This is for specifying mutually exclusive sets of arguments.)
+      #
+      # @example Require exactly one of these arguments
+      #
+      #   field :update_amount, IngredientAmount, null: false do
+      #     argument :ingredient_id, ID, required: true
+      #     argument :cups, Integer, required: false
+      #     argument :tablespoons, Integer, required: false
+      #     argument :teaspoons, Integer, required: true
+      #     validates required: { one_of: [:cups, :tablespoons, :teaspoons] }
+      #   end
+      #
+      # @example Require one of these _sets_ of arguments
+      #
+      #  field :find_object, Node, null: true do
+      #    argument :node_id, ID, required: false
+      #    argument :object_type, String, required: false
+      #    argument :object_id, Integer, required: false
+      #    # either a global `node_id` or an `object_type`/`object_id` pair is required:
+      #    validates required: { one_of: [:node_id, [:object_type, :object_id]] }
+      #  end
+      #
+      class RequiredValidator < Validator
+        # @param one_of [Symbol, Array<Symbol>] An argument, or a list of arguments, that represents a valid set of inputs for this field
+        # @param message [String]
+        def initialize(one_of:, message: "%{validated} has the wrong arguments", **default_options)
+          @one_of = one_of
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          matched_conditions = 0
+
+          @one_of.each do |one_of_condition|
+            case one_of_condition
+            when Symbol
+              if value.key?(one_of_condition)
+                matched_conditions += 1
+              end
+            when Array
+              if one_of_condition.all? { |k| value.key?(k) }
+                matched_conditions += 1
+                break
+              end
+            else
+              raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
+            end
+          end
+
+          if matched_conditions == 1
+            nil # OK
+          else
+            @message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # The thing being validated
+      # @return [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>]
+      attr_reader :validated
+
+      # TODO should this implement `if:` and `unless:` ?
+      # @param validated [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>] The argument or argument owner this validator is attached to
+      # @param allow_blank [Boolean] if `true`, then objects that respond to `.blank?` and return true for `.blank?` will skip this validation
+      # @param allow_null [Boolean] if `true`, then incoming `null`s will skip this validation
+      def initialize(validated:, allow_blank: false, allow_null: false)
+        @validated = validated
+        @allow_blank = allow_blank
+        @allow_null = allow_null
+      end
+
+      # @param object [Object] The application object that this argument's field is being resolved for
+      # @param context [GraphQL::Query::Context]
+      # @param value [Object] The client-provided value for this argument (after parsing and coercing by the input type)
+      # @return [nil, Array<String>, String] Error message or messages to add
+      def validate(object, context, value)
+        raise GraphQL::RequiredImplementationMissingError, "Validator classes should implement #validate"
+      end
+
+      # This is called by the validation system and eventually calls {#validate}.
+      # @api private
+      def apply(object, context, value)
+        if value.nil?
+          if @allow_null
+            nil # skip this
+          else
+            "%{validated} can't be null"
+          end
+        elsif value.respond_to?(:blank?) && value.blank?
+          if @allow_blank
+            nil # skip this
+          else
+            "%{validated} can't be blank"
+          end
+        else
+          validate(object, context, value)
+        end
+      end
+
+      # This is like `String#%`, but it supports the case that only some of `string`'s
+      # values are present in `substitutions`
+      def partial_format(string, substitutions)
+        substitutions.each do |key, value|
+          sub_v = value.is_a?(String) ? value : value.to_s
+          string = string.gsub("%{#{key}}", sub_v)
+        end
+        string
+      end
+
+      # @param schema_member [GraphQL::Schema::Field, GraphQL::Schema::Argument, Class<GraphQL::Schema::InputObject>]
+      # @param validates_hash [Hash{Symbol => Hash}, Hash{Class => Hash} nil] A configuration passed as `validates:`
+      # @return [Array<Validator>]
+      def self.from_config(schema_member, validates_hash)
+        if validates_hash.nil? || validates_hash.empty?
+          EMPTY_ARRAY
+        else
+          validates_hash.map do |validator_name, options|
+            validator_class = case validator_name
+            when Class
+              validator_name
+            else
+              all_validators[validator_name] || raise(ArgumentError, "unknown validation: #{validator_name.inspect}")
+            end
+            validator_class.new(validated: schema_member, **options)
+          end
+        end
+      end
+
+      # Add `validator_class` to be initialized when `validates:` is given `name`.
+      # (It's initialized with whatever options are given by the key `name`).
+      # @param name [Symbol]
+      # @param validator_class [Class]
+      # @return [void]
+      def self.install(name, validator_class)
+        all_validators[name] = validator_class
+        nil
+      end
+
+      # Remove whatever validator class is {.install}ed at `name`, if there is one
+      # @param name [Symbol]
+      # @return [void]
+      def self.uninstall(name)
+        all_validators.delete(name)
+        nil
+      end
+
+      class << self
+        attr_accessor :all_validators
+      end
+
+      self.all_validators = {}
+
+      include Schema::FindInheritedValue::EmptyObjects
+
+      class ValidationFailedError < GraphQL::ExecutionError
+        attr_reader :errors
+
+        def initialize(errors:)
+          @errors = errors
+          super(errors.join(", "))
+        end
+      end
+
+      # @param validators [Array<Validator>]
+      # @param object [Object]
+      # @param context [Query::Context]
+      # @param value [Object]
+      # @return [void]
+      # @raises [ValidationFailedError]
+      def self.validate!(validators, object, context, value, as: nil)
+        # Assuming the default case is no errors, reduce allocations in that case.
+        # This will be replaced with a mutable array if we actually get any errors.
+        all_errors = EMPTY_ARRAY
+
+        validators.each do |validator|
+          validated = as || validator.validated
+          errors = validator.apply(object, context, value)
+          if errors &&
+            (errors.is_a?(Array) && errors != EMPTY_ARRAY) ||
+            (errors.is_a?(String))
+            if all_errors.frozen? # It's empty
+              all_errors = []
+            end
+            interpolation_vars = { validated: validated.graphql_name }
+            if errors.is_a?(String)
+              all_errors << (errors % interpolation_vars)
+            else
+              errors = errors.map { |e| e % interpolation_vars }
+              all_errors.concat(errors)
+            end
+          end
+        end
+
+        if all_errors.any?
+          raise ValidationFailedError.new(errors: all_errors)
+        end
+        nil
+      end
+    end
+  end
+end
+
+
+require "graphql/schema/validator/length_validator"
+GraphQL::Schema::Validator.install(:length, GraphQL::Schema::Validator::LengthValidator)
+require "graphql/schema/validator/numericality_validator"
+GraphQL::Schema::Validator.install(:numericality, GraphQL::Schema::Validator::NumericalityValidator)
+require "graphql/schema/validator/format_validator"
+GraphQL::Schema::Validator.install(:format, GraphQL::Schema::Validator::FormatValidator)
+require "graphql/schema/validator/inclusion_validator"
+GraphQL::Schema::Validator.install(:inclusion, GraphQL::Schema::Validator::InclusionValidator)
+require "graphql/schema/validator/exclusion_validator"
+GraphQL::Schema::Validator.install(:exclusion, GraphQL::Schema::Validator::ExclusionValidator)
+require "graphql/schema/validator/required_validator"
+GraphQL::Schema::Validator.install(:required, GraphQL::Schema::Validator::RequiredValidator)

data/lib/graphql/schema.rb

@@ -21,6 +21,7 @@ require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
+require "graphql/schema/validator"
 require "graphql/schema/member"
 require "graphql/schema/wrapper"
 require "graphql/schema/list"
@@ -40,6 +41,7 @@ require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
+require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
 require "graphql/schema/type_membership"
 
@@ -80,6 +82,7 @@ module GraphQL
     extend GraphQL::Schema::Member::AcceptsDefinition
     extend GraphQL::Schema::Member::HasAstNode
     include GraphQL::Define::InstanceDefinable
+    extend GraphQL::Define::InstanceDefinable::DeprecatedDefine
     extend GraphQL::Schema::FindInheritedValue
 
     class DuplicateTypeNamesError < GraphQL::Error
@@ -157,7 +160,7 @@ module GraphQL
 
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :error_bubbling,
       :raise_definition_error,
@@ -196,7 +199,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -281,11 +284,11 @@ module GraphQL
       @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
       @lazy_methods.set(GraphQL::Execution::Lazy, :value)
       @cursor_encoder = Base64Encoder
-      # Default to the built-in execution strategy:
+      # For schema instances, default to legacy runtime modules
       @analysis_engine = GraphQL::Analysis
-      @query_execution_strategy = self.class.default_execution_strategy
-      @mutation_execution_strategy = self.class.default_execution_strategy
-      @subscription_execution_strategy = self.class.default_execution_strategy
+      @query_execution_strategy = GraphQL::Execution::Execute
+      @mutation_execution_strategy = GraphQL::Execution::Execute
+      @subscription_execution_strategy = GraphQL::Execution::Execute
       @default_mask = GraphQL::Schema::NullMask
       @rebuilding_artifacts = false
       @context_class = GraphQL::Query::Context
@@ -300,12 +303,11 @@ module GraphQL
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
     def interpreter?
-      @interpreter
+      query_execution_strategy == GraphQL::Execution::Interpreter &&
+        mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+        subscription_execution_strategy == GraphQL::Execution::Interpreter
     end
 
-    # @api private
-    attr_writer :interpreter
-
     def inspect
       "#<#{self.class.name} ...>"
     end
@@ -366,11 +368,11 @@ module GraphQL
       validator_opts = { schema: self }
       rules && (validator_opts[:rules] = rules)
       validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
+      res = validator.validate(query, timeout: validate_timeout)
       res[:errors]
     end
 
-    def define(**kwargs, &block)
+    def deprecated_define(**kwargs, &block)
       super
       ensure_defined
       # Assert that all necessary configs are present:
@@ -709,7 +711,7 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
-    def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :error_handler, :rescues
 
 
     # Given this schema member, find the class-based definition object
@@ -787,9 +789,8 @@ module GraphQL
     # @param default_resolve [<#call(type, field, obj, args, ctx)>] A callable for handling field resolution
     # @param parser [Object] An object for handling definition string parsing (must respond to `parse`)
     # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
-    # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
     # @return [Class] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: nil, interpreter: true, parser: GraphQL.default_parser, using: {})
+    def self.from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
       if definition_or_path.end_with?(".graphql")
         GraphQL::Schema::BuildFromDefinition.from_definition_path(
@@ -797,7 +798,6 @@ module GraphQL
           default_resolve: default_resolve,
           parser: parser,
           using: using,
-          interpreter: interpreter,
         )
       else
         GraphQL::Schema::BuildFromDefinition.from_definition(
@@ -805,7 +805,6 @@ module GraphQL
           default_resolve: default_resolve,
           parser: parser,
           using: using,
-          interpreter: interpreter,
         )
       end
     end
@@ -951,7 +950,6 @@ module GraphQL
         schema_defn.mutation = mutation && mutation.graphql_definition
         schema_defn.subscription = subscription && subscription.graphql_definition
         schema_defn.validate_timeout = validate_timeout
-        schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
@@ -1120,15 +1118,14 @@ module GraphQL
             type.possible_types(context: context)
           else
             stored_possible_types = own_possible_types[type.graphql_name]
-            visible_possible_types = if stored_possible_types && type.kind.interface?
-              stored_possible_types.select do |possible_type|
-                # Use `.graphql_name` comparison to match legacy vs class-based types.
-                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
-                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
-              end
-            else
-              stored_possible_types
-            end
+            visible_possible_types = stored_possible_types.select do |possible_type|
+              next true unless type.kind.interface?
+              next true unless possible_type.kind.object?
+
+              # Use `.graphql_name` comparison to match legacy vs class-based types.
+              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+            end if stored_possible_types
             visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
@@ -1159,6 +1156,14 @@ module GraphQL
         end
       end
 
+      # @api private
+      # @see GraphQL::Dataloader
+      def dataloader_class
+        @dataloader_class || GraphQL::Dataloader::NullDataloader
+      end
+
+      attr_writer :dataloader_class
+
       def references_to(to_type = nil, from: nil)
         @own_references_to ||= Hash.new { |h, k| h[k] = [] }
         if to_type
@@ -1287,19 +1292,6 @@ module GraphQL
         end
       end
 
-      attr_writer :validate_max_errors
-
-      def validate_max_errors(new_validate_max_errors = nil)
-        if new_validate_max_errors
-          @validate_max_errors = new_validate_max_errors
-        elsif defined?(@validate_max_errors)
-          @validate_max_errors
-        else
-          find_inherited_value(:validate_max_errors)
-        end
-      end
-
-
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)
@@ -1315,7 +1307,7 @@ module GraphQL
       attr_writer :analysis_engine
 
       def analysis_engine
-        @analysis_engine || find_inherited_value(:analysis_engine, GraphQL::Analysis)
+        @analysis_engine || find_inherited_value(:analysis_engine, self.default_analysis_engine)
       end
 
       def using_ast_analysis?
@@ -1323,11 +1315,9 @@ module GraphQL
       end
 
       def interpreter?
-        if defined?(@interpreter)
-          @interpreter
-        else
-          find_inherited_value(:interpreter?, false)
-        end
+        query_execution_strategy == GraphQL::Execution::Interpreter &&
+          mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+          subscription_execution_strategy == GraphQL::Execution::Interpreter
       end
 
       attr_writer :interpreter
@@ -1411,7 +1401,15 @@ module GraphQL
         if superclass <= GraphQL::Schema
           superclass.default_execution_strategy
         else
-          @default_execution_strategy ||= GraphQL::Execution::Execute
+          @default_execution_strategy ||= GraphQL::Execution::Interpreter
+        end
+      end
+
+      def default_analysis_engine
+        if superclass <= GraphQL::Schema
+          superclass.default_analysis_engine
+        else
+          @default_analysis_engine ||= GraphQL::Analysis::AST
         end
       end
 
@@ -1565,6 +1563,10 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        if instrument_step == :field
+          warn "Field instrumentation (#{instrumenter.inspect}) will be removed in GraphQL-Ruby 2.0, please upgrade to field extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
+        end
+
         step = if instrument_step == :field && options[:after_built_ins]
           :field_after_built_ins
         else
@@ -1586,9 +1588,12 @@ module GraphQL
 
       # Attach a single directive to this schema
       # @param new_directive [Class]
+      # @return void
       def directive(new_directive)
-        add_type_and_traverse(new_directive, root: false)
-        own_directives[new_directive.graphql_name] = new_directive
+        own_directives[new_directive.graphql_name] ||= begin
+          add_type_and_traverse(new_directive, root: false)
+          new_directive
+        end
       end
 
       def default_directives
@@ -1620,6 +1625,7 @@ module GraphQL
 
       def middleware(new_middleware = nil)
         if new_middleware
+          warn "Middleware will be removed in GraphQL-Ruby 2.0, please upgrade to Field Extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
           own_middleware << new_middleware
         else
           # TODO make sure this is cached when running a query
@@ -1719,6 +1725,7 @@ module GraphQL
           else
             @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
             @lazy_methods.set(GraphQL::Execution::Lazy, :value)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load)
           end
         end
         @lazy_methods
@@ -1915,13 +1922,16 @@ module GraphQL
           end
         else
           own_types[type.graphql_name] = type
+          add_directives_from(type)
           if type.kind.fields?
             type.fields.each do |name, field|
               field_type = field.type.unwrap
               references_to(field_type, from: field)
               field_path = path + [name]
               add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              add_directives_from(field)
               field.arguments.each do |arg_name, arg|
+                add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
                 add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
@@ -1930,6 +1940,7 @@ module GraphQL
           end
           if type.kind.input_object?
             type.arguments.each do |arg_name, arg|
+              add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
               add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
@@ -1967,8 +1978,20 @@ module GraphQL
           end
         end
       end
+
+      def add_directives_from(owner)
+        owner.directives.each { |dir| directive(dir.class) }
+      end
     end
 
+    def dataloader_class
+      self.class.dataloader_class
+    end
+
+    # Install these here so that subclasses will also install it.
+    use(GraphQL::Execution::Errors)
+    use(GraphQL::Pagination::Connections)
+
     protected
 
     def rescues?

data/lib/graphql/static_validation/base_visitor.rb

@@ -205,9 +205,6 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
-        if @context.too_many_errors?
-          throw :too_many_validation_errors
-        end
         error.path ||= (path || @path.dup)
         context.errors << error
       end