DataFetchResult generaton

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

@@ -103,6 +103,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();
 
 
@@ -193,6 +194,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(
@@ -815,6 +818,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

@@ -186,6 +186,9 @@ public class GraphQLCodegenMojo extends AbstractMojo implements GraphQLCodegenCo
     @Parameter
     private String[] fieldsToExcludeFromGeneration;
 
+    @Parameter
+    private String[] fieldsWithDataFetcherResult;
+
     @Parameter
     private RelayConfig relayConfig = new RelayConfig();
 
@@ -305,6 +308,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);
@@ -627,6 +631,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,14 +7,17 @@
 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 graphql.language.InputValueDefinition;
 import graphql.language.NullValue;
 
 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;
 
@@ -108,7 +111,8 @@ 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;
@@ -122,6 +126,9 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, String gra
         } else {
             langTypeName = DataModelMapper.getModelClassNameWithPrefixAndSuffix(mappingContext, graphQLType);
         }
+
+        langTypeName = wrapWithDataFetcherResultIfRequired(mappingContext, directives, langTypeName, name);
+
         if (serializeFieldsUsingObjectMapper.contains(graphQLType) ||
                 (name != null && parentTypeName != null &&
                         serializeFieldsUsingObjectMapper.contains(parentTypeName + "." + name))) {
@@ -164,4 +171,26 @@ public String wrapApiDefaultValueIfRequired(MappingContext mappingContext, Named
         }
     }
 
-}
+    private String wrapWithDataFetcherResultIfRequired(MappingContext mappingContext,
+                                                       List<Directive> directives,
+                                                       String langTypeName,
+                                                       String name) {
+        Set<String> fieldsWithDataFetcherResult = mappingContext.getFieldsWithDataFetcherResult();
+        Set<String> directivesNames = directives.stream()
+                .map(directive -> "@" + directive.getName())
+                .collect(Collectors.toSet());
+
+        // Create the representation of 'name'
+        String nameRepresentation = langTypeName + "." + name;
+
+        boolean shouldWrap = directivesNames.stream().anyMatch(fieldsWithDataFetcherResult::contains)
+                || fieldsWithDataFetcherResult.contains(langTypeName)
+                || fieldsWithDataFetcherResult.contains(nameRepresentation);
+
+        if (shouldWrap) {
+            langTypeName = "graphql.execution.DataFetcherResult<" + langTypeName + ">";
+        }
+
+        return langTypeName;
+    }
+}

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

@@ -146,7 +146,9 @@ 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

@@ -217,6 +217,23 @@ 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)
      *
@@ -231,12 +248,32 @@ 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(
@@ -247,8 +284,8 @@ public NamedDefinition getLanguageType(MappingContext mappingContext, Type<?> gr
             }
             return mappedCollectionType;
         } else if (graphqlType instanceof NonNullType) {
-            return getLanguageType(mappingContext, ((NonNullType) graphqlType).getType(), name, parentTypeName, true,
-                    collection);
+            return getLanguageType(mappingContext, ((NonNullType) graphqlType).getType(), name, parentTypeName,
+                    true, collection, directives);
         }
         throw new IllegalArgumentException("Unknown type: " + graphqlType);
     }
@@ -262,10 +299,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;
@@ -329,5 +368,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

@@ -65,6 +65,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;
@@ -195,6 +196,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);
@@ -622,6 +624,15 @@ public void setFieldsToExcludeFromGeneration(Set<String> fieldsToExcludeFromGene
         this.fieldsToExcludeFromGeneration = fieldsToExcludeFromGeneration;
     }
 
+    @Override
+    public Set<String> getFieldsWithDataFetcherResult() {
+        return fieldsWithDataFetcherResult;
+    }
+
+    public void setFieldsWithDataFetcherResult(Set<String> fieldsWithDataFetcherResult) {
+        this.fieldsWithDataFetcherResult = fieldsWithDataFetcherResult;
+    }
+
     @Override
     public String getQueryResolverParentInterface() {
         return queryResolverParentInterface;

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

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