Start work on LegacyCoercing support

bbakerman · bbakerman · commit 137199fd2b3e · 2023-05-17T11:20:02.000+10:00
diff --git a/src/main/java/graphql/execution/values/legacycoercing/LegacyCoercingInputInterceptor.java b/src/main/java/graphql/execution/values/legacycoercing/LegacyCoercingInputInterceptor.java
@@ -0,0 +1,166 @@
+package graphql.execution.values.legacycoercing;
+
+import graphql.GraphQLContext;
+import graphql.Scalars;
+import graphql.execution.values.InputInterceptor;
+import graphql.scalar.CoercingUtil;
+import graphql.schema.GraphQLInputType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+
+import static graphql.Assert.assertNotNull;
+import static graphql.Assert.assertShouldNeverHappen;
+import static graphql.scalar.CoercingUtil.isNumberIsh;
+
+public class LegacyCoercingInputInterceptor implements InputInterceptor {
+
+    /**
+     * This will ONLY observe legacy values and invoke the callback when it gets one.  you can use this to enumerate how many
+     * legacy values are hitting you graphql implementation
+     *
+     * @param observerCallback a callback allowing you to observe a legacy scalar value
+     *
+     * @return an InputInterceptor that only observes values
+     */
+    public static LegacyCoercingInputInterceptor observeValues(BiConsumer<Object, GraphQLInputType> observerCallback) {
+        return new LegacyCoercingInputInterceptor(((input, graphQLInputType) -> {
+            observerCallback.accept(input, graphQLInputType);
+            return input;
+        }));
+    }
+
+    /**
+     * This will ONLY observe legacy values and invoke the callback when it gets one.  you can use this to enumerate how many
+     * legacy values are hitting you graphql implementation
+     *
+     * @param observerCallback a callback allowing you to observe a legacy scalar value before it is migrated
+     *
+     * @return an InputInterceptor that both observes values and migrates them to a more strict value
+     */
+    public static LegacyCoercingInputInterceptor migrateValues(BiConsumer<Object, GraphQLInputType> observerCallback) {
+        return new LegacyCoercingInputInterceptor(((input, graphQLInputType) -> {
+            observerCallback.accept(input, graphQLInputType);
+            if (Scalars.GraphQLBoolean.equals(graphQLInputType)) {
+                return coerceLegacyBooleanValue(input);
+            }
+            if (Scalars.GraphQLFloat.equals(graphQLInputType)) {
+                return coerceLegacyFloatValue(input);
+            }
+            if (Scalars.GraphQLInt.equals(graphQLInputType)) {
+                return coerceLegacyIntValue(input);
+            }
+            if (Scalars.GraphQLString.equals(graphQLInputType)) {
+                return coerceLegacyStringValue(input);
+            }
+            return input;
+        }));
+    }
+
+    private final BiFunction<Object, GraphQLInputType, Object> behavior;
+
+    private LegacyCoercingInputInterceptor(BiFunction<Object, GraphQLInputType, Object> behavior) {
+        this.behavior = assertNotNull(behavior);
+    }
+
+    @Override
+    public Object intercept(@Nullable Object input, @NotNull GraphQLInputType graphQLType, @NotNull GraphQLContext graphqlContext, @NotNull Locale locale) {
+        if (isLegacyValue(input, graphQLType)) {
+            // we ONLY apply the new behavior IF it's an old acceptable legacy value.
+            // so for compliant values - we change nothing and invoke no behaviour
+            // and for values that would not coerce anyway, we also invoke no behavior
+            return behavior.apply(input, graphQLType);
+        }
+        return input;
+    }
+
+    @SuppressWarnings("RedundantIfStatement")
+    static boolean isLegacyValue(Object input, GraphQLInputType graphQLType) {
+        if (Scalars.GraphQLBoolean.equals(graphQLType)) {
+            return isLegacyBooleanValue(input);
+        } else if (Scalars.GraphQLFloat.equals(graphQLType)) {
+            return isLegacyFloatValue(input);
+        } else if (Scalars.GraphQLInt.equals(graphQLType)) {
+            return isLegacyIntValue(input);
+        } else if (Scalars.GraphQLString.equals(graphQLType)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static boolean isLegacyBooleanValue(Object input) {
+        return input instanceof String || CoercingUtil.isNumberIsh(input);
+    }
+
+    static boolean isLegacyFloatValue(Object input) {
+        return input instanceof String;
+    }
+
+    static boolean isLegacyIntValue(Object input) {
+        return input instanceof String;
+    }
+
+    static Object coerceLegacyBooleanValue(Object input) {
+        if (input instanceof String) {
+            String lStr = ((String) input).toLowerCase();
+            if (lStr.equals("true")) {
+                return true;
+            }
+            if (lStr.equals("false")) {
+                return false;
+            }
+            return null;
+        } else if (isNumberIsh(input)) {
+            BigDecimal value;
+            try {
+                value = new BigDecimal(input.toString());
+            } catch (NumberFormatException e) {
+                // this should never happen because String is handled above
+                return assertShouldNeverHappen();
+            }
+            return value.compareTo(BigDecimal.ZERO) != 0;
+        }
+        // unchanged
+        return input;
+    }
+
+    static Object coerceLegacyFloatValue(Object input) {
+        if (isNumberIsh(input)) {
+            BigDecimal value;
+            try {
+                value = new BigDecimal(input.toString());
+            } catch (NumberFormatException e) {
+                return null;
+            }
+            return value.doubleValue();
+        }
+        return input;
+    }
+
+    static Object coerceLegacyIntValue(Object input) {
+        if (isNumberIsh(input)) {
+            BigDecimal value;
+            try {
+                value = new BigDecimal(input.toString());
+            } catch (NumberFormatException e) {
+                return null;
+            }
+            try {
+                return value.intValueExact();
+            } catch (ArithmeticException e) {
+                return null;
+            }
+        }
+        return input;
+    }
+
+
+    static Object coerceLegacyStringValue(Object input) {
+        return String.valueOf(input);
+    }
+}
diff --git a/src/test/groovy/graphql/execution/values/legacycoercing/LegacyCoercingInputInterceptorTest.groovy b/src/test/groovy/graphql/execution/values/legacycoercing/LegacyCoercingInputInterceptorTest.groovy
@@ -0,0 +1,26 @@
+package graphql.execution.values.legacycoercing
+
+import graphql.Scalars
+import spock.lang.Specification
+
+class LegacyCoercingInputInterceptorTest extends Specification {
+
+    def "can detect boolean legacy values"() {
+        when:
+        def isLegacyValue = LegacyCoercingInputInterceptor.isLegacyValue(input, inputType)
+        then:
+        isLegacyValue == expected
+
+        where:
+        input       | inputType              | expected
+        "true"      | Scalars.GraphQLBoolean | true
+        "false"     | Scalars.GraphQLBoolean | true
+        "TRUE"      | Scalars.GraphQLBoolean | true
+        "FALSE"     | Scalars.GraphQLBoolean | true
+        "junk"      | Scalars.GraphQLBoolean | true
+        // not acceptable to the old
+        true        | Scalars.GraphQLBoolean | false
+        false       | Scalars.GraphQLBoolean | false
+        ["rubbish"] | Scalars.GraphQLBoolean | false
+    }
+}
