Added early expression support

Author: bbakerman

readme.md

@@ -48,6 +48,20 @@ the `name` field must be at least 3 characters long and no more than 100 charact
 
 ## The supplied constraints
 
+### @Arguments
+
+The provided expression must evaluate to true.
+
+- Example : `drivers( first : Int, after : String!, last : Int, before : String) 
+ : DriverConnection @Arguments(expression : "${args.containsOneOf('first','last') }"`
+
+- Applies to : `Output Fields`
+
+- SDL : `directive @Arguments(expression : String!, message : String = "graphql.validation.Arguments.message") on FIELD_DEFINITION`
+
+- Message : `graphql.validation.Arguments.message`
+
+
 ### @AssertFalse
 
 The boolean value must be false.

src/main/java/graphql/validation/constraints/AbstractDirectiveConstraint.java

@@ -204,6 +204,19 @@ protected Map<String, Object> mkMessageParams(Object validatedValue, ValidationE
         params.put("constraint", getName());
         params.put("path", mkFieldOrArgPath(validationEnvironment));
 
+        params.putAll(mkMap(args));
+        return params;
+    }
+
+    /**
+     * Makes a map of the args
+     *
+     * @param args must be an key / value array with String keys as the even params and values as then odd params
+     *
+     * @return a map of the args
+     */
+    protected Map<String, Object> mkMap(Object... args) {
+        Map<String, Object> params = new LinkedHashMap<>();
         Assert.assertTrue(args.length % 2 == 0, "You MUST pass in an even number of arguments");
         for (int ix = 0; ix < args.length; ix = ix + 2) {
             Object key = args[ix];
@@ -214,6 +227,7 @@ protected Map<String, Object> mkMessageParams(Object validatedValue, ValidationE
         return params;
     }
 
+
     private Object mkFieldOrArgPath(ValidationEnvironment validationEnvironment) {
         ExecutionPath executionPath = validationEnvironment.getExecutionPath();
         ExecutionPath fieldOrArgumentPath = validationEnvironment.getFieldOrArgumentPath();

src/main/java/graphql/validation/constraints/DirectiveConstraints.java

@@ -15,6 +15,7 @@
 import graphql.schema.GraphQLList;
 import graphql.schema.GraphQLTypeUtil;
 import graphql.util.FpKit;
+import graphql.validation.constraints.standard.ArgumentsConstraint;
 import graphql.validation.constraints.standard.AssertFalseConstraint;
 import graphql.validation.constraints.standard.AssertTrueConstraint;
 import graphql.validation.constraints.standard.DecimalMaxConstraint;
@@ -56,6 +57,7 @@ public class DirectiveConstraints implements ValidationRule {
      * These are the standard directive rules that come with the system
      */
     public final static List<DirectiveConstraint> STANDARD_CONSTRAINTS = Arrays.asList(
+            new ArgumentsConstraint(),
             new AssertFalseConstraint(),
             new AssertTrueConstraint(),
             new DecimalMaxConstraint(),

src/main/java/graphql/validation/constraints/standard/ArgumentsConstraint.java

@@ -1,23 +1,23 @@
 package graphql.validation.constraints.standard;
 
 import graphql.GraphQLError;
+import graphql.schema.GraphQLDirective;
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.schema.GraphQLFieldsContainer;
 import graphql.schema.GraphQLInputType;
 import graphql.validation.constraints.AbstractDirectiveConstraint;
 import graphql.validation.constraints.Documentation;
+import graphql.validation.el.ELSupport;
 import graphql.validation.rules.ValidationEnvironment;
 
-import javax.el.ELContext;
-import javax.el.ExpressionFactory;
-import javax.el.ValueExpression;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 public class ArgumentsConstraint extends AbstractDirectiveConstraint {
 
     public ArgumentsConstraint() {
-        super("@Arguments");
+        super("Arguments");
     }
 
 
@@ -26,14 +26,14 @@ public Documentation getDocumentation() {
         return Documentation.newDocumentation()
                 .messageTemplate(getMessageTemplate())
 
-                .description("TODO")
+                .description("The provided expression must evaluate to true.")
 
                 .example("drivers( first : Int, after : String!, last : Int, before : String) \n" +
-                        " : DriverConnection @Arguments(expr : \"${(! empty first && ! empty after) || (! empty last && ! empty before)}\"")
+                        " : DriverConnection @Arguments(expression : \"${args.containsOneOf('first','last') }\"")
 
                 .applicableTypeNames("Output Fields")
 
-                .directiveSDL("directive @Arguments(expr : String!, message : String = \"%s\") " +
+                .directiveSDL("directive @Arguments(expression : String!, message : String = \"%s\") " +
                                 "on FIELD_DEFINITION",
                         getMessageTemplate())
                 .build();
@@ -53,16 +53,32 @@ public boolean appliesTo(GraphQLFieldDefinition fieldDefinition, GraphQLFieldsCo
     public List<GraphQLError> runValidation(ValidationEnvironment validationEnvironment) {
 
         GraphQLFieldDefinition fieldDefinition = validationEnvironment.getFieldDefinition();
+        GraphQLDirective directive = validationEnvironment.getContextObject(GraphQLDirective.class);
+        String expression = curlyBraces(getStrArg(directive, "expression"));
 
-        // TODO
+        Map<String, Object> variables = mkMap(
+                "fieldDefinition", fieldDefinition,
+                "args", validationEnvironment.getArgumentValues()
+        );
+        ELSupport elSupport = new ELSupport(validationEnvironment.getLocale());
+        boolean isOK = elSupport.evaluateBoolean(expression, variables);
+
+        if (!isOK) {
+            return mkError(validationEnvironment, directive, mkMessageParams(null, validationEnvironment,
+                    "expression", expression));
+
+        }
         return Collections.emptyList();
     }
 
-    private void bindVariable(ExpressionFactory expressionFactory, ELContext elContext, String variableName, Object variable, Class variableClass) {
-        ValueExpression valueExpression = expressionFactory.createValueExpression(
-                variable,
-                variableClass
-        );
-        elContext.getVariableMapper().setVariable(variableName, valueExpression);
+    private String curlyBraces(String expression) {
+        expression = expression.trim();
+        if (!expression.startsWith("${") && !expression.startsWith("#{")) {
+            expression = "${" + expression;
+        }
+        if (!expression.startsWith("}")) {
+            expression = expression + "}";
+        }
+        return expression;
     }
 }

src/main/java/graphql/validation/el/BetterMapELResolver.java

@@ -0,0 +1,52 @@
+package graphql.validation.el;
+
+import graphql.Internal;
+
+import javax.el.ELContext;
+import javax.el.MapELResolver;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+@Internal
+public class BetterMapELResolver extends MapELResolver {
+    public static boolean containsOneOf(Map map, List<Object> keys) {
+        int count = 0;
+        for (Object key : keys) {
+            if (map.get(key) != null) {
+                count++;
+            }
+        }
+        return count == 1;
+    }
+
+    public static boolean containsAllOf(Map map, List<Object> keys) {
+        for (Object key : keys) {
+            if (map.get(key) == null) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public Object invoke(ELContext context, Object base, Object method, Class<?>[] paramTypes, Object[] params) {
+
+        if (context == null) {
+            throw new NullPointerException();
+        }
+
+        if (base instanceof Map) {
+            context.setPropertyResolved(true);
+            Map map = (Map) base;
+            if ("containsOneOf" .equals(method)) {
+                return containsOneOf(map, Arrays.asList(params));
+            }
+            if ("containsAllOf" .equals(method)) {
+                return containsAllOf(map, Arrays.asList(params));
+            }
+        }
+        return null;
+    }
+
+}

src/main/java/graphql/validation/el/ELSupport.java

@@ -0,0 +1,80 @@
+package graphql.validation.el;
+
+import graphql.Internal;
+import org.hibernate.validator.internal.engine.messageinterpolation.FormatterWrapper;
+
+import javax.el.ELContext;
+import javax.el.ELManager;
+import javax.el.ExpressionFactory;
+import javax.el.StandardELContext;
+import javax.el.ValueExpression;
+import java.lang.reflect.Method;
+import java.util.Locale;
+import java.util.Map;
+
+@Internal
+@SuppressWarnings("unused")
+public class ELSupport {
+    private static final ExpressionFactory expressionFactory = loadExpressionSupport();
+    private final StandardELContext elContext;
+
+    public ELSupport(Locale locale) {
+        elContext = new StandardELContext(expressionFactory);
+        elContext.setLocale(locale);
+        elContext.addELResolver(new BetterMapELResolver());
+        // put in standard functions and variables here
+        bindVariable(elContext, "formatter", new FormatterWrapper(locale));
+    }
+
+
+    private static ExpressionFactory loadExpressionSupport() {
+        //
+        // Do we need fancy class loading support.  The Hibernate Validator code jumps though incredible
+        // class loader tricks so should we?  Do they know something we don't?
+        //
+        // For now lets keep it simple
+        //
+        return ELManager.getExpressionFactory();
+    }
+
+    private void bindMethod(String bindName, String methodName, Class<?>... args) {
+        elContext.getFunctionMapper().mapFunction("", bindName, loadMethod(methodName, args));
+    }
+
+    private Method loadMethod(String name, Class<?>... args) {
+        try {
+            return ELSupport.class.getMethod(name, args);
+        } catch (NoSuchMethodException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private ValueExpression bindVariable(ELContext elContext, String variableName, Object variableValue) {
+        ValueExpression valueExpression = expressionFactory.createValueExpression(
+                variableValue,
+                Object.class
+        );
+        return elContext.getVariableMapper().setVariable(variableName, valueExpression);
+    }
+
+    public boolean evaluateBoolean(String expression, Map<String, Object> variables) {
+        return evaluateImpl(expression, variables, Boolean.class);
+
+    }
+
+    public Object evaluate(String expression, Map<String, Object> variables) {
+        return evaluateImpl(expression, variables, Object.class);
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T evaluateImpl(String expression, Map<String, Object> variables, Class<T> expectedResultClass) {
+        StandardELContext context = new StandardELContext(elContext);
+        for (Map.Entry<String, Object> entry : variables.entrySet()) {
+            bindVariable(context, entry.getKey(), entry.getValue());
+        }
+        ValueExpression result = expressionFactory.createValueExpression(context, expression, expectedResultClass);
+        return (T) result.getValue(context);
+    }
+
+
+}

src/main/java/graphql/validation/rules/ValidationEnvironment.java

@@ -16,8 +16,6 @@
 import java.util.Map;
 import java.util.function.Consumer;
 
-import static graphql.Assert.assertNotNull;
-
 @PublicApi
 public class ValidationEnvironment {
 
@@ -111,7 +109,7 @@ public ValidationEnvironment transform(Consumer<Builder> builderConsumer) {
     public static class Builder {
         private final Map<Class, Object> contextMap = new HashMap<>();
         private GraphQLArgument argument;
-        private Map<String, Object> argumentValues;
+        private Map<String, Object> argumentValues = new HashMap<>();
         private ExecutionPath executionPath;
         private GraphQLFieldDefinition fieldDefinition;
         private ExecutionPath fieldOrArgumentPath = ExecutionPath.rootPath();
@@ -210,9 +208,6 @@ public Builder locale(Locale locale) {
         }
 
         public ValidationEnvironment build() {
-            assertNotNull(argument);
-            assertNotNull(fieldOrArgumentType);
-            assertNotNull(fieldOrArgumentPath);
             return new ValidationEnvironment(this);
         }
     }

src/main/resources/graphql/validation/ValidationMessages.properties

@@ -1,6 +1,7 @@
 #
 # This contains the library provided validation messages
 #
+graphql.validation.Arguments.message=the expression must evaluate to true
 graphql.validation.AssertFalse.message=must be false
 graphql.validation.AssertTrue.message=must be true
 graphql.validation.DecimalMax.message=must be less than ${inclusive == true ? 'or equal to ' : ''}{value}
@@ -17,3 +18,4 @@ graphql.validation.Positive.message=must be greater than 0
 graphql.validation.PositiveOrZero.message=must be greater than or equal to 0
 graphql.validation.Range.message=range must be between {min} and {max}
 graphql.validation.Size.message=size must be between {min} and {max}
+