hacktoberfest-2023 : Multiple resolver directive

Author: vkarthikeya

src/main/java/com/intuit/graphql/orchestrator/resolverdirective/FieldResolverDirectiveUtil.java

@@ -20,6 +20,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.intuit.graphql.orchestrator.resolverdirective.ResolverDirectiveDefinition.extractRequiredFieldsFrom;
 import static com.intuit.graphql.orchestrator.utils.XtextTypeUtils.getFieldDefinitions;
@@ -124,37 +125,35 @@ public static boolean isObjectOrInterfaceType(TypeDefinition typeDefinition) {
 
   public static List<FieldResolverContext> createFieldResolverContexts(
       TypeDefinition typeDefinition, XtextGraph xtextGraph) {
-
     List<FieldDefinition> childFields = getFieldDefinitions(typeDefinition);
-    return childFields.stream()
-        .map(childFieldDefinition -> {
-          List<Directive> directives = getResolverDirective(childFieldDefinition);
-
-          if (CollectionUtils.size(directives) > 1) {
-            throw new MultipleResolverDirectiveDefinition(CollectionUtils.size(directives));
-          }
-
-          if (CollectionUtils.size(directives) < 1) {
-            return Optional.<FieldResolverContext>empty();
-          }
-
-          ResolverDirectiveDefinition resolverDirectiveDefinition = ResolverDirectiveDefinition.from(directives.get(0));
-
-          FieldResolverContext fieldResolverContext = FieldResolverContext.builder()
-              //.fieldContext(new FieldContext(typeDefinition.getName(), childFieldDefinition.getName()))
-              .fieldDefinition(childFieldDefinition)
-              .parentTypeDefinition(typeDefinition)
-              .requiresTypeNameInjection(xtextGraph.requiresTypenameInjection())
-              .serviceNamespace(xtextGraph.getServiceProvider().getNameSpace())
-              .resolverDirectiveDefinition(resolverDirectiveDefinition)
-              .requiredFields(extractRequiredFieldsFrom(resolverDirectiveDefinition))
-              .build();
-
-          return Optional.of(fieldResolverContext);
-        })
-        .filter(Optional::isPresent)
-        .map(Optional::get)
-        .collect(Collectors.toList());
+
+    List<FieldResolverContext> contexts = childFields.stream()
+            .flatMap(childFieldDefinition -> {
+              List<Directive> directives = getResolverDirective(childFieldDefinition);
+
+              if (CollectionUtils.size(directives) < 1) {
+                return Stream.empty();
+              }
+
+              return directives.stream().map(directive -> {
+                ResolverDirectiveDefinition resolverDirectiveDefinition = ResolverDirectiveDefinition.from(directive);
+
+                FieldResolverContext fieldResolverContext = FieldResolverContext.builder()
+                        //.fieldContext(new FieldContext(typeDefinition.getName(), childFieldDefinition.getName()))
+                        .fieldDefinition(childFieldDefinition)
+                        .parentTypeDefinition(typeDefinition)
+                        .requiresTypeNameInjection(xtextGraph.requiresTypenameInjection())
+                        .serviceNamespace(xtextGraph.getServiceProvider().getNameSpace())
+                        .resolverDirectiveDefinition(resolverDirectiveDefinition)
+                        .requiredFields(extractRequiredFieldsFrom(resolverDirectiveDefinition))
+                        .build();
+
+                return fieldResolverContext;
+              });
+            })
+            .collect(Collectors.toList());
+
+    return contexts;
   }
 
   private static List<Directive> getResolverDirective(FieldDefinition fieldDefinition) {

src/main/java/com/intuit/graphql/orchestrator/resolverdirective/InvalidDirectivePairingException.java

@@ -0,0 +1,11 @@
+package com.intuit.graphql.orchestrator.resolverdirective;
+
+public class InvalidDirectivePairingException extends ResolverDirectiveException {
+
+  private static final String ERR_MSG = "Field %s in container type %s with resolver directive not allowed "
+      + "to have argument definitions.";
+
+  public InvalidDirectivePairingException(String fieldName, String containerName) {
+    super(String.format(ERR_MSG, fieldName, containerName));
+  }
+}

src/main/java/com/intuit/graphql/orchestrator/schema/transform/FieldResolverTransformerPreMerge.java

@@ -3,16 +3,19 @@
 import static com.intuit.graphql.orchestrator.resolverdirective.FieldResolverDirectiveUtil.canContainFieldResolverDirective;
 import static com.intuit.graphql.orchestrator.resolverdirective.FieldResolverDirectiveUtil.createFieldResolverContexts;
 
+import com.intuit.graphql.graphQL.Directive;
 import com.intuit.graphql.graphQL.FieldDefinition;
 import com.intuit.graphql.orchestrator.resolverdirective.ArgumentDefinitionNotAllowed;
 import com.intuit.graphql.orchestrator.resolverdirective.FieldResolverDirectiveUtil;
+import com.intuit.graphql.orchestrator.resolverdirective.InvalidDirectivePairingException;
 import com.intuit.graphql.orchestrator.resolverdirective.NotAValidLocationForFieldResolverDirective;
 import com.intuit.graphql.orchestrator.utils.XtextTypeUtils;
 import com.intuit.graphql.orchestrator.xtext.XtextGraph;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import org.apache.commons.collections4.CollectionUtils;
+import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
 
 public class FieldResolverTransformerPreMerge implements Transformer<XtextGraph, XtextGraph> {
@@ -39,21 +42,51 @@ public XtextGraph transform(XtextGraph sourceXtextGraph) {
   }
 
   private void validateFieldWithResolver(List<FieldResolverContext> fieldResolverContexts) {
-    fieldResolverContexts
-        .forEach(fieldResolverContext -> {
-          FieldDefinition fieldDefinition = fieldResolverContext.getFieldDefinition();
-          String fieldName = fieldDefinition.getName();
-          String parentTypeName = XtextTypeUtils.getParentTypeName(fieldDefinition);
-
-          EObject parentType = fieldDefinition.eContainer();
-          if (!(canContainFieldResolverDirective(parentType))) {
-            throw new NotAValidLocationForFieldResolverDirective(fieldName, parentTypeName);
-          }
-
-          if (hasArguments(fieldDefinition)) {
-            throw new ArgumentDefinitionNotAllowed(fieldName, parentTypeName);
-          }
-        });
+      fieldResolverContexts
+              .forEach(fieldResolverContext -> {
+                  FieldDefinition fieldDefinition = fieldResolverContext.getFieldDefinition();
+                  String fieldName = fieldDefinition.getName();
+                  String parentTypeName = XtextTypeUtils.getParentTypeName(fieldDefinition);
+
+                  EObject parentType = fieldDefinition.eContainer();
+                  if (!(canContainFieldResolverDirective(parentType))) {
+                      throw new NotAValidLocationForFieldResolverDirective(fieldName, parentTypeName);
+                  }
+
+                  if (hasArguments(fieldDefinition)) {
+                      throw new ArgumentDefinitionNotAllowed(fieldName, parentTypeName);
+                  }
+
+                  EList<Directive> directives = fieldDefinition.getDirectives();
+                  boolean hasResolverDirective = false;
+                  boolean hasExternalDirective = false;
+                  boolean hasProvidesDirective = false;
+                  boolean hasRequiresDirective = false;
+
+                  for (Directive directive : directives) {
+                      String directiveName = directive.getDefinition().getName();
+                      switch (directiveName) {
+                          case "resolver":
+                              hasResolverDirective = true;
+                              break;
+                          case "external":
+                              hasExternalDirective = true;
+                              break;
+                          case "provides":
+                              hasProvidesDirective = true;
+                              break;
+                          case "requires":
+                              hasRequiresDirective = true;
+                              break;
+                      }
+                  }
+
+                  if (hasResolverDirective) {
+                      if (hasExternalDirective || hasProvidesDirective || hasRequiresDirective) {
+                          throw new InvalidDirectivePairingException(fieldName, parentTypeName);
+                      }
+                  }
+              });
   }
 
   private boolean hasArguments(FieldDefinition fieldDefinition) {