fix: support a different arg name for plural args (#39)

Author: aaron-steinfeld

hypertrace-core-graphql-deserialization/src/main/java/org/hypertrace/core/graphql/deserialization/ArgumentDeserializationConfig.java

@@ -8,13 +8,22 @@ public interface ArgumentDeserializationConfig {
 
   String getArgumentKey();
 
+  default String getListArgumentKey() {
+    return getArgumentKey();
+  }
+
   Class<?> getArgumentSchema();
 
   default List<Module> jacksonModules() {
     return Collections.emptyList();
   }
 
   static ArgumentDeserializationConfig forPrimitive(String argKey, Class<?> argSchema) {
-    return new SimpleArgumentDeserializationConfig(argKey, argSchema);
+    return forPrimitive(argKey, argKey, argSchema);
+  }
+
+  static ArgumentDeserializationConfig forPrimitive(
+      String argKey, String listArgKey, Class<?> argSchema) {
+    return new SimpleArgumentDeserializationConfig(argKey, listArgKey, argSchema);
   }
 }

hypertrace-core-graphql-deserialization/src/main/java/org/hypertrace/core/graphql/deserialization/DefaultArgumentDeserializer.java

@@ -10,6 +10,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
@@ -23,7 +24,7 @@ class DefaultArgumentDeserializer implements ArgumentDeserializer {
   private static final Logger LOG = LoggerFactory.getLogger(DefaultArgumentDeserializer.class);
 
   private final ObjectMapper objectMapper;
-  private final Map<Class<?>, String> argKeyBySchema;
+  private final Map<Class<?>, ArgumentDeserializationConfig> configBySchema;
 
   @Inject
   DefaultArgumentDeserializer(Set<ArgumentDeserializationConfig> argumentDeserializationConfigs) {
@@ -35,39 +36,38 @@ class DefaultArgumentDeserializer implements ArgumentDeserializer {
                     .flatMap(Collection::stream))
             .collect(Collectors.toUnmodifiableSet());
 
-    this.argKeyBySchema =
+    this.configBySchema =
         argumentDeserializationConfigs.stream()
             .collect(
                 Collectors.toUnmodifiableMap(
-                    ArgumentDeserializationConfig::getArgumentSchema,
-                    ArgumentDeserializationConfig::getArgumentKey));
+                    ArgumentDeserializationConfig::getArgumentSchema, Function.identity()));
 
     this.objectMapper = JsonMapper.builder().addModules(jacksonModules).build();
   }
 
   @Override
   public <T> Optional<T> deserializeObject(Map<String, Object> arguments, Class<T> argSchema) {
-    return this.argumentKeyForSchema(argSchema)
+    return this.argumentKey(argSchema)
         .flatMap(key -> this.deserializeValue(arguments.get(key), argSchema));
   }
 
   @Override
   public <T> Optional<List<T>> deserializeObjectList(
       Map<String, Object> arguments, Class<T> argSchema) {
-    return this.argumentKeyForSchema(argSchema)
+    return this.listArgumentKey(argSchema)
         .flatMap(key -> this.deserializeValueList(arguments.get(key), argSchema));
   }
 
   @Override
   public <T> Optional<T> deserializePrimitive(
       Map<String, Object> arguments, Class<? extends PrimitiveArgument<T>> argSchema) {
-    return this.argumentKeyForSchema(argSchema).map(key -> this.uncheckedCast(arguments.get(key)));
+    return this.argumentKey(argSchema).map(key -> this.uncheckedCast(arguments.get(key)));
   }
 
   @Override
   public <T> Optional<List<T>> deserializePrimitiveList(
       Map<String, Object> arguments, Class<? extends PrimitiveArgument<T>> argSchema) {
-    return this.argumentKeyForSchema(argSchema)
+    return this.listArgumentKey(argSchema)
         .flatMap(key -> this.logIfNotList(arguments.get(key)));
   }
 
@@ -81,8 +81,16 @@ private <T> Optional<T> deserializeValue(@Nullable Object rawValue, Class<T> arg
     }
   }
 
-  private Optional<String> argumentKeyForSchema(Class<?> argSchema) {
-    return Optional.ofNullable(this.argKeyBySchema.get(argSchema))
+  private Optional<String> argumentKey(Class<?> argSchema) {
+    return configForSchema(argSchema).map(ArgumentDeserializationConfig::getArgumentKey);
+  }
+
+  private Optional<String> listArgumentKey(Class<?> argSchema) {
+    return configForSchema(argSchema).map(ArgumentDeserializationConfig::getListArgumentKey);
+  }
+
+  private Optional<ArgumentDeserializationConfig> configForSchema(Class<?> argSchema) {
+    return Optional.ofNullable(this.configBySchema.get(argSchema))
         .or(
             () -> {
               LOG.warn(

hypertrace-core-graphql-deserialization/src/main/java/org/hypertrace/core/graphql/deserialization/SimpleArgumentDeserializationConfig.java

@@ -5,5 +5,6 @@
 @Value
 class SimpleArgumentDeserializationConfig implements ArgumentDeserializationConfig {
   String argumentKey;
+  String listArgumentKey;
   Class<?> argumentSchema;
 }

hypertrace-core-graphql-deserialization/src/test/java/org/hypertrace/core/graphql/deserialization/DefaultArgumentDeserializerTest.java

@@ -12,16 +12,14 @@
 import java.util.Set;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.junit.jupiter.MockitoExtension;
 
-@ExtendWith(MockitoExtension.class)
 class DefaultArgumentDeserializerTest {
 
   private DefaultArgumentDeserializer argumentDeserializer;
 
   private interface TestPrimitiveArgument extends PrimitiveArgument<String> {
     String ARG_NAME = "primitiveArg";
+    String LIST_ARG_NAME = "primitiveArgs";
   }
 
   private interface TestObjectArgument {
@@ -46,17 +44,10 @@ void beforeEach() {
     this.argumentDeserializer =
         new DefaultArgumentDeserializer(
             Set.of(
-                new ArgumentDeserializationConfig() {
-                  @Override
-                  public String getArgumentKey() {
-                    return TestPrimitiveArgument.ARG_NAME;
-                  }
-
-                  @Override
-                  public Class<?> getArgumentSchema() {
-                    return TestPrimitiveArgument.class;
-                  }
-                },
+                ArgumentDeserializationConfig.forPrimitive(
+                    TestPrimitiveArgument.ARG_NAME,
+                    TestPrimitiveArgument.LIST_ARG_NAME,
+                    TestPrimitiveArgument.class),
                 new ArgumentDeserializationConfig() {
                   @Override
                   public String getArgumentKey() {
@@ -166,22 +157,29 @@ void deserializePrimitive() {
   void emptyIfNoPrimitivePresent() {
     assertEquals(
         Optional.empty(),
-        this.argumentDeserializer.deserializeObject(
+        this.argumentDeserializer.deserializePrimitive(
             Collections.emptyMap(), TestPrimitiveArgument.class));
   }
 
   @Test
   void deserializePrimitiveList() {
     Map<String, Object> argMap =
-        Map.of(TestPrimitiveArgument.ARG_NAME, List.of("foo", "bar", "baz"));
+        Map.of(TestPrimitiveArgument.LIST_ARG_NAME, List.of("foo", "bar", "baz"));
     assertEquals(
         Optional.of(List.of("foo", "bar", "baz")),
         this.argumentDeserializer.deserializePrimitiveList(argMap, TestPrimitiveArgument.class));
+
+    // Make sure only the list arg name works
+    argMap =
+        Map.of(TestPrimitiveArgument.ARG_NAME, List.of("foo", "bar", "baz"));
+    assertEquals(
+        Optional.empty(),
+        this.argumentDeserializer.deserializePrimitiveList(argMap, TestPrimitiveArgument.class));
   }
 
   @Test
   void emptyListForEmptyPrimitiveList() {
-    Map<String, Object> argMap = Map.of(TestPrimitiveArgument.ARG_NAME, List.of());
+    Map<String, Object> argMap = Map.of(TestPrimitiveArgument.LIST_ARG_NAME, List.of());
     assertEquals(
         Optional.of(List.of()),
         this.argumentDeserializer.deserializePrimitiveList(argMap, TestPrimitiveArgument.class));