graphql-java · bbakerman · Feb 24, 2022 · Sep 26, 2021 · Oct 4, 2021 · Oct 4, 2021
diff --git a/src/main/java/graphql/DirectivesUtil.java b/src/main/java/graphql/DirectivesUtil.java
@@ -2,23 +2,29 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import graphql.schema.GraphQLAppliedDirective;
 import graphql.schema.GraphQLArgument;
 import graphql.schema.GraphQLDirective;
+import graphql.schema.GraphQLDirectiveContainer;
 import graphql.util.FpKit;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
+import java.util.StringJoiner;
 import java.util.stream.Collectors;
 
 import static graphql.Assert.assertNotNull;
 import static graphql.collect.ImmutableKit.emptyList;
+import static java.util.stream.Collectors.toSet;
 
 @Internal
 public class DirectivesUtil {
 
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static Map<String, GraphQLDirective> nonRepeatableDirectivesByName(List<GraphQLDirective> directives) {
         // filter the repeatable directives
         List<GraphQLDirective> singletonDirectives = directives.stream()
@@ -27,11 +33,13 @@ public static Map<String, GraphQLDirective> nonRepeatableDirectivesByName(List<G
         return FpKit.getByName(singletonDirectives, GraphQLDirective::getName);
     }
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static Map<String, ImmutableList<GraphQLDirective>> allDirectivesByName(List<GraphQLDirective> directives) {
 
         return ImmutableMap.copyOf(FpKit.groupingBy(directives, GraphQLDirective::getName));
     }
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static Optional<GraphQLArgument> directiveWithArg(List<GraphQLDirective> directives, String directiveName, String argumentName) {
         GraphQLDirective directive = nonRepeatableDirectivesByName(directives).get(directiveName);
         GraphQLArgument argument = null;
@@ -42,6 +50,7 @@ public static Optional<GraphQLArgument> directiveWithArg(List<GraphQLDirective>
     }
 
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static boolean isAllNonRepeatable(List<GraphQLDirective> directives) {
         if (directives == null || directives.isEmpty()) {
             return false;
@@ -54,20 +63,23 @@ public static boolean isAllNonRepeatable(List<GraphQLDirective> directives) {
         return true;
     }
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static List<GraphQLDirective> add(List<GraphQLDirective> targetList, GraphQLDirective newDirective) {
         assertNotNull(targetList, () -> "directive list can't be null");
         assertNotNull(newDirective, () -> "directive can't be null");
         targetList.add(newDirective);
         return targetList;
     }
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static List<GraphQLDirective> addAll(List<GraphQLDirective> targetList, List<GraphQLDirective> newDirectives) {
         assertNotNull(targetList, () -> "directive list can't be null");
         assertNotNull(newDirectives, () -> "directive list can't be null");
         targetList.addAll(newDirectives);
         return targetList;
     }
 
+    @Deprecated // use GraphQLAppliedDirectives eventually
     public static GraphQLDirective getFirstDirective(String name, Map<String, List<GraphQLDirective>> allDirectivesByName) {
         List<GraphQLDirective> directives = allDirectivesByName.getOrDefault(name, emptyList());
         if (directives.isEmpty()) {
@@ -76,6 +88,43 @@ public static GraphQLDirective getFirstDirective(String name, Map<String, List<G
         return directives.get(0);
     }
 
+    /**
+     * This can take a collection of legacy directives and turn them applied directives, and combine them with any applied directives.  The applied
+     * directives collection takes precedence.
+     *
+     * @param directiveContainer the schema element holding applied directives
+     *
+     * @return a combined list unique by name
+     */
+    public static List<GraphQLAppliedDirective> toAppliedDirectives(GraphQLDirectiveContainer directiveContainer) {
+        return toAppliedDirectives(directiveContainer.getAppliedDirectives(), directiveContainer.getDirectives());
+    }
+
+    /**
+     * This can take a collection of legacy directives and turn them applied directives, and combine them with any applied directives.  The applied
+     * directives collection takes precedence.
+     *
+     * @param appliedDirectives the applied directives to use
+     * @param directives        the legacy directives to use
+     *
+     * @return a combined list unique by name
+     */
+    public static List<GraphQLAppliedDirective> toAppliedDirectives(Collection<GraphQLAppliedDirective> appliedDirectives, Collection<GraphQLDirective> directives) {
+        Set<String> named = appliedDirectives.stream()
+                .map(GraphQLAppliedDirective::getName).collect(toSet());
+
+        ImmutableList.Builder<GraphQLAppliedDirective> list = ImmutableList.<GraphQLAppliedDirective>builder()
+                .addAll(appliedDirectives);
+        // we only put in legacy directives if the list does not already contain them.  We need this mechanism
+        // (and not a map) because of repeated directives
+        directives.forEach(directive -> {
+            if (!named.contains(directive.getName())) {
+                list.add(directive.toAppliedDirective());
+            }
+        });
+        return list.build();
+    }
+
     /**
      * A holder class that breaks a list of directives into maps to be more easily accessible in using classes
      */
@@ -85,13 +134,20 @@ public static class DirectivesHolder {
         private final ImmutableMap<String, GraphQLDirective> nonRepeatableDirectivesByName;
         private final List<GraphQLDirective> allDirectives;
 
-        public DirectivesHolder(Collection<GraphQLDirective> allDirectives) {
+        private final ImmutableMap<String, List<GraphQLAppliedDirective>> allAppliedDirectivesByName;
+        private final List<GraphQLAppliedDirective> allAppliedDirectives;
+
+        public DirectivesHolder(Collection<GraphQLDirective> allDirectives, Collection<GraphQLAppliedDirective> allAppliedDirectives) {
             this.allDirectives = ImmutableList.copyOf(allDirectives);
             this.allDirectivesByName = ImmutableMap.copyOf(FpKit.groupingBy(allDirectives, GraphQLDirective::getName));
             // filter out the repeatable directives
             List<GraphQLDirective> nonRepeatableDirectives = allDirectives.stream()
                     .filter(d -> !d.isRepeatable()).collect(Collectors.toList());
             this.nonRepeatableDirectivesByName = ImmutableMap.copyOf(FpKit.getByName(nonRepeatableDirectives, GraphQLDirective::getName));
+
+            this.allAppliedDirectives = ImmutableList.copyOf(allAppliedDirectives);
+            this.allAppliedDirectivesByName = ImmutableMap.copyOf(FpKit.groupingBy(allAppliedDirectives, GraphQLAppliedDirective::getName));
+
         }
 
         public ImmutableMap<String, List<GraphQLDirective>> getAllDirectivesByName() {
@@ -112,11 +168,35 @@ public GraphQLDirective getDirective(String directiveName) {
                 return null;
             }
             return directiveList.get(0);
-
         }
 
         public List<GraphQLDirective> getDirectives(String directiveName) {
             return allDirectivesByName.getOrDefault(directiveName, emptyList());
         }
+
+        public ImmutableMap<String, List<GraphQLAppliedDirective>> getAllAppliedDirectivesByName() {
+            return allAppliedDirectivesByName;
+        }
+
+        public List<GraphQLAppliedDirective> getAppliedDirectives() {
+            return allAppliedDirectives;
+        }
+
+        public List<GraphQLAppliedDirective> getAppliedDirectives(String directiveName) {
+            return allAppliedDirectivesByName.getOrDefault(directiveName, emptyList());
+        }
+
+        public GraphQLAppliedDirective getAppliedDirective(String directiveName) {
+            List<GraphQLAppliedDirective> list = allAppliedDirectivesByName.getOrDefault(directiveName, emptyList());
+            return list.isEmpty() ? null : list.get(0);
+        }
+
+        @Override
+        public String toString() {
+            return new StringJoiner(", ", DirectivesHolder.class.getSimpleName() + "[", "]")
+                    .add("allDirectivesByName=" + String.join(",", allDirectivesByName.keySet()))
+                    .add("allAppliedDirectivesByName=" + String.join(",", allAppliedDirectivesByName.keySet()))
+                    .toString();
+        }
     }
 }
diff --git a/src/main/java/graphql/execution/directives/QueryAppliedDirective.java b/src/main/java/graphql/execution/directives/QueryAppliedDirective.java
@@ -0,0 +1,190 @@
+package graphql.execution.directives;
+
+
+import com.google.common.collect.ImmutableList;
+import graphql.PublicApi;
+import graphql.language.Directive;
+import graphql.schema.GraphQLArgument;
+import graphql.schema.GraphQLDirective;
+import graphql.schema.GraphqlTypeBuilder;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringJoiner;
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+
+import static graphql.Assert.assertNotNull;
+import static graphql.Assert.assertValidName;
+import static graphql.util.FpKit.getByName;
+
+/**
+ * An applied directive represents the instance of a directive that is applied to a query element such as a field or fragment.
+ * <p>
+ * Originally graphql-java re-used the {@link GraphQLDirective} and {@link GraphQLArgument}
+ * classes to do both purposes.  This was a modelling mistake.  New {@link QueryAppliedDirective} and {@link QueryAppliedDirectiveArgument}
+ * classes have been introduced to better model when a directive is applied to a query element,
+ * as opposed to its schema definition itself.
+ * <p>
+ * See http://graphql.org/learn/queries/#directives for more details on the concept.
+ */
+@PublicApi
+public class QueryAppliedDirective {
+
+    private final String name;
+    private final ImmutableList<QueryAppliedDirectiveArgument> arguments;
+    private final Directive definition;
+
+    private QueryAppliedDirective(String name, Directive definition, Collection<QueryAppliedDirectiveArgument> arguments) {
+        assertValidName(name);
+        assertNotNull(arguments, () -> "arguments can't be null");
+        this.name = name;
+        this.arguments = ImmutableList.copyOf(arguments);
+        this.definition = definition;
+    }
+
+    @Nonnull
+    public String getName() {
+        return name;
+    }
+
+    @Nullable
+    public String getDescription() {
+        return null;
+    }
+
+    public List<QueryAppliedDirectiveArgument> getArguments() {
+        return arguments;
+    }
+
+    @Nullable
+    public QueryAppliedDirectiveArgument getArgument(String name) {
+        for (QueryAppliedDirectiveArgument argument : arguments) {
+            if (argument.getName().equals(name)) {
+                return argument;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public Directive getDefinition() {
+        return definition;
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", QueryAppliedDirective.class.getSimpleName() + "[", "]")
+                .add("name='" + name + "'")
+                .add("arguments=" + arguments)
+                .add("definition=" + definition)
+                .toString();
+    }
+
+    /**
+     * This helps you transform the current GraphQLDirective into another one by starting a builder with all
+     * the current values and allows you to transform it how you want.
+     *
+     * @param builderConsumer the consumer code that will be given a builder to transform
+     *
+     * @return a new field based on calling build on that builder
+     */
+    public QueryAppliedDirective transform(Consumer<Builder> builderConsumer) {
+        Builder builder = newDirective(this);
+        builderConsumer.accept(builder);
+        return builder.build();
+    }
+
+    public static Builder newDirective() {
+        return new Builder();
+    }
+
+    public static Builder newDirective(QueryAppliedDirective existing) {
+        return new Builder(existing);
+    }
+
+    public static class Builder extends GraphqlTypeBuilder<Builder> {
+
+        private final Map<String, QueryAppliedDirectiveArgument> arguments = new LinkedHashMap<>();
+        private Directive definition;
+
+        public Builder() {
+        }
+
+        public Builder(QueryAppliedDirective existing) {
+            this.name = existing.getName();
+            this.description = existing.getDescription();
+            this.arguments.putAll(getByName(existing.getArguments(), QueryAppliedDirectiveArgument::getName));
+        }
+
+        public Builder argument(QueryAppliedDirectiveArgument argument) {
+            assertNotNull(argument, () -> "argument must not be null");
+            arguments.put(argument.getName(), argument);
+            return this;
+        }
+
+        public Builder replaceArguments(List<QueryAppliedDirectiveArgument> arguments) {
+            assertNotNull(arguments, () -> "arguments must not be null");
+            this.arguments.clear();
+            for (QueryAppliedDirectiveArgument argument : arguments) {
+                this.arguments.put(argument.getName(), argument);
+            }
+            return this;
+        }
+
+        /**
+         * Take an argument builder in a function definition and apply. Can be used in a jdk8 lambda
+         * e.g.:
+         * <pre>
+         *     {@code
+         *      argument(a -> a.name("argumentName"))
+         *     }
+         * </pre>
+         *
+         * @param builderFunction a supplier for the builder impl
+         *
+         * @return this
+         */
+        public Builder argument(UnaryOperator<QueryAppliedDirectiveArgument.Builder> builderFunction) {
+            QueryAppliedDirectiveArgument.Builder builder = QueryAppliedDirectiveArgument.newArgument();
+            builder = builderFunction.apply(builder);
+            return argument(builder);
+        }
+
+        /**
+         * Same effect as the argument(GraphQLAppliedDirectiveArgument). Builder.build() is called
+         * from within
+         *
+         * @param builder an un-built/incomplete GraphQLAppliedDirectiveArgument
+         *
+         * @return this
+         */
+        public Builder argument(QueryAppliedDirectiveArgument.Builder builder) {
+            return argument(builder.build());
+        }
+
+        /**
+         * This is used to clear all the arguments in the builder so far.
+         *
+         * @return the builder
+         */
+        public Builder clearArguments() {
+            arguments.clear();
+            return this;
+        }
+
+
+        public Builder definition(Directive definition) {
+            this.definition = definition;
+            return this;
+        }
+
+        public QueryAppliedDirective build() {
+            return new QueryAppliedDirective(name, this.definition, arguments.values());
+        }
+    }
+}