graphql.schema.GraphQLAppliedDirective Maven / Gradle / Ivy
package graphql.schema;
import com.google.common.collect.ImmutableList;
import graphql.PublicApi;
import graphql.language.Directive;
import graphql.util.TraversalControl;
import graphql.util.TraverserContext;
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 schema element,
* as opposed to it definition
*
* A directive has a definition, that is what arguments it takes, and it can also be applied
* to other schema elements. Originally graphql-java re-used the {@link GraphQLDirective} and {@link GraphQLArgument}
* classes to do both purposes. This was a modelling mistake. New {@link GraphQLAppliedDirective} and {@link GraphQLAppliedDirectiveArgument}
* classes have been introduced to better model when a directive is applied to a schema element,
* as opposed to its schema definition itself.
*
* See https://graphql.org/learn/queries/#directives for more details on the concept.
*/
@PublicApi
public class GraphQLAppliedDirective implements GraphQLNamedSchemaElement {
private final String name;
private final ImmutableList arguments;
private final Directive definition;
public static final String CHILD_ARGUMENTS = "arguments";
private GraphQLAppliedDirective(String name, Directive definition, List arguments) {
assertValidName(name);
assertNotNull(arguments, () -> "arguments can't be null");
this.name = name;
this.arguments = ImmutableList.copyOf(arguments);
this.definition = definition;
}
@Override
public String getName() {
return name;
}
@Override
public String getDescription() {
return null;
}
public List getArguments() {
return arguments;
}
public GraphQLAppliedDirectiveArgument getArgument(String name) {
for (GraphQLAppliedDirectiveArgument argument : arguments) {
if (argument.getName().equals(name)) {
return argument;
}
}
return null;
}
public Directive getDefinition() {
return definition;
}
@Override
public String toString() {
return new StringJoiner(", ", GraphQLAppliedDirective.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 GraphQLAppliedDirective transform(Consumer builderConsumer) {
Builder builder = newDirective(this);
builderConsumer.accept(builder);
return builder.build();
}
@Override
public GraphQLSchemaElement copy() {
return newDirective(this).build();
}
@Override
public TraversalControl accept(TraverserContext context, GraphQLTypeVisitor visitor) {
return visitor.visitGraphQLAppliedDirective(this, context);
}
@Override
public List getChildren() {
return ImmutableList.copyOf(arguments);
}
@Override
public SchemaElementChildrenContainer getChildrenWithTypeReferences() {
return SchemaElementChildrenContainer.newSchemaElementChildrenContainer()
.children(CHILD_ARGUMENTS, arguments)
.build();
}
@Override
public GraphQLAppliedDirective withNewChildren(SchemaElementChildrenContainer newChildren) {
return transform(builder ->
builder.replaceArguments(newChildren.getChildren(CHILD_ARGUMENTS))
);
}
/**
* {@inheritDoc}
*/
@Override
public final boolean equals(Object o) {
return super.equals(o);
}
/**
* {@inheritDoc}
*/
@Override
public final int hashCode() {
return super.hashCode();
}
public static Builder newDirective() {
return new Builder();
}
public static Builder newDirective(GraphQLAppliedDirective existing) {
return new Builder(existing);
}
public static class Builder extends GraphqlTypeBuilder {
private final Map arguments = new LinkedHashMap<>();
private Directive definition;
public Builder() {
}
public Builder(GraphQLAppliedDirective existing) {
this.name = existing.getName();
this.description = existing.getDescription();
this.arguments.putAll(getByName(existing.getArguments(), GraphQLAppliedDirectiveArgument::getName));
}
public Builder argument(GraphQLAppliedDirectiveArgument argument) {
assertNotNull(argument, () -> "argument must not be null");
arguments.put(argument.getName(), argument);
return this;
}
public Builder replaceArguments(List arguments) {
assertNotNull(arguments, () -> "arguments must not be null");
this.arguments.clear();
for (GraphQLAppliedDirectiveArgument 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.:
*
* {@code
* argument(a -> a.name("argumentName"))
* }
*
*
* @param builderFunction a supplier for the builder impl
*
* @return this
*/
public Builder argument(UnaryOperator builderFunction) {
GraphQLAppliedDirectiveArgument.Builder builder = GraphQLAppliedDirectiveArgument.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(GraphQLAppliedDirectiveArgument.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 GraphQLAppliedDirective build() {
return new GraphQLAppliedDirective(name, this.definition, sort(arguments, GraphQLAppliedDirective.class, GraphQLAppliedDirectiveArgument.class));
}
}
}