Merge pull request #2 from graphql-java/better_locale_support

Better locale support while its missing in graphql-java

Author: bbakerman

readme.md

@@ -120,7 +120,20 @@ You can use Java EL syntax in the message templates to format even more powerful
 If you use directive arguments like `message : String = "graphql.validation.Size.message"` then the `ResourceBundleMessageInterpolator` class
 will use that as a resource bundle lookup key.  This too is inspired by the javax.validation annotations and how they work.
 
-Like javax.validation, this library ships with some default error message templates but you can override them. 
+Like javax.validation, this library ships with some default error message templates but you can override them.
+
+# I18n Locale Support
+
+The validation library aims to offer Internationalisation (18N) of the error messages.  When the validation rules
+run they are passed in a `java.util.Locale`.  A `ResourceBundleMessageInterpolator` can then be used to build up messages
+that come from I18N bundles.
+
+A `Locale` should be created per graphql execution.  However at the time of writing graphql-java does not
+pass in a `Locale` per request `ExecutionInput` .  A PR exists to fix this and it will be released in v14.0.  This
+library will then be updated to to take advantage of this.  
+
+In the mean time you can work around this by having the `context`, `source` or `root` implement `graphql.validation.locale.LocaleProvider` and
+the library will extract a `Locale` from that.
 
 # Schema Directive Wiring
 

src/main/java/graphql/validation/locale/LocaleProvider.java

@@ -0,0 +1,14 @@
+package graphql.validation.locale;
+
+import java.util.Locale;
+
+/**
+ * An object that can give back a locale
+ */
+public interface LocaleProvider {
+
+    /**
+     * @return a locale to be used by validation rules
+     */
+    Locale getLocale();
+}

src/main/java/graphql/validation/locale/LocaleUtil.java

@@ -0,0 +1,89 @@
+package graphql.validation.locale;
+
+import graphql.Internal;
+import graphql.schema.DataFetchingEnvironment;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class LocaleUtil {
+
+    /**
+     * This will try to determine the Locale from the data fetching env in a number of ways, searching
+     * via the context and source objects and the data fetching environment itself.  This plugs a gap while
+     * graphql-java does not have a getLocale on ExecutionInput / DataFetchingEnvironment
+     *
+     * @param environment   the fetching env
+     * @param defaultLocale the default to use
+     *
+     * @return a Locale
+     */
+    public static Locale determineLocale(DataFetchingEnvironment environment, Locale defaultLocale) {
+        //
+        // in a future version of graphql java the DFE will have the Locale but in the mean time
+        Locale locale;
+        locale = extractLocale(environment);
+        if (locale == null) {
+            locale = extractLocale(environment.getContext());
+            if (locale == null) {
+                locale = extractLocale(environment.getSource());
+                if (locale == null) {
+                    locale = extractLocale(environment.getRoot());
+                    if (locale == null) {
+                        locale = defaultLocale;
+                    }
+                }
+            }
+        }
+        return locale;
+    }
+
+    private static Locale extractLocale(Object object) {
+        if (object != null) {
+            if (object instanceof LocaleProvider) {
+                return ((LocaleProvider) object).getLocale();
+            }
+            return reflectGetLocale(object);
+        }
+        return null;
+    }
+
+    private static final Map<Class, Method> METHOD_CACHE = new ConcurrentHashMap<>();
+    private static final Map<Class, Class> FAILED_CLASS_CACHE = new ConcurrentHashMap<>();
+
+    @Internal
+    public static void clearMethodCaches() {
+        METHOD_CACHE.clear();
+        FAILED_CLASS_CACHE.clear();
+    }
+
+    private static Locale reflectGetLocale(Object object) {
+        Class<?> clazz = object.getClass();
+        if (FAILED_CLASS_CACHE.containsKey(clazz)) {
+            return null;
+        }
+        try {
+            Method getLocaleMethod = METHOD_CACHE.get(clazz);
+            if (getLocaleMethod == null) {
+                getLocaleMethod = clazz.getMethod("getLocale");
+                if (Locale.class.equals(getLocaleMethod.getReturnType())) {
+                    METHOD_CACHE.put(clazz, getLocaleMethod);
+                } else {
+                    getLocaleMethod = null; // wat - very tricksy hobbit??
+                }
+            }
+            if (getLocaleMethod != null) {
+                return (Locale) getLocaleMethod.invoke(object);
+            }
+
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ignored) {
+        }
+        FAILED_CLASS_CACHE.put(clazz, clazz);
+        return null;
+    }
+
+
+}

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

@@ -17,6 +17,7 @@
 import graphql.schema.GraphQLTypeUtil;
 import graphql.util.FpKit;
 import graphql.validation.interpolation.MessageInterpolator;
+import graphql.validation.locale.LocaleUtil;
 import graphql.validation.util.Util;
 
 import java.util.ArrayList;
@@ -56,12 +57,15 @@ public boolean isEmpty() {
     /**
      * Runs the contained rules that match the currently executing field named by the {@link graphql.schema.DataFetchingEnvironment}
      *
-     * @param env          the field being executed
-     * @param interpolator the message interpolator to use
-     * @param locale       the locale in play
+     * @param env           the field being executed
+     * @param interpolator  the message interpolator to use
+     * @param defaultLocale the default locale in play
+     *
      * @return a list of zero or more input data validation errors
      */
-    public List<GraphQLError> runValidationRules(DataFetchingEnvironment env, MessageInterpolator interpolator, Locale locale) {
+    public List<GraphQLError> runValidationRules(DataFetchingEnvironment env, MessageInterpolator interpolator, Locale defaultLocale) {
+
+        defaultLocale = LocaleUtil.determineLocale(env, defaultLocale);
 
         List<GraphQLError> errors = new ArrayList<>();
 
@@ -76,6 +80,7 @@ public List<GraphQLError> runValidationRules(DataFetchingEnvironment env, Messag
             ValidationEnvironment ruleEnvironment = ValidationEnvironment.newValidationEnvironment()
                     .dataFetchingEnvironment(env)
                     .messageInterpolator(interpolator)
+                    .locale(defaultLocale)
                     .validatedElement(FIELD)
                     .validatedPath(fieldPath)
                     .build();
@@ -109,7 +114,7 @@ public List<GraphQLError> runValidationRules(DataFetchingEnvironment env, Messag
                     .validatedPath(fieldPath.segment(fieldArg.getName()))
                     .directives(fieldArg.getDirectives())
                     .messageInterpolator(interpolator)
-                    .locale(locale)
+                    .locale(defaultLocale)
                     .build();
 
             for (ValidationRule rule : rules) {

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

@@ -93,19 +93,17 @@ public List<ValidationRule> getRulesFor(GraphQLFieldDefinition fieldDefinition,
      * This helper method will run the validation rules that apply to the provided {@link graphql.schema.DataFetchingEnvironment}
      *
      * @param env the data fetching environment
+     *
      * @return a list of zero or more input data validation errors
      */
     public List<GraphQLError> runValidationRules(DataFetchingEnvironment env) {
         GraphQLFieldsContainer fieldsContainer = env.getExecutionStepInfo().getFieldContainer();
         GraphQLFieldDefinition fieldDefinition = env.getFieldDefinition();
 
-        //
-        // a future version of graphql-java will have the locale within the DataFetchingEnvironment
-        Locale locale = this.getLocale();
         MessageInterpolator messageInterpolator = this.getMessageInterpolator();
 
         TargetedValidationRules rules = this.buildRulesFor(fieldDefinition, fieldsContainer);
-        return rules.runValidationRules(env, messageInterpolator, locale);
+        return rules.runValidationRules(env, messageInterpolator, this.getLocale());
     }
 
     /**
@@ -163,6 +161,7 @@ public Builder messageInterpolator(MessageInterpolator messageInterpolator) {
          * will not be as useful.
          *
          * @param locale the locale to use for message interpolation
+         *
          * @return this builder
          */
         public Builder locale(Locale locale) {

src/main/java/graphql/validation/schemawiring/ValidationSchemaWiring.java

@@ -9,8 +9,8 @@
 import graphql.schema.idl.SchemaDirectiveWiringEnvironment;
 import graphql.validation.interpolation.MessageInterpolator;
 import graphql.validation.rules.OnValidationErrorStrategy;
-import graphql.validation.rules.ValidationRules;
 import graphql.validation.rules.TargetedValidationRules;
+import graphql.validation.rules.ValidationRules;
 import graphql.validation.util.Util;
 
 import java.util.List;
@@ -55,12 +55,10 @@ public GraphQLFieldDefinition onField(SchemaDirectiveWiringEnvironment<GraphQLFi
         return fieldDefinition;
     }
 
-    private DataFetcher buildValidatingDataFetcher(TargetedValidationRules rules, OnValidationErrorStrategy errorStrategy, MessageInterpolator messageInterpolator, DataFetcher currentDF, Locale locale) {
+    private DataFetcher buildValidatingDataFetcher(TargetedValidationRules rules, OnValidationErrorStrategy errorStrategy, MessageInterpolator messageInterpolator, DataFetcher currentDF, final Locale defaultLocale) {
         // ok we have some rules that need to be applied to this field and its arguments
         return environment -> {
-            // TODO - get the Locale from the DFE instead of statically - this needs to go into graphql-java however
-
-            List<GraphQLError> errors = rules.runValidationRules(environment, messageInterpolator, locale);
+            List<GraphQLError> errors = rules.runValidationRules(environment, messageInterpolator, defaultLocale);
             if (!errors.isEmpty()) {
                 // should we continue?
                 if (!errorStrategy.shouldContinue(errors, environment)) {
@@ -75,4 +73,5 @@ private DataFetcher buildValidatingDataFetcher(TargetedValidationRules rules, On
             return Util.mkDFRFromFetchedResult(errors, returnValue);
         };
     }
+
 }