Upped to graphql-java 13.0 and more work in applies to!

bbakerman · bbakerman · commit 0e75b750a35d · 2019-06-16T12:39:09.000+10:00
diff --git a/TODO.md b/TODO.md
@@ -37,4 +37,25 @@ the name Constraint especially for the @directives rules
  Does this makes sense?  What can we do to make this more powerful?
  
  Hibernate Validator uses a form of this to do message interpolation
- 
+ 
+ Could this be the inter argument validation
+ 
+ ```graphql
+    field( first : Int, after : ID, last : Int, before : ID) : ObjType
+        @Expression( expr="""
+            ${ (! empty first && empty last) || (!empty last && empty first) }
+        """)
+```
+ 
+ is this powerful or not?
+ 
+ # Allow scripting
+ 
+ The Hibernate project allows scripting
+ 
+ ```graphql
+    @Script(lang : "javascript", script : "_this.startDate.before(_this.endDate)")
+
+```
+
+Could we do something similar
diff --git a/build.gradle b/build.gradle
@@ -38,7 +38,7 @@ repositories {
 
 
 dependencies {
-    compile "com.graphql-java:graphql-java:12.0"
+    compile "com.graphql-java:graphql-java:13.0"
     compile "javax.validation:validation-api:2.0.1.Final"
     //compile "org.hibernate.validator:hibernate-validator:6.0.17.Final"
     compile "org.hibernate.validator:hibernate-validator:6.1.0.Alpha5"
diff --git a/src/main/java/graphql/validation/directives/AbstractDirectiveValidationRule.java b/src/main/java/graphql/validation/directives/AbstractDirectiveValidationRule.java
@@ -11,6 +11,7 @@
 import graphql.schema.GraphQLInputObjectType;
 import graphql.schema.GraphQLInputType;
 import graphql.schema.GraphQLScalarType;
+import graphql.schema.GraphQLTypeUtil;
 import graphql.validation.rules.ValidationRuleEnvironment;
 import graphql.validation.util.Util;
 
@@ -39,10 +40,32 @@ public String getName() {
     }
 
     @Override
-    public boolean appliesToType(GraphQLArgument argument, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
-        return appliesToType(Util.unwrapNonNull(argument.getType()));
+    public boolean appliesTo(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
+        return false;
     }
 
+    @Override
+    public boolean appliesTo(GraphQLArgument argument, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
+
+        return DirectivesAndTypeWalker.isSuitable(argument, (inputType, directive) -> {
+            boolean hasNamedDirective = directive.getName().equals(this.getName());
+            if (hasNamedDirective) {
+                inputType = Util.unwrapNonNull(inputType);
+                boolean appliesToType = appliesToType(inputType);
+                if (appliesToType) {
+                    return true;
+                }
+                // if they have a @Directive on there BUT it cant handle that type
+                // then is a really bad situation
+                String argType = GraphQLTypeUtil.simplePrint(inputType);
+                Assert.assertShouldNeverHappen("The directive rule '%s' cannot be placed on elements of type '%s'", this.getName(), argType);
+            }
+            return false;
+        });
+    }
+
+    abstract protected boolean appliesToType(GraphQLInputType inputType);
+
     /**
      * Returns true of the input type is one of the specified scalar types, regardless of non null ness
      *
diff --git a/src/main/java/graphql/validation/directives/DirectiveValidationRule.java b/src/main/java/graphql/validation/directives/DirectiveValidationRule.java
@@ -2,13 +2,17 @@
 
 import graphql.GraphQLError;
 import graphql.PublicSpi;
-import graphql.schema.GraphQLInputType;
 import graphql.validation.rules.ValidationRule;
 import graphql.validation.rules.ValidationRuleEnvironment;
 
 import java.util.Collections;
 import java.util.List;
 
+/**
+ * A DirectiveValidationRule is a specialised form of validation rule
+ * that assumes it is backed by a SDL directive on fields, field arguments
+ * or input type fields.
+ */
 @PublicSpi
 public interface DirectiveValidationRule extends ValidationRule {
 
@@ -20,8 +24,6 @@ public interface DirectiveValidationRule extends ValidationRule {
 
     List<String> getApplicableTypeNames();
 
-    boolean appliesToType(GraphQLInputType inputType);
-
     @Override
     default List<GraphQLError> runValidation(ValidationRuleEnvironment ruleEnvironment) {
         return Collections.emptyList();
diff --git a/src/main/java/graphql/validation/directives/DirectiveValidationRules.java b/src/main/java/graphql/validation/directives/DirectiveValidationRules.java
@@ -91,24 +91,25 @@ public static Builder newDirectiveValidationRules() {
     }
 
     @Override
-    public boolean appliesToType(GraphQLArgument argument, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
-        return argument.getDirectives().stream().anyMatch(d -> oneOfOurs(d, argument));
-    }
-
-    private boolean oneOfOurs(GraphQLDirective directive, GraphQLArgument argument) {
-        DirectiveValidationRule rule = directiveRules.get(directive.getName());
-        if (rule != null) {
-            return rule.appliesToType(argument.getType());
+    public boolean appliesTo(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
+        for (DirectiveValidationRule directiveRule : directiveRules.values()) {
+            boolean applies = directiveRule.appliesTo(fieldDefinition, fieldsContainer);
+            if (applies) {
+                return true;
+            }
         }
         return false;
     }
 
-    private void assertDirectiveOnTheRightType(DirectiveValidationRule directiveRule, GraphQLInputType inputType) {
-        boolean applicable = directiveRule.appliesToType(inputType);
-        if (!applicable) {
-            String argType = GraphQLTypeUtil.simplePrint(inputType);
-            Assert.assertShouldNeverHappen("The directive %s cannot be placed on arguments of type %s", directiveRule.getName(), argType);
+    @Override
+    public boolean appliesTo(GraphQLArgument argument, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
+        for (DirectiveValidationRule directiveRule : directiveRules.values()) {
+            boolean applies = directiveRule.appliesTo(argument, fieldDefinition, fieldsContainer);
+            if (applies) {
+                return true;
+            }
         }
+        return false;
     }
 
     @SuppressWarnings("unchecked")
@@ -118,9 +119,6 @@ public List<GraphQLError> runValidation(ValidationRuleEnvironment ruleEnvironmen
         GraphQLArgument argument = ruleEnvironment.getArgument();
         Object validatedValue = ruleEnvironment.getValidatedValue();
         List<GraphQLDirective> directives = argument.getDirectives();
-        if (directives.isEmpty()) {
-            return Collections.emptyList();
-        }
 
         //
         // all the directives validation code does NOT care for NULL ness since the graphql engine covers that.
@@ -140,10 +138,6 @@ private List<GraphQLError> runValidationImpl(ValidationRuleEnvironment ruleEnvir
             if (validationRule == null) {
                 continue;
             }
-            //
-            // double check that directive is in fact on an element it can handle
-            //
-            assertDirectiveOnTheRightType(validationRule, inputType);
 
             ruleEnvironment = ruleEnvironment.transform(b -> b.context(GraphQLDirective.class, directive));
             //
diff --git a/src/main/java/graphql/validation/directives/DirectivesAndTypeWalker.java b/src/main/java/graphql/validation/directives/DirectivesAndTypeWalker.java
@@ -0,0 +1,53 @@
+package graphql.validation.directives;
+
+import graphql.schema.GraphQLArgument;
+import graphql.schema.GraphQLDirective;
+import graphql.schema.GraphQLDirectiveContainer;
+import graphql.schema.GraphQLInputObjectField;
+import graphql.schema.GraphQLInputObjectType;
+import graphql.schema.GraphQLInputType;
+import graphql.schema.GraphQLList;
+import graphql.validation.util.Util;
+
+import java.util.List;
+import java.util.function.BiFunction;
+
+public class DirectivesAndTypeWalker {
+
+    public static boolean isSuitable(GraphQLArgument argument, BiFunction<GraphQLInputType, GraphQLDirective, Boolean> isSutiable) {
+        GraphQLInputType inputType = argument.getType();
+        List<GraphQLDirective> directives = argument.getDirectives();
+        return walkInputType(inputType, directives, isSutiable);
+    }
+
+    private static boolean walkInputType(GraphQLInputType inputType, List<GraphQLDirective> directives, BiFunction<GraphQLInputType, GraphQLDirective, Boolean> isSuitable) {
+        GraphQLInputType unwrappedInputType = Util.unwrapNonNull(inputType);
+        for (GraphQLDirective directive : directives) {
+            if (isSuitable.apply(unwrappedInputType, directive)) {
+                return true;
+            }
+        }
+        if (unwrappedInputType instanceof GraphQLInputObjectType) {
+            GraphQLInputObjectType inputObjType = (GraphQLInputObjectType) unwrappedInputType;
+            for (GraphQLInputObjectField inputField : inputObjType.getFieldDefinitions()) {
+                inputType = inputField.getType();
+                directives = inputField.getDirectives();
+
+                if (walkInputType(inputType, directives, isSuitable)) {
+                    return true;
+                }
+            }
+        }
+        if (unwrappedInputType instanceof GraphQLList) {
+            GraphQLInputType innerListType = Util.unwrapOneAndAllNonNull(unwrappedInputType);
+            if (innerListType instanceof GraphQLDirectiveContainer) {
+                directives = ((GraphQLDirectiveContainer) innerListType).getDirectives();
+                if (walkInputType(innerListType, directives, isSuitable)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/src/main/java/graphql/validation/rules/PossibleValidationRules.java b/src/main/java/graphql/validation/rules/PossibleValidationRules.java
@@ -11,8 +11,6 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import static graphql.validation.rules.ArgumentCoordinates.newArgumentCoordinates;
-
 /**
  * {@link PossibleValidationRules} is a simple holder of possible rules
  * and you can then pass it field and arguments and narrow down the list of actual rules
@@ -31,7 +29,7 @@ private PossibleValidationRules(Builder builder) {
         this.onValidationErrorStrategy = builder.onValidationErrorStrategy;
     }
 
-    public static Builder newValidationRuleCandidates() {
+    public static Builder newPossibleRules() {
         return new Builder();
     }
 
@@ -47,21 +45,32 @@ public OnValidationErrorStrategy getOnValidationErrorStrategy() {
         return onValidationErrorStrategy;
     }
 
-    public ValidationRules getRulesFor(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
+    public ValidationRules buildRulesFor(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
         ValidationRules.Builder rulesBuilder = ValidationRules.newValidationRules();
+
+        ValidationCoordinates fieldCoordinates = ValidationCoordinates.newCoordinates(fieldsContainer, fieldDefinition);
+        List<ValidationRule> fieldRules = getRulesFor(fieldDefinition, fieldsContainer);
+        rulesBuilder.addRules(fieldCoordinates, fieldRules);
+
         for (GraphQLArgument fieldArg : fieldDefinition.getArguments()) {
-            ArgumentCoordinates argumentCoordinates = newArgumentCoordinates(fieldsContainer, fieldDefinition, fieldArg);
+            ValidationCoordinates validationCoordinates = ValidationCoordinates.newCoordinates(fieldsContainer, fieldDefinition, fieldArg);
 
             List<ValidationRule> rules = getRulesFor(fieldArg, fieldDefinition, fieldsContainer);
-            rulesBuilder.addRules(argumentCoordinates, rules);
+            rulesBuilder.addRules(validationCoordinates, rules);
         }
 
         return rulesBuilder.build();
     }
 
     public List<ValidationRule> getRulesFor(GraphQLArgument fieldArg, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
         return rules.stream()
-                .filter(rule -> rule.appliesToType(fieldArg, fieldDefinition, fieldsContainer))
+                .filter(rule -> rule.appliesTo(fieldArg, fieldDefinition, fieldsContainer))
+                .collect(Collectors.toList());
+    }
+
+    public List<ValidationRule> getRulesFor(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer) {
+        return rules.stream()
+                .filter(rule -> rule.appliesTo(fieldDefinition, fieldsContainer))
                 .collect(Collectors.toList());
     }
 
diff --git a/src/main/java/graphql/validation/rules/ValidationCoordinates.java b/src/main/java/graphql/validation/rules/ValidationCoordinates.java
@@ -9,16 +9,16 @@
 import java.util.StringJoiner;
 
 @PublicApi
-public class ArgumentCoordinates {
+public class ValidationCoordinates {
 
     private final String containerType;
     private final String fieldName;
     private final String argName;
 
-    public ArgumentCoordinates(String containerType, String fieldName, String argName) {
+    public ValidationCoordinates(String containerType, String fieldName, String argName) {
         this.containerType = Objects.requireNonNull(containerType);
         this.fieldName = Objects.requireNonNull(fieldName);
-        this.argName = Objects.requireNonNull(argName);
+        this.argName = argName;
     }
 
     public String getContainerType() {
@@ -42,7 +42,7 @@ public boolean equals(Object o) {
             return false;
         }
 
-        ArgumentCoordinates that = (ArgumentCoordinates) o;
+        ValidationCoordinates that = (ValidationCoordinates) o;
 
         return Objects.equals(this.getContainerType(), that.getContainerType()) && Objects.equals(this.getFieldName(), that.getFieldName()) && Objects.equals(this.getArgName(), that.getArgName());
     }
@@ -62,19 +62,35 @@ public String toString() {
     }
 
 
-    public static ArgumentCoordinates newArgumentCoordinates(GraphQLFieldsContainer fieldsContainer, GraphQLFieldDefinition fieldDefinition, GraphQLArgument fieldArg) {
-        return new ArgumentCoordinates(
+    public static ValidationCoordinates newCoordinates(GraphQLFieldsContainer fieldsContainer, GraphQLFieldDefinition fieldDefinition, GraphQLArgument fieldArg) {
+        return new ValidationCoordinates(
                 fieldsContainer.getName(),
                 fieldDefinition.getName(),
                 fieldArg.getName()
         );
     }
 
-    public static ArgumentCoordinates newArgumentCoordinates(String fieldsContainer, String fieldDefinition, String fieldArg) {
-        return new ArgumentCoordinates(
+    public static ValidationCoordinates newCoordinates(GraphQLFieldsContainer fieldsContainer, GraphQLFieldDefinition fieldDefinition) {
+        return new ValidationCoordinates(
+                fieldsContainer.getName(),
+                fieldDefinition.getName(),
+                null
+        );
+    }
+
+    public static ValidationCoordinates newCoordinates(String fieldsContainer, String fieldDefinition, String fieldArg) {
+        return new ValidationCoordinates(
                 fieldsContainer,
                 fieldDefinition,
                 fieldArg
         );
     }
+
+    public static ValidationCoordinates newCoordinates(String fieldsContainer, String fieldDefinition) {
+        return new ValidationCoordinates(
+                fieldsContainer,
+                fieldDefinition,
+                null
+        );
+    }
 }
diff --git a/src/main/java/graphql/validation/rules/ValidationRule.java b/src/main/java/graphql/validation/rules/ValidationRule.java
@@ -15,7 +15,33 @@
 @PublicSpi
 public interface ValidationRule {
 
-    boolean appliesToType(GraphQLArgument argument, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer);
+    /**
+     * This is called to work out if this rule applies to a specified field
+     *
+     * @param fieldDefinition the field to check
+     * @param fieldsContainer the field container
+     *
+     * @return true if this rule applies to the field
+     */
+    boolean appliesTo(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer);
 
+    /**
+     * This is called to work out if this rule applies to the argument of a specified field
+     *
+     * @param argument        the argument to check
+     * @param fieldDefinition the field to check
+     * @param fieldsContainer the field container
+     *
+     * @return true if this rule applies to the argument of the field field
+     */
+    boolean appliesTo(GraphQLArgument argument, GraphQLFieldDefinition fieldDefinition, GraphQLFieldsContainer fieldsContainer);
+
+    /**
+     * This is called to runs the rule
+     *
+     * @param ruleEnvironment the rule environment
+     *
+     * @return a non null list of errors where emptyList() means its valid
+     */
     List<GraphQLError> runValidation(ValidationRuleEnvironment ruleEnvironment);
 }
diff --git a/src/main/java/graphql/validation/rules/ValidationRules.java b/src/main/java/graphql/validation/rules/ValidationRules.java
diff --git a/src/main/java/graphql/validation/schemawiring/ValidationSchemaWiring.java b/src/main/java/graphql/validation/schemawiring/ValidationSchemaWiring.java
diff --git a/src/test/groovy/graphql/validation/directives/DirectiveValidationRulesTest.groovy b/src/test/groovy/graphql/validation/directives/DirectiveValidationRulesTest.groovy
diff --git a/src/test/groovy/graphql/validation/schemawiring/ValidationSchemaWiringTest.groovy b/src/test/groovy/graphql/validation/schemawiring/ValidationSchemaWiringTest.groovy
