Merge pull request #75 from intuit/nested-fieldresolver

Adding support for nested field resolver

Author: ashpak-shaikh

src/main/java/com/intuit/graphql/orchestrator/batch/FieldResolverBatchLoader.java

@@ -3,32 +3,42 @@
 import static com.intuit.graphql.orchestrator.GraphQLOrchestrator.DATA_LOADER_REGISTRY_CONTEXT_KEY;
 import static com.intuit.graphql.orchestrator.resolverdirective.FieldResolverDirectiveUtil.createFieldResolverOperationName;
 import static graphql.language.AstPrinter.printAstCompact;
+import static graphql.schema.GraphQLTypeUtil.unwrapAll;
 
+import com.intuit.graphql.orchestrator.ServiceProvider;
+import com.intuit.graphql.orchestrator.datafetcher.ServiceDataFetcher;
 import com.intuit.graphql.orchestrator.fieldresolver.FieldResolverBatchSelectionSetSupplier;
+import com.intuit.graphql.orchestrator.fieldresolver.FieldResolverGraphQLError;
 import com.intuit.graphql.orchestrator.fieldresolver.QueryOperationFactory;
 import com.intuit.graphql.orchestrator.resolverdirective.ResolverDirectiveDefinition;
 import com.intuit.graphql.orchestrator.schema.GraphQLObjects;
+import com.intuit.graphql.orchestrator.schema.ServiceMetadata;
 import com.intuit.graphql.orchestrator.schema.transform.FieldResolverContext;
+import com.intuit.graphql.orchestrator.xtext.FieldContext;
 import graphql.ExecutionInput;
-import graphql.ExecutionResult;
-import graphql.GraphQL;
 import graphql.GraphQLContext;
-import graphql.execution.AsyncExecutionStrategy;
 import graphql.execution.DataFetcherResult;
+import graphql.language.AstTransformer;
 import graphql.language.Definition;
 import graphql.language.Document;
 import graphql.language.FragmentDefinition;
 import graphql.language.FragmentSpread;
 import graphql.language.OperationDefinition;
 import graphql.language.SelectionSet;
+import graphql.schema.DataFetcher;
 import graphql.schema.DataFetchingEnvironment;
+import graphql.schema.FieldCoordinates;
+import graphql.schema.GraphQLCodeRegistry;
+import graphql.schema.GraphQLFieldDefinition;
+import graphql.schema.GraphQLFieldsContainer;
+import graphql.schema.GraphQLObjectType;
 import graphql.schema.GraphQLSchema;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 import lombok.Builder;
 import org.apache.commons.collections4.CollectionUtils;
@@ -37,11 +47,6 @@
 
 public class FieldResolverBatchLoader implements BatchLoader<DataFetchingEnvironment, DataFetcherResult<Object>> {
 
-  private static final Function<GraphQLSchema, GraphQL> DEFAULT_GRAPHQL_BUILDER = schema -> GraphQL
-      .newGraphQL(schema)
-      .queryExecutionStrategy(new AsyncExecutionStrategy())
-      .build();
-
   private final QueryOperationModifier queryOperationModifier = new QueryOperationModifier();
 
   private final QueryResponseModifier queryResponseModifier = new DefaultQueryResponseModifier();
@@ -54,6 +59,8 @@ public class FieldResolverBatchLoader implements BatchLoader<DataFetchingEnviron
 
   private final QueryOperationFactory queryOperationFactory = new QueryOperationFactory();
 
+  private static final AstTransformer AST_TRANSFORMER = new AstTransformer();
+
   @Builder
   public FieldResolverBatchLoader(FieldResolverContext fieldResolverContext) {
     Objects.requireNonNull(fieldResolverContext, "fieldResolverContext is required");
@@ -71,31 +78,67 @@ public FieldResolverBatchLoader(FieldResolverContext fieldResolverContext) {
   public CompletionStage<List<DataFetcherResult<Object>>> load(final List<DataFetchingEnvironment> dataFetchingEnvironments) {
 
     String originalOperationName = dataFetchingEnvironments.get(0).getOperationDefinition().getName();
-    String operationName = createFieldResolverOperationName(originalOperationName);
+    String downstreamQueryOpName = createFieldResolverOperationName(originalOperationName);
 
     FieldResolverBatchSelectionSetSupplier fieldResolverBatchSelectionSetSupplier =
             new FieldResolverBatchSelectionSetSupplier(resolverSelectedFields, dataFetchingEnvironments, fieldResolverContext);
+    SelectionSet selectionSet = fieldResolverBatchSelectionSetSupplier.get();
+    OperationDefinition downstreamQueryOpDef = queryOperationFactory.create(downstreamQueryOpName, selectionSet);
 
-    OperationDefinition resolverQueryOpDef = queryOperationFactory.create(operationName, fieldResolverBatchSelectionSetSupplier);
+    ServiceMetadata serviceMetadata = getServiceMetadata(dataFetchingEnvironments.get(0));
+    if (serviceMetadata.hasFieldResolverDirective()) {
+      downstreamQueryOpDef = removeExternalFields(downstreamQueryOpDef, dataFetchingEnvironments.get(0), serviceMetadata);
+    }
 
     if (this.fieldResolverContext.isRequiresTypeNameInjection()) {
-      resolverQueryOpDef = queryOperationModifier.modifyQuery(
+      downstreamQueryOpDef = queryOperationModifier.modifyQuery(
           dataFetchingEnvironments.get(0).getGraphQLSchema(),
-          resolverQueryOpDef,
+          downstreamQueryOpDef,
           // each DFE have identical fragmentsByName since this is a batch call for same field
           // Arguments on the field with @resolver now allowed, set variables empty
           dataFetchingEnvironments.get(0).getFragmentsByName(), Collections.emptyMap());
     }
 
-    List<Definition<FragmentDefinition>> resolverQueryFragmentDefinitions =
+    List<Definition<FragmentDefinition>> downstreamQueryFragmentDefinitions =
         createResolverQueryFragmentDefinitions(dataFetchingEnvironments.get(0));
 
-    return execute(dataFetchingEnvironments.get(0), resolverQueryOpDef, resolverQueryFragmentDefinitions)
-        .thenApply(ExecutionResult::toSpecification)
+    ServiceProvider serviceProvider = serviceMetadata.getServiceProvider();
+    return execute(dataFetchingEnvironments.get(0), downstreamQueryOpDef, downstreamQueryFragmentDefinitions, serviceProvider)
         .thenApply(queryResponseModifier::modify)
         .thenApply(result -> batchResultTransformer.toBatchResult(result, dataFetchingEnvironments));
   }
 
+  private OperationDefinition removeExternalFields(OperationDefinition operationDefinition,
+      DataFetchingEnvironment dataFetchingEnvironment, ServiceMetadata serviceMetadata) {
+    GraphQLSchema graphQLSchema = dataFetchingEnvironment.getGraphQLSchema();
+    GraphQLObjectType rootType = graphQLSchema.getQueryType();
+    Map<String, FragmentDefinition> fragmentsByName = dataFetchingEnvironment.getFragmentsByName();
+    return (OperationDefinition) AST_TRANSFORMER.transform(operationDefinition,
+        new NoExternalReferenceSelectionSetModifier((GraphQLFieldsContainer) unwrapAll(rootType), serviceMetadata, fragmentsByName));
+  }
+
+  private ServiceMetadata getServiceMetadata(DataFetchingEnvironment dataFetchingEnvironment) {
+    GraphQLCodeRegistry graphQLCodeRegistry = dataFetchingEnvironment.getGraphQLSchema().getCodeRegistry();
+    GraphQLFieldDefinition graphQLFieldDefinition = dataFetchingEnvironment.getFieldDefinition();
+
+    FieldContext fieldContext = this.fieldResolverContext.getTargetFieldContext();
+    FieldCoordinates fieldCoordinates = fieldContext.getFieldCoordinates();
+
+    DataFetcher<?> dataFetcher = graphQLCodeRegistry.getDataFetcher(fieldCoordinates, graphQLFieldDefinition);
+    if (Objects.nonNull(dataFetcher) && dataFetcher instanceof ServiceDataFetcher) {
+      ServiceDataFetcher serviceDataFetcher = (ServiceDataFetcher) dataFetcher;
+      return serviceDataFetcher.getServiceMetadata();
+    } else {
+      throw FieldResolverGraphQLError.builder()
+          .errorMessage("ServiceDataFetcher not found.")
+          .fieldName(fieldCoordinates.getFieldName())
+          .parentTypeName(fieldCoordinates.getTypeName())
+          .resolverDirectiveDefinition(this.fieldResolverContext.getResolverDirectiveDefinition())
+          .serviceNameSpace(fieldResolverContext.getServiceNamespace())
+          .build();
+    }
+  }
+
   private List<Definition<FragmentDefinition>> createResolverQueryFragmentDefinitions(DataFetchingEnvironment dataFetchingEnvironment) {
     SelectionSet selectionSet = dataFetchingEnvironment.getField().getSelectionSet();
     if (selectionSet == null || CollectionUtils.isEmpty(selectionSet.getSelections())) {
@@ -109,9 +152,10 @@ private List<Definition<FragmentDefinition>> createResolverQueryFragmentDefiniti
         .collect(Collectors.toList());
   }
 
-  private CompletableFuture<ExecutionResult> execute(DataFetchingEnvironment dataFetchingEnvironment,
+  private CompletableFuture<Map<String, Object>> execute(DataFetchingEnvironment dataFetchingEnvironment,
       OperationDefinition resolverQueryOpDef,
-      List<Definition<FragmentDefinition>> resolverQueryFragmentDefs
+      List<Definition<FragmentDefinition>> resolverQueryFragmentDefs,
+      ServiceProvider serviceProvider
   ) {
     GraphQLContext context = dataFetchingEnvironment.getContext();
 
@@ -129,9 +173,7 @@ private CompletableFuture<ExecutionResult> execute(DataFetchingEnvironment dataF
         .operationName(resolverQueryOpDef.getName())
         .build();
 
-    GraphQL graphQL = DEFAULT_GRAPHQL_BUILDER.apply(dataFetchingEnvironment.getGraphQLSchema());
-
-    return graphQL.executeAsync(resolverQueryExecutionInput);
+    return serviceProvider.query(resolverQueryExecutionInput, dataFetchingEnvironment.getLocalContext());
   }
 
 }

src/main/java/com/intuit/graphql/orchestrator/batch/NoExternalReferenceSelectionSetModifier.java

@@ -15,6 +15,7 @@
 import graphql.language.InlineFragment;
 import graphql.language.Node;
 import graphql.language.NodeVisitorStub;
+import graphql.language.OperationDefinition;
 import graphql.language.SelectionSet;
 import graphql.schema.FieldCoordinates;
 import graphql.schema.GraphQLFieldDefinition;
@@ -89,6 +90,12 @@ public TraversalControl visitInlineFragment(InlineFragment node, TraverserContex
     return TraversalControl.CONTINUE;
   }
 
+  @Override
+  public TraversalControl visitOperationDefinition(OperationDefinition node, TraverserContext<Node> context) {
+    context.setVar(GraphQLType.class, rootType);
+    return TraversalControl.CONTINUE;
+  }
+
   @Override
   public TraversalControl visitSelectionSet(SelectionSet node, TraverserContext<Node> context) {
     GraphQLFieldsContainer parentType = (GraphQLFieldsContainer) getParentType(context);

src/main/java/com/intuit/graphql/orchestrator/fieldresolver/FieldResolverGraphQLError.java

@@ -0,0 +1,73 @@
+package com.intuit.graphql.orchestrator.fieldresolver;
+
+import com.intuit.graphql.orchestrator.resolverdirective.ResolverDirectiveDefinition;
+import graphql.ErrorType;
+import graphql.GraphqlErrorException;
+
+/**
+ * A class thrown when an error occured during field resolver graphql execution
+ */
+public class FieldResolverGraphQLError extends GraphqlErrorException {
+
+  private FieldResolverGraphQLError(FieldResolverGraphQLError.Builder builder) {
+    super(builder);
+  }
+
+  @Override
+  public ErrorType getErrorType() {
+    return ErrorType.ExecutionAborted;
+  }
+
+  public static FieldResolverGraphQLError.Builder builder() {
+    return new FieldResolverGraphQLError.Builder();
+  }
+
+  public static class Builder extends BuilderBase<FieldResolverGraphQLError.Builder, FieldResolverGraphQLError> {
+
+    private String errorMessage;
+
+    private String fieldName;
+    private String parentTypeName;
+    private ResolverDirectiveDefinition resolverDirectiveDefinition;
+    private String serviceNameSpace;
+
+    public Builder fieldName(String fieldName) {
+      this.fieldName = fieldName;
+      return this;
+    }
+
+    public Builder parentTypeName(String parentTypeName) {
+      this.parentTypeName = parentTypeName;
+      return this;
+    }
+
+    public Builder resolverDirectiveDefinition(ResolverDirectiveDefinition resolverDirectiveDefinition) {
+      this.resolverDirectiveDefinition = resolverDirectiveDefinition;
+      return this;
+    }
+
+    public Builder serviceNameSpace(String serviceNameSpace) {
+      this.serviceNameSpace = serviceNameSpace;
+      return this;
+    }
+
+    public Builder errorMessage(String errorMessage) {
+      this.errorMessage = errorMessage;
+      return this;
+    }
+
+    public FieldResolverGraphQLError build() {
+      String msgTemplate = "%s. "
+          + " fieldName=%s, "
+          + " parentTypeName=%s, "
+          + " resolverDirectiveDefinition=%s,"
+          + " serviceNameSpace=%s";
+
+      this.message = String.format(msgTemplate, errorMessage, fieldName, parentTypeName,
+          resolverDirectiveDefinition, serviceNameSpace);
+      this.errorClassification = ErrorType.DataFetchingException;
+      return new FieldResolverGraphQLError(this);
+    }
+  }
+
+}

src/main/java/com/intuit/graphql/orchestrator/fieldresolver/QueryOperationFactory.java

@@ -4,14 +4,12 @@
 import graphql.language.OperationDefinition.Operation;
 import graphql.language.SelectionSet;
 
-import java.util.function.Supplier;
-
 public class QueryOperationFactory {
 
-    public OperationDefinition create(String operationName, Supplier<SelectionSet> selectionSetSupplier) {
+    public OperationDefinition create(String operationName, SelectionSet selectionSet) {
         return OperationDefinition.newOperationDefinition()
                 .name(operationName)
-                .selectionSet(selectionSetSupplier.get())
+                .selectionSet(selectionSet)
                 .operation(Operation.QUERY)
                 .build();
 

src/main/java/com/intuit/graphql/orchestrator/xtext/FieldContext.java

@@ -1,5 +1,6 @@
 package com.intuit.graphql.orchestrator.xtext;
 
+import graphql.schema.FieldCoordinates;
 import java.util.Objects;
 import lombok.Getter;
 
@@ -8,10 +9,12 @@ public class FieldContext {
 
   private final String parentType;
   private final String fieldName;
+  private final FieldCoordinates fieldCoordinates;
 
   public FieldContext(String parentType, String fieldName) {
     this.parentType = parentType;
     this.fieldName = fieldName;
+    this.fieldCoordinates = FieldCoordinates.coordinates(parentType, fieldName);
   }
 
   @Override

src/test/groovy/com/intuit/graphql/orchestrator/integration/FieldResolverDirectiveNestedSpec.groovy renamed to src/test/groovy/com/intuit/graphql/orchestrator/integration/FieldResolverDirectiveTargetIsNestedFieldSpec.groovy

@@ -8,7 +8,7 @@ import graphql.ExecutionResult
 import helpers.BaseIntegrationTestSpecification
 import spock.lang.Subject
 
-class FieldResolverDirectiveNestedSpec extends BaseIntegrationTestSpecification {
+class FieldResolverDirectiveTargetIsNestedFieldSpec extends BaseIntegrationTestSpecification {
     def PERSON_DOWNSTREAM_QUERY = "query Get_Person {person {id} person {name}}";
     def BOOK_DOWNSTREAM_QUERY = "query Get_Person {person {book {id name author {lastName}}}}";
     def PETS_DOWNSTREAM_QUERY = "query Get_Person {person {pets {name}}}";
@@ -62,7 +62,7 @@ class FieldResolverDirectiveNestedSpec extends BaseIntegrationTestSpecification
                 .build();
     }
 
-    def "testFieldResolverInNestedField"() {
+    def "FieldResolver target is a nested field"() {
         given:
         specUnderTest = createGraphQLOrchestrator([mockPersonService, mockBookService, mockPetsService]);