Support custom validators on directives

Author: rmosolgo

lib/graphql/execution/interpreter/runtime.rb

@@ -826,6 +826,13 @@ def run_directive(method_name, object, directives, idx, &block)
           else
             dir_defn = @schema_directives.fetch(dir_node.name)
             raw_dir_args = arguments(nil, dir_defn, dir_node)
+            if !raw_dir_args.is_a?(GraphQL::ExecutionError)
+              begin
+                dir_defn.validate!(raw_dir_args, context)
+              rescue GraphQL::ExecutionError => err
+                raw_dir_args = err
+              end
+            end
             dir_args = continue_value(
               raw_dir_args, # value
               nil, # field

lib/graphql/schema/directive.rb

@@ -9,6 +9,7 @@ class Schema
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::HasDirectiveArguments
+      extend GraphQL::Schema::Member::HasValidators
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -75,6 +76,10 @@ def resolve_each(object, arguments, context)
           yield
         end
 
+        def validate!(arguments, context)
+          Schema::Validator.validate!(validators, self, context, arguments)
+        end
+
         def on_field?
           locations.include?(FIELD)
         end
@@ -122,15 +127,19 @@ def initialize(owner, **arguments)
         # - lazy resolution
         # Probably, those won't be needed here, since these are configuration arguments,
         # not runtime arguments.
+        context = Query::NullContext.instance
         self.class.all_argument_definitions.each do |arg_defn|
           value = arguments[arg_defn.keyword]
-          arg_type = arg_defn.type
-          result = arg_defn.type.validate_input(value, Query::NullContext.instance)
+          result = arg_defn.type.validate_input(value, context)
           if !result.valid?
             raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
           end
         end
-        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext.instance)
+        self.class.validate!(arguments, context)
+        @arguments = self.class.coerce_arguments(nil, arguments, context)
+        if @arguments.is_a?(GraphQL::ExecutionError)
+          raise @arguments
+        end
       end
 
       def graphql_name

spec/graphql/schema/directive_spec.rb

@@ -401,6 +401,56 @@ def numbers
     assert_equal [["tag", { name: "t7"}], ["tag", { name: "t8"}]], enum_value.directives.map { |dir| [dir.graphql_name, dir.arguments.to_h] }
   end
 
+  describe "Custom validations on definition directives" do
+    class DirectiveValidationSchema < GraphQL::Schema
+      class ValidatedDirective < GraphQL::Schema::Directive
+        locations OBJECT, FIELD
+        argument :f, Float, required: false, validates: { numericality: { greater_than: 0 } }
+        argument :s, String, required: false, validates: { format: { with: /^[a-z]{3}$/ } }
+        validates required: { one_of: [:f, :s]}
+      end
+
+      class Query < GraphQL::Schema::Object
+        field :i, Int, fallback_value: 100
+      end
+
+      query(Query)
+      directive(ValidatedDirective)
+    end
+
+    it "runs custom validation during execution" do
+      f_err_res = DirectiveValidationSchema.execute("{ i @validatedDirective(f: -10) }")
+      assert_equal [{"message" => "f must be greater than 0", "locations" => [{"line" => 1, "column" => 5}], "path" => ["i"]}], f_err_res["errors"]
+
+      s_err_res = DirectiveValidationSchema.execute("{ i @validatedDirective(s: \"wnrn\") }")
+      assert_equal [{"message" => "s is invalid", "locations" => [{"line" => 1, "column" => 5}], "path" => ["i"]}], s_err_res["errors"]
+
+      f_s_err_res = DirectiveValidationSchema.execute("{ i @validatedDirective }")
+      assert_equal [{"message" => "validatedDirective must include exactly one of the following arguments: f, s.", "locations" => [{"line" => 1, "column" => 5}], "path" => ["i"]}], f_s_err_res["errors"]
+    end
+
+    it "runs custom validation during definition" do
+      obj_type = Class.new(GraphQL::Schema::Object)
+      directive_defn = DirectiveValidationSchema::ValidatedDirective
+      obj_type.directive(directive_defn, f: 1)
+      f_err = assert_raises GraphQL::Schema::Validator::ValidationFailedError do
+        obj_type.directive(directive_defn, f: -1)
+      end
+      assert_equal "f must be greater than 0", f_err.message
+
+      obj_type.directive(directive_defn, s: "abc")
+      s_err = assert_raises GraphQL::Schema::Validator::ValidationFailedError do
+        obj_type.directive(directive_defn, s: "defg")
+      end
+      assert_equal "s is invalid", s_err.message
+
+      required_err = assert_raises GraphQL::Schema::Validator::ValidationFailedError do
+        obj_type.directive(directive_defn)
+      end
+      assert_equal "validatedDirective must include exactly one of the following arguments: f, s.", required_err.message
+    end
+  end
+
   describe "Validating schema directives" do
     def build_sdl(size:)
       <<~GRAPHQL