feat: define aliased scalars from configurations

At this stage it only works for standard and extended scalars (not
custom scalar beans)

Author: BlasiusSecundus

graphql-spring-boot-autoconfigure/src/main/java/graphql/kickstart/autoconfigure/scalars/GraphQLAliasedScalarsInitializer.java

@@ -0,0 +1,68 @@
+package graphql.kickstart.autoconfigure.scalars;
+
+import static graphql.kickstart.autoconfigure.scalars.GraphQLScalarUtils.extractScalarDefinitions;
+
+import graphql.Scalars;
+import graphql.scalars.ExtendedScalars;
+import graphql.schema.GraphQLScalarType;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.ApplicationContextException;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.EnumerablePropertySource;
+
+@RequiredArgsConstructor
+public class GraphQLAliasedScalarsInitializer
+    implements ApplicationContextInitializer<GenericApplicationContext> {
+
+  private static final String GRAPHQL_ALIASED_SCALAR_PREFIX = "graphql.aliased-scalars.";
+  private static final String JOINING_SEPARATOR = ", ";
+  private static final String NO_BUILT_IN_SCALAR_FOUND
+      = "Scalar(s) '%s' cannot be aliased. "
+      + "Only the following scalars can be aliased by configuration: %s. "
+      + "Note that custom scalar beans cannot be aliased this way.";
+
+  @Override
+  public void initialize(@NonNull final GenericApplicationContext applicationContext) {
+      final Map<String, GraphQLScalarType> predefinedScalars
+          = extractScalarDefinitions(Scalars.class, ExtendedScalars.class);
+      final ConfigurableEnvironment environment = applicationContext.getEnvironment();
+      verifyAliasedScalarConfiguration(predefinedScalars, environment);
+      predefinedScalars.forEach((scalarName, scalarType) ->
+          ((List<?>) environment.getProperty(GRAPHQL_ALIASED_SCALAR_PREFIX + scalarName,
+              List.class, Collections.emptyList()))
+          .stream()
+          .map(String::valueOf)
+          .map(alias -> ExtendedScalars.newAliasedScalar(alias).aliasedScalar(scalarType).build())
+          .forEach(aliasedScalar -> applicationContext.registerBean(aliasedScalar.getName(),
+              GraphQLScalarType.class, () -> aliasedScalar)));
+    }
+
+  private void verifyAliasedScalarConfiguration(
+      final Map<String, GraphQLScalarType> predefinedScalars,
+      final ConfigurableEnvironment environment) {
+    final List<String> invalidScalars = environment.getPropertySources().stream()
+        .filter(pSource -> pSource instanceof EnumerablePropertySource)
+        .map(pSource -> (EnumerablePropertySource<?>) pSource)
+        .map(EnumerablePropertySource::getPropertyNames)
+        .flatMap(Arrays::stream)
+        .filter(pName -> pName.startsWith(GRAPHQL_ALIASED_SCALAR_PREFIX))
+        .map(pName -> pName.replace(GRAPHQL_ALIASED_SCALAR_PREFIX, ""))
+        .filter(scalarName -> !predefinedScalars.containsKey(scalarName))
+        .sorted()
+        .collect(Collectors.toList());
+    if (!invalidScalars.isEmpty()) {
+      final String validBuildInScalars = predefinedScalars.keySet().stream().sorted()
+          .collect(Collectors.joining(JOINING_SEPARATOR));
+      throw new ApplicationContextException(String.format(NO_BUILT_IN_SCALAR_FOUND,
+          String.join(JOINING_SEPARATOR, invalidScalars), validBuildInScalars));
+    }
+  }
+}

graphql-spring-boot-autoconfigure/src/main/java/graphql/kickstart/autoconfigure/scalars/GraphQLScalarUtils.java

@@ -0,0 +1,44 @@
+package graphql.kickstart.autoconfigure.scalars;
+
+import graphql.schema.GraphQLScalarType;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Stream;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.springframework.util.ReflectionUtils;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class GraphQLScalarUtils {
+
+  /**
+   * Extract scalar field definitions from helper classes. Public static
+   * {@link GraphQLScalarType} fields are considered as scalar definitions.
+   *
+   * @param classes  classes that may contain scalar definitions.
+   * @return the map of scalar definitions (keys = scalar names, values are scalar type definitions).
+   * May return an empty map if no definitions found. If multiple source classes define GraphQL
+   * scalar types with the same definition, then the last one will be included in the map.
+   */
+  public static Map<String, GraphQLScalarType> extractScalarDefinitions(final Class<?>... classes) {
+    final Map<String, GraphQLScalarType> scalarTypes = new HashMap<>();
+    Stream.of(classes).forEach(clazz -> extractScalarField(clazz, scalarTypes));
+    return scalarTypes;
+  }
+
+  private static void extractScalarField(Class<?> clazz, Map<String, GraphQLScalarType> target) {
+    ReflectionUtils.doWithFields(clazz, scalarField -> extractedIfScalarField(target, scalarField));
+  }
+
+  private static void extractedIfScalarField(Map<String, GraphQLScalarType> target, Field field)
+      throws IllegalAccessException {
+    if (Modifier.isPublic(field.getModifiers())
+        && Modifier.isStatic(field.getModifiers())
+        && field.getType().equals(GraphQLScalarType.class)) {
+      final GraphQLScalarType graphQLScalarType = (GraphQLScalarType) field.get(null);
+      target.put(graphQLScalarType.getName(), graphQLScalarType);
+    }
+  }
+}

graphql-spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json

@@ -7,8 +7,12 @@
   "properties": [
     {
       "name": "graphql.extended-scalars",
-      "type": "java.util.Set",
+      "type": "java.util.Set<java.lang.String>",
       "description": "List of extended scalars to be used."
+    }, {
+      "name": "graphql.aliased-scalars",
+      "type": "java.util.Map<java.lang.String, java.util.List<java.lang.String>>",
+      "description": "Aliased scalar definitions."
     }
   ]
 }

graphql-spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

@@ -1,5 +1,6 @@
 org.springframework.context.ApplicationContextInitializer=\
-    graphql.kickstart.autoconfigure.scalars.GraphQLExtendedScalarsInitializer
+    graphql.kickstart.autoconfigure.scalars.GraphQLExtendedScalarsInitializer,\
+    graphql.kickstart.autoconfigure.scalars.GraphQLAliasedScalarsInitializer
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
     graphql.kickstart.autoconfigure.web.servlet.GraphQLWebAutoConfiguration,\
     graphql.kickstart.autoconfigure.web.servlet.GraphQLWebSecurityAutoConfiguration,\

graphql-spring-boot-autoconfigure/src/test/java/graphql/kickstart/autoconfigure/web/servlet/test/aliasedscalars/AliasedScalarConfigurationTest.java

@@ -0,0 +1,33 @@
+package graphql.kickstart.autoconfigure.web.servlet.test.aliasedscalars;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import graphql.schema.GraphQLScalarType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.ApplicationContext;
+import org.springframework.test.context.ActiveProfiles;
+
+@SpringBootTest(
+    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
+    classes = AliasedScalarConfigurationTest.AliasedScalarsTestApplication.class)
+@ActiveProfiles("aliased-scalars")
+@DisplayName("Testing aliased scalars auto configuration")
+class AliasedScalarConfigurationTest {
+
+  @Autowired private ApplicationContext applicationContext;
+
+  @Test
+  @DisplayName(
+      "The aliased scalars initializer should be properly picked up by Spring auto configuration.")
+  void testAutoConfiguration() {
+    assertThat(applicationContext.getBeansOfType(GraphQLScalarType.class))
+        .containsOnlyKeys("Decimal", "Number", "Text");
+  }
+
+  @SpringBootApplication
+  public static class AliasedScalarsTestApplication {}
+}

graphql-spring-boot-autoconfigure/src/test/java/graphql/kickstart/autoconfigure/web/servlet/test/aliasedscalars/AliasedScalarsIncorrectConfigurationTest.java

@@ -0,0 +1,63 @@
+package graphql.kickstart.autoconfigure.web.servlet.test.aliasedscalars;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import graphql.kickstart.autoconfigure.scalars.GraphQLExtendedScalarsInitializer;
+import graphql.schema.GraphQLScalarType;
+import java.util.Collections;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.WebApplicationType;
+import org.springframework.context.ApplicationContextException;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.core.env.MapPropertySource;
+import org.springframework.core.env.StandardEnvironment;
+
+@DisplayName("Testing aliased scalars configuration")
+class AliasedScalarsIncorrectConfigurationTest {
+
+  @Test
+  @DisplayName(
+      "Should throw exception at context initialization when a non-built in scalar was aliased.")
+  void shouldThrowErrorOnStartupIfScalarDoesNotExists() {
+    // GIVEN
+    final SpringApplication application = setupTestApplication(Collections.singletonMap(
+        "graphql.aliased-scalars.BugDecimal",
+        "Number"));
+    // THEN
+    assertThatExceptionOfType(ApplicationContextException.class)
+        .isThrownBy(application::run)
+        .withMessage(
+            "Scalar(s) 'BugDecimal' cannot be aliased."
+                + " Only the following scalars can be aliased by configuration: BigDecimal,"
+                + " BigInteger, Boolean, Byte, Char, Date, DateTime, Float, ID, Int, JSON,"
+                + " Locale, Long, NegativeFloat, NegativeInt, NonNegativeFloat, NonNegativeInt,"
+                + " NonPositiveFloat, NonPositiveInt, Object, PositiveFloat, PositiveInt, Short,"
+                + " String, Time, Url. Note that custom scalar beans cannot be aliased this way.");
+  }
+
+  @Test
+  @DisplayName("Should not create any aliased scalars by default.")
+  void shouldNotDeclareAnyAliasedScalarsByDefault() {
+    // GIVEN
+    final SpringApplication application = setupTestApplication(Collections.emptyMap());
+    // WHEN
+    final ConfigurableApplicationContext context = application.run();
+    // THEN
+    assertThat(context.getBeansOfType(GraphQLScalarType.class)).isEmpty();
+  }
+
+  private SpringApplication setupTestApplication(final Map<String, Object> properties) {
+    final StandardEnvironment standardEnvironment = new StandardEnvironment();
+    standardEnvironment.getPropertySources().addFirst(new MapPropertySource("testProperties",
+        properties));
+    final SpringApplication application =
+        new SpringApplication(GraphQLExtendedScalarsInitializer.class);
+    application.setWebApplicationType(WebApplicationType.NONE);
+    application.setEnvironment(standardEnvironment);
+    return application;
+  }
+}

graphql-spring-boot-autoconfigure/src/test/resources/application-aliased-scalars.yaml

@@ -0,0 +1,4 @@
+graphql:
+  aliased-scalars:
+    BigDecimal: Number, Decimal
+    String: Text