DataFetchResult generaton

plugins/gradle/graphql-java-codegen-gradle-plugin/src/main/java/io/github/kobylynskyi/graphql/codegen/gradle/GraphQLCodegenGradleTask.java

@@ -101,6 +101,7 @@ public class GraphQLCodegenGradleTask extends DefaultTask implements GraphQLCode
     private Set<String> typesAsInterfaces = new HashSet<>();
     private Set<String> resolverArgumentAnnotations = new HashSet<>();
     private Set<String> parametrizedResolverAnnotations = new HashSet<>();
+    private Set<String> fieldsWithDataFetcherResult = new HashSet<>();
     private final RelayConfig relayConfig = new RelayConfig();
 
 
@@ -190,6 +191,8 @@ public void generate() throws Exception {
                 fieldsWithoutResolvers != null ? fieldsWithoutResolvers : new HashSet<>());
         mappingConfig.setFieldsToExcludeFromGeneration(
                 fieldsToExcludeFromGeneration != null ? fieldsToExcludeFromGeneration : new HashSet<>());
+        mappingConfig.setFieldsWithDataFetcherResult(
+                fieldsWithDataFetcherResult != null ? fieldsWithDataFetcherResult : new HashSet<>());
         mappingConfig.setTypesAsInterfaces(
                 typesAsInterfaces != null ? typesAsInterfaces : new HashSet<>());
         mappingConfig.setResolverArgumentAnnotations(
@@ -801,6 +804,17 @@ public void setFieldsToExcludeFromGeneration(Set<String> fieldsToExcludeFromGene
         this.fieldsToExcludeFromGeneration = fieldsToExcludeFromGeneration;
     }
 
+    @Input
+    @Optional
+    @Override
+    public Set<String> getFieldsWithDataFetcherResult() {
+        return fieldsWithDataFetcherResult;
+    }
+
+    public void setFieldsWithDataFetcherResult(Set<String> fieldsWithDataFetcherResult) {
+        this.fieldsWithDataFetcherResult = fieldsWithDataFetcherResult;
+    }
+
     @Input
     @Optional
     @Override

plugins/maven/graphql-java-codegen-maven-plugin/src/main/java/io/github/kobylynskyi/graphql/codegen/GraphQLCodegenMojo.java

@@ -183,6 +183,9 @@ public class GraphQLCodegenMojo extends AbstractMojo implements GraphQLCodegenCo
     @Parameter
     private String[] fieldsToExcludeFromGeneration;
 
+    @Parameter
+    private String[] fieldsWithDataFetcherResult;
+
     @Parameter
     private RelayConfig relayConfig = new RelayConfig();
 
@@ -301,6 +304,7 @@ public void execute() throws MojoExecutionException {
         mappingConfig.setFieldsWithResolvers(mapToHashSet(fieldsWithResolvers));
         mappingConfig.setFieldsWithoutResolvers(mapToHashSet(fieldsWithoutResolvers));
         mappingConfig.setFieldsToExcludeFromGeneration(mapToHashSet(fieldsToExcludeFromGeneration));
+        mappingConfig.setFieldsWithDataFetcherResult(mapToHashSet(fieldsWithDataFetcherResult));
         mappingConfig.setRelayConfig(relayConfig);
 
         mappingConfig.setGenerateClient(generateClient);
@@ -618,6 +622,11 @@ public Set<String> getFieldsToExcludeFromGeneration() {
         return mapToHashSet(fieldsToExcludeFromGeneration);
     }
 
+    @Override
+    public Set<String> getFieldsWithDataFetcherResult() {
+        return mapToHashSet(fieldsWithDataFetcherResult);
+    }
+
     @Override
     public Boolean getGenerateAllMethodInProjection() {
         return generateAllMethodInProjection;

src/main/java/com/kobylynskyi/graphql/codegen/java/JavaGraphQLTypeMapper.java

@@ -7,12 +7,15 @@
 import com.kobylynskyi.graphql.codegen.model.NamedDefinition;
 import com.kobylynskyi.graphql.codegen.model.graphql.GraphQLOperation;
 import com.kobylynskyi.graphql.codegen.utils.Utils;
+import graphql.language.Directive;
 
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import static java.util.Arrays.asList;
 
@@ -102,7 +105,7 @@ public boolean isPrimitive(String possiblyPrimitiveType) {
 
     @Override
     public NamedDefinition getLanguageType(MappingContext mappingContext, String graphQLType, String name,
-                                           String parentTypeName, boolean mandatory, boolean collection) {
+                                           String parentTypeName, boolean mandatory, boolean collection, List<Directive> directives) {
         Map<String, String> customTypesMapping = mappingContext.getCustomTypesMapping();
         Set<String> serializeFieldsUsingObjectMapper = mappingContext.getUseObjectMapperForRequestSerialization();
         String langTypeName;
@@ -116,6 +119,15 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, String gra
         } else {
             langTypeName = DataModelMapper.getModelClassNameWithPrefixAndSuffix(mappingContext, graphQLType);
         }
+
+        Set<String> fieldsWithDataFetcherResult = mappingContext.getFieldsWithDataFetcherResult();
+        Set<String> directivesNames = directives.stream()
+                .map(directive -> "@" + directive.getName())
+                .collect(Collectors.toSet());
+        if (directivesNames.stream().anyMatch(fieldsWithDataFetcherResult::contains)) {
+            langTypeName = wrapWithDataFetcherResult(langTypeName);
+        }
+
         if (serializeFieldsUsingObjectMapper.contains(graphQLType) ||
                 (name != null && parentTypeName != null &&
                         serializeFieldsUsingObjectMapper.contains(parentTypeName + "." + name))) {
@@ -126,4 +138,7 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, String gra
                 mandatory, primitiveCanBeUsed, serializeUsingObjectMapper);
     }
 
+    private String wrapWithDataFetcherResult(String typeName) {
+        return "graphql.execution.DataFetcherResult<" + typeName + ">";
+    }
 }

src/main/java/com/kobylynskyi/graphql/codegen/mapper/FieldDefinitionToParameterMapper.java

@@ -146,7 +146,7 @@ private ParameterDefinition mapField(MappingContext mappingContext,
                                          ExtendedFieldDefinition fieldDef,
                                          ExtendedDefinition<?, ?> parentDefinition) {
         NamedDefinition namedDefinition = graphQLTypeMapper
-                .getLanguageType(mappingContext, fieldDef.getType(), fieldDef.getName(), parentDefinition.getName());
+                .getLanguageType(mappingContext, fieldDef.getType(), fieldDef.getName(), parentDefinition.getName(), fieldDef.getDirectives());
 
         ParameterDefinition parameter = new ParameterDefinition();
         parameter.setName(dataModelMapper.capitalizeIfRestricted(mappingContext, fieldDef.getName()));

src/main/java/com/kobylynskyi/graphql/codegen/mapper/GraphQLTypeMapper.java

@@ -4,6 +4,7 @@
 import com.kobylynskyi.graphql.codegen.model.NamedDefinition;
 import com.kobylynskyi.graphql.codegen.model.RelayConfig;
 import com.kobylynskyi.graphql.codegen.model.definitions.ExtendedFieldDefinition;
+import graphql.com.google.common.collect.ImmutableList;
 import graphql.language.Argument;
 import graphql.language.Directive;
 import graphql.language.DirectivesContainer;
@@ -161,6 +162,21 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> gr
         return getLanguageType(mappingContext, graphqlType, name, parentTypeName, false, false);
     }
 
+    /**
+     * Convert GraphQL type to a corresponding language-specific type (java/scala/kotlin/etc)
+     *
+     * @param mappingContext Global mapping context
+     * @param graphqlType    GraphQL type
+     * @param name           GraphQL type name
+     * @param parentTypeName Name of the parent type
+     * @param directives     GraphQL field directives
+     * @return Corresponding language-specific type (java/scala/kotlin/etc)
+     */
+    public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> graphqlType, String name,
+                                           String parentTypeName, List<Directive> directives) {
+        return getLanguageType(mappingContext, graphqlType, name, parentTypeName, false, false, directives);
+    }
+
     /**
      * Convert GraphQL type to a corresponding language-specific type (java/scala/kotlin/etc)
      *
@@ -175,12 +191,30 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> gr
     public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> graphqlType,
                                            String name, String parentTypeName,
                                            boolean mandatory, boolean collection) {
+        return getLanguageType(mappingContext, graphqlType, name, parentTypeName, mandatory, collection, Collections.emptyList());
+    }
+
+    /**
+     * Convert GraphQL type to a corresponding language-specific type (java/scala/kotlin/etc)
+     *
+     * @param mappingContext Global mapping context
+     * @param graphqlType    GraphQL type
+     * @param name           GraphQL type name
+     * @param parentTypeName Name of the parent type
+     * @param mandatory      GraphQL type is non-null
+     * @param collection     GraphQL type is collection
+     * @param directives     GraphQL field directives
+     * @return Corresponding language-specific type (java/scala/kotlin/etc)
+     */
+    public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> graphqlType,
+                                           String name, String parentTypeName,
+                                           boolean mandatory, boolean collection, List<Directive> directives) {
         if (graphqlType instanceof TypeName) {
             return getLanguageType(mappingContext, ((TypeName) graphqlType).getName(), name, parentTypeName, mandatory,
-                    collection);
+                    collection, directives);
         } else if (graphqlType instanceof ListType) {
             NamedDefinition mappedCollectionType = getLanguageType(mappingContext, ((ListType) graphqlType).getType(),
-                    name, parentTypeName, false, true);
+                    name, parentTypeName, false, true, directives);
             if (mappedCollectionType.isInterfaceOrUnion() &&
                     isInterfaceOrUnion(mappingContext, parentTypeName)) {
                 mappedCollectionType.setJavaName(
@@ -192,7 +226,7 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> gr
             return mappedCollectionType;
         } else if (graphqlType instanceof NonNullType) {
             return getLanguageType(mappingContext, ((NonNullType) graphqlType).getType(), name, parentTypeName, true,
-                    collection);
+                    collection, directives);
         }
         throw new IllegalArgumentException("Unknown type: " + graphqlType);
     }
@@ -206,10 +240,12 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> gr
      * @param parentTypeName Name of the parent type
      * @param mandatory      GraphQL type is non-null
      * @param collection     GraphQL type is collection
+     * @param directives     GraphQL field directives
      * @return Corresponding language-specific type (java/scala/kotlin/etc)
      */
     public NamedDefinition getLanguageType(MappingContext mappingContext, String graphQLType, String name,
-                                           String parentTypeName, boolean mandatory, boolean collection) {
+                                           String parentTypeName, boolean mandatory, boolean collection,
+                                           List<Directive> directives) {
         Map<String, String> customTypesMapping = mappingContext.getCustomTypesMapping();
         Set<String> serializeFieldsUsingObjectMapper = mappingContext.getUseObjectMapperForRequestSerialization();
         String langTypeName;
@@ -273,5 +309,4 @@ protected boolean isInterfaceOrUnion(MappingContext mappingContext, String graph
         return mappingContext.getInterfacesName().contains(graphQLType) ||
                 mappingContext.getUnionsNames().contains(graphQLType);
     }
-
 }

src/main/java/com/kobylynskyi/graphql/codegen/model/GraphQLCodegenConfiguration.java

@@ -349,6 +349,21 @@ public interface GraphQLCodegenConfiguration {
      */
     Set<String> getFieldsToExcludeFromGeneration();
 
+    /**
+     * Fields that require DataFetcherResult.
+     *
+     * <p>Values should be defined here in format: TypeName, TypeName.fieldName, @directive
+     *
+     *
+     * <p>E.g.:
+     * <ul>
+     *   <li>{@code @dataFetcherResult}</li>
+     * </ul>
+     *
+     * @return Set of types and fields that should have DataFetcherResult.
+     */
+    Set<String> getFieldsWithDataFetcherResult();
+
     /**
      * Specifies whether return types of generated API interface should be wrapped into <code>java.util.Optional</code>
      *

src/main/java/com/kobylynskyi/graphql/codegen/model/MappingConfig.java

@@ -64,6 +64,7 @@ public class MappingConfig implements GraphQLCodegenConfiguration, Combinable<Ma
     private Set<String> fieldsWithResolvers = new HashSet<>();
     private Set<String> fieldsWithoutResolvers = new HashSet<>();
     private Set<String> fieldsToExcludeFromGeneration = new HashSet<>();
+    private Set<String> fieldsWithDataFetcherResult = new HashSet<>();
 
     // parent interfaces configs:
     private String queryResolverParentInterface;
@@ -192,6 +193,7 @@ public void combine(MappingConfig source) {
         parametrizedInputSuffix = getValueOrDefaultToThis(source,
                 GraphQLCodegenConfiguration::getParametrizedInputSuffix);
         fieldsWithResolvers = combineSet(fieldsWithResolvers, source.fieldsWithResolvers);
+        fieldsWithDataFetcherResult = combineSet(fieldsWithDataFetcherResult, source.fieldsWithDataFetcherResult);
         fieldsWithoutResolvers = combineSet(fieldsWithoutResolvers, source.fieldsWithoutResolvers);
         fieldsToExcludeFromGeneration = combineSet(fieldsToExcludeFromGeneration, source.fieldsToExcludeFromGeneration);
         customTypesMapping = combineMap(customTypesMapping, source.customTypesMapping);
@@ -606,6 +608,15 @@ public Set<String> getFieldsToExcludeFromGeneration() {
         return fieldsToExcludeFromGeneration;
     }
 
+    public void setFieldsWithDataFetcherResult(Set<String> fieldsWithDataFetcherResult) {
+        this.fieldsWithDataFetcherResult = fieldsWithDataFetcherResult;
+    }
+
+    @Override
+    public Set<String> getFieldsWithDataFetcherResult() {
+        return fieldsWithDataFetcherResult;
+    }
+
     public void setFieldsToExcludeFromGeneration(Set<String> fieldsToExcludeFromGeneration) {
         this.fieldsToExcludeFromGeneration = fieldsToExcludeFromGeneration;
     }

src/main/java/com/kobylynskyi/graphql/codegen/model/MappingContext.java

@@ -274,6 +274,11 @@ public Set<String> getFieldsToExcludeFromGeneration() {
         return config.getFieldsToExcludeFromGeneration();
     }
 
+    @Override
+    public Set<String> getFieldsWithDataFetcherResult() {
+        return config.getFieldsWithDataFetcherResult();
+    }
+
     @Override
     public Boolean getGenerateClient() {
         return config.getGenerateClient();

src/test/java/com/kobylynskyi/graphql/codegen/GraphQLCodegenFieldsWithDataFetcherTest.java

@@ -0,0 +1,71 @@
+package com.kobylynskyi.graphql.codegen;
+
+import com.kobylynskyi.graphql.codegen.java.JavaGraphQLCodegen;
+import com.kobylynskyi.graphql.codegen.model.MappingConfig;
+import com.kobylynskyi.graphql.codegen.utils.Utils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+
+import static com.kobylynskyi.graphql.codegen.TestUtils.getFileByName;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singleton;
+import static java.util.Collections.singletonList;
+import static java.util.stream.Collectors.toList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GraphQLCodegenFieldsWithDataFetcherTest {
+
+    private final File outputBuildDir = new File("build/generated");
+    private final File outputJavaClassesDir = new File("build/generated/com/github/graphql");
+    private final MappingConfig mappingConfig = new MappingConfig();
+
+    @BeforeEach
+    void init() {
+        mappingConfig.setPackageName("com.github.graphql");
+        mappingConfig.setFieldsWithDataFetcherResult(new HashSet<>(singleton("@dataFetcherResult")));
+    }
+
+    @AfterEach
+    void cleanup() {
+        Utils.deleteDir(outputBuildDir);
+    }
+
+    @Test
+    void generate_fieldsWithDataFetcherResult() throws Exception {
+        mappingConfig.getFieldsWithDataFetcherResult().add("orders");
+        mappingConfig.getFieldsWithDataFetcherResult().add("cart");
+
+        generate("src/test/resources/schemas/fields-with-data-fetcher-result.graphqls");
+
+        File[] files = Objects.requireNonNull(outputJavaClassesDir.listFiles());
+        Assertions.assertNotNull(files);
+
+        List<String> generatedFileNames = Arrays.stream(files).map(File::getName).sorted().collect(toList());
+        assertEquals(
+                asList("Cart.java", "Order.java", "QueryResolver.java", "User.java", "UserCurrentQueryResolver.java"),
+                generatedFileNames
+        );
+
+        File user = getFileByName(files, "User.java");
+        String userContext = Utils.getFileContent(user.getPath()).trim();
+
+        assertTrue(userContext.contains("java.util.List<graphql.execution.DataFetcherResult<Order>>"));
+        assertTrue(userContext.contains("graphql.execution.DataFetcherResult<Cart>"));
+    }
+
+    private void generate(String o) throws IOException {
+        new JavaGraphQLCodegen(singletonList(o), outputBuildDir, mappingConfig,
+                TestUtils.getStaticGeneratedInfo(mappingConfig))
+                .generate();
+    }
+}

src/test/resources/schemas/fields-with-data-fetcher-result.graphqls

@@ -0,0 +1,27 @@
+# A GraphQL schema provides a root type for each kind of operation.
+schema {
+    # The query root.
+    query: Query
+}
+
+type Query {
+    userCurrent: User
+}
+
+type User {
+    username: String!
+    email: String!
+    orders: [Order!]! @dataFetcherResult
+    cart: Cart! @dataFetcherResult
+}
+
+type Order {
+    number: String!
+    price: String!
+}
+
+type Cart {
+    id: Long!
+}
+
+directive @dataFetcherResult on FIELD_DEFINITION