Merge pull request #186 from yarinvak/add-directive-creation

Add directive creation

Author: yarinvak

README.md

@@ -322,6 +322,67 @@ GraphQLAnnotations.register(new UUIDTypeFunction())
 
 You can also specify custom type function for any field with `@GraphQLType` annotation.
 
+## Directives
+You can wire your fields using directives with annotations.
+We allow both defining directives using annotations, and wiring fields.
+
+### Creating/Defining a ``GraphQLDirective``
+In order to create a directive, you first have to create a class that the directive will be created from.
+For example:
+
+```java
+    @GraphQLName("upper")
+    @GraphQLDescription("upper")
+    @DirectiveLocations({Introspection.DirectiveLocation.FIELD_DEFINITION, Introspection.DirectiveLocation.INTERFACE})
+    public static class UpperDirective {
+        private boolean isActive = true;
+    }
+```
+
+The name of the directive will be taken from the ``@GraphQLName`` annotation (if not specified, the name will be the class's name).
+The description of the directive will be taken from the ``@GraphQLDescription`` annotation's value.
+The valid locations of the directive (locations which the directive can be applied on) will be taken from ``@DirectiveLocations``.
+The arguments of the directive will be taken from the fields defined in the class - notice that you can only use primitive types as arguments of a directive.
+For example, we defined an ``isActive`` field - which is boolean, and its default value is true. That's how the argument of the directive will be defined.
+You can also use ``@GraphQLName`` and ``@GraphQLDescription`` annotations on the field.
+
+After you created the class, you will be able to create the ``GraphQLDirective`` object using the following code:
+```java
+GraphQLAnnotations.directive(UpperDirective.class);
+```
+
+### Wiring with directives
+Using directives you will be able to wire fields and more, for example, changing the data fetchers of the fields.
+
+In order to define a wiring functionality, you have to create a Wiring class matching one of you directives. For example:
+```java
+public class UpperWiring implements AnnotationsDirectiveWiring {
+        @Override
+        public GraphQLFieldDefinition onField(AnnotationsWiringEnvironment environment) {
+            GraphQLFieldDefinition field = (GraphQLFieldDefinition) environment.getElement();
+            boolean isActive = (boolean) environment.getDirective().getArgument("isActive").getValue();
+            DataFetcher dataFetcher = DataFetcherFactories.wrapDataFetcher(field.getDataFetcher(), (((dataFetchingEnvironment, value) -> {
+                if (value instanceof String && isActive) {
+                    return ((String) value).toUpperCase();
+                }
+                return value;
+            })));
+            return field.transform(builder -> builder.dataFetcher(dataFetcher));
+        }
+    }
+```
+This class turns your string field to upper case if the directive argument "isActive" is set to true.
+Now, you have to wire the field itself:
+```java
+@GraphQLField
+@GraphQLDirectives(@Directive(name = "upperCase", wiringClass = UpperWiring.class, argumentsValues = {"true"}))
+public static String name() {
+    return "yarin";
+}
+```
+We now wired the field "name" - so it will turn upper case when calling the field.
+The ``Directive`` annotations requires the name of the directive, the wiring class (the ``UpperWiring`` class defined earlier), and the values of the arguments. If an argument has a default value, you don't have to supply a value in the arguments values.
+
 ## Relay support
 
 ### Mutations

build.gradle

@@ -69,7 +69,7 @@ gradle.projectsEvaluated {
 
 dependencies {
     compile 'javax.validation:validation-api:1.1.0.Final'
-    compile 'com.graphql-java:graphql-java:9.1'
+    compile 'com.graphql-java:graphql-java:9.2'
 
     // OSGi
     compileOnly 'org.osgi:org.osgi.core:6.0.0'

src/main/java/graphql/annotations/directives/creation/DirectiveLocations.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2016 Yurii Rashkovskii
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ */
+package graphql.annotations.directives.creation;
+
+import graphql.introspection.Introspection;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DirectiveLocations {
+    Introspection.DirectiveLocation[] value();
+}

src/main/java/graphql/annotations/processor/GraphQLAnnotations.java

@@ -15,6 +15,9 @@
 package graphql.annotations.processor;
 
 import graphql.annotations.annotationTypes.GraphQLName;
+import graphql.annotations.processor.directives.CommonPropertiesCreator;
+import graphql.annotations.processor.directives.DirectiveArgumentCreator;
+import graphql.annotations.processor.directives.DirectiveCreator;
 import graphql.annotations.processor.exceptions.GraphQLAnnotationsException;
 import graphql.annotations.processor.graphQLProcessors.GraphQLAnnotationsProcessor;
 import graphql.annotations.processor.graphQLProcessors.GraphQLInputProcessor;
@@ -42,6 +45,7 @@ public class GraphQLAnnotations implements GraphQLAnnotationsProcessor {
 
     private GraphQLObjectHandler graphQLObjectHandler;
     private GraphQLExtensionsHandler graphQLExtensionsHandler;
+    private DirectiveCreator directiveCreator;
 
     private ProcessingElementsContainer container;
 
@@ -78,6 +82,10 @@ public GraphQLAnnotations() {
         this.graphQLObjectHandler = objectHandler;
         this.graphQLExtensionsHandler = extensionsHandler;
         this.container = new ProcessingElementsContainer(defaultTypeFunction);
+
+        DirectiveArgumentCreator directiveArgumentCreator = new DirectiveArgumentCreator(new CommonPropertiesCreator(),
+                container.getDefaultTypeFunction(), container);
+        this.directiveCreator = new DirectiveCreator(directiveArgumentCreator, new CommonPropertiesCreator());
     }
 
     public GraphQLAnnotations(TypeFunction defaultTypeFunction, GraphQLObjectHandler graphQLObjectHandler, GraphQLExtensionsHandler graphQLExtensionsHandler) {
@@ -125,6 +133,18 @@ public static GraphQLObjectType object(Class<?> object, GraphQLDirective... dire
         }
     }
 
+    public static GraphQLDirective directive(Class<?> object) throws GraphQLAnnotationsException {
+        GraphQLAnnotations instance = getInstance();
+
+        try {
+            return instance.directiveCreator.getDirective(object);
+        } catch (GraphQLAnnotationsException e) {
+            instance.getContainer().getProcessing().clear();
+            instance.getTypeRegistry().clear();
+            throw e;
+        }
+    }
+
     public void registerTypeExtension(Class<?> objectClass) {
         graphQLExtensionsHandler.registerTypeExtension(objectClass, container);
     }

src/main/java/graphql/annotations/processor/directives/CommonPropertiesCreator.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2016 Yurii Rashkovskii
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ */
+package graphql.annotations.processor.directives;
+
+import graphql.annotations.annotationTypes.GraphQLDescription;
+import graphql.annotations.annotationTypes.GraphQLName;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+
+public class CommonPropertiesCreator {
+    public String getDescription(AnnotatedElement annotatedElement) {
+        GraphQLDescription graphQLDescriptionAnnotation = annotatedElement.getAnnotation(GraphQLDescription.class);
+        if (graphQLDescriptionAnnotation != null) {
+            return graphQLDescriptionAnnotation.value();
+        }
+        return null;
+    }
+
+    public String getName(AnnotatedElement annotatedElement) {
+        GraphQLName graphQLNameAnnotation = annotatedElement.getAnnotation(GraphQLName.class);
+        if (graphQLNameAnnotation != null) {
+            return graphQLNameAnnotation.value();
+        } else if (annotatedElement instanceof Class<?>) {
+            return ((Class<?>) annotatedElement).getSimpleName();
+        } else if (annotatedElement instanceof Field) {
+            return ((Field) annotatedElement).getName();
+        }
+        return null;
+    }
+}

src/main/java/graphql/annotations/processor/directives/DirectiveArgumentCreator.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2016 Yurii Rashkovskii
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ */
+package graphql.annotations.processor.directives;
+
+import graphql.annotations.processor.ProcessingElementsContainer;
+import graphql.annotations.processor.exceptions.GraphQLAnnotationsException;
+import graphql.annotations.processor.typeFunctions.TypeFunction;
+import graphql.schema.GraphQLArgument;
+import graphql.schema.GraphQLInputType;
+
+import java.lang.reflect.Field;
+
+import static graphql.schema.GraphQLArgument.newArgument;
+
+public class DirectiveArgumentCreator {
+    private CommonPropertiesCreator commonPropertiesCreator;
+    private TypeFunction typeFunction;
+    private ProcessingElementsContainer container;
+
+    public DirectiveArgumentCreator(CommonPropertiesCreator commonPropertiesCreator, TypeFunction typeFunction, ProcessingElementsContainer container) {
+        this.commonPropertiesCreator = commonPropertiesCreator;
+        this.typeFunction = typeFunction;
+        this.container = container;
+    }
+
+
+    public GraphQLArgument getArgument(Field field, Class<?> containingClass) {
+        GraphQLArgument.Builder builder = newArgument()
+                .name(commonPropertiesCreator.getName(field))
+                .description(commonPropertiesCreator.getDescription(field))
+                .type(getType(field));
+        try {
+            builder.defaultValue(getDefaultValue(field, containingClass));
+        } catch (IllegalAccessException | InstantiationException e) {
+            throw new GraphQLAnnotationsException(e);
+        }
+
+        return builder.build();
+    }
+
+    private Object getDefaultValue(Field field, Class<?> containingClass) throws IllegalAccessException, InstantiationException {
+        field.setAccessible(true);
+        Object object = containingClass.newInstance();
+        return field.get(object);
+    }
+
+    private GraphQLInputType getType(Field field) {
+        return (GraphQLInputType) typeFunction.buildType(true, field.getType(),
+                field.getAnnotatedType(), container);
+    }
+
+
+}

src/main/java/graphql/annotations/processor/directives/DirectiveCreator.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2016 Yurii Rashkovskii
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ */
+package graphql.annotations.processor.directives;
+
+import graphql.annotations.directives.creation.DirectiveLocations;
+import graphql.annotations.processor.exceptions.GraphQLAnnotationsException;
+import graphql.introspection.Introspection;
+import graphql.schema.GraphQLDirective;
+
+import java.util.Arrays;
+
+import static graphql.schema.GraphQLDirective.newDirective;
+
+public class DirectiveCreator {
+
+    private DirectiveArgumentCreator directiveArgumentCreator;
+    private CommonPropertiesCreator commonPropertiesCreator;
+
+
+    public DirectiveCreator(DirectiveArgumentCreator directiveArgumentCreator, CommonPropertiesCreator commonPropertiesCreator) {
+        this.directiveArgumentCreator = directiveArgumentCreator;
+        this.commonPropertiesCreator = commonPropertiesCreator;
+    }
+
+    public GraphQLDirective getDirective(Class<?> annotatedClass) {
+        GraphQLDirective.Builder builder = newDirective()
+        .name(commonPropertiesCreator.getName(annotatedClass))
+        .description(commonPropertiesCreator.getDescription(annotatedClass));
+        Introspection.DirectiveLocation[] validLocations = getValidLocations(annotatedClass);
+        if (validLocations == null || validLocations.length == 0) {
+            throw new GraphQLAnnotationsException("No valid locations defined on directive", null);
+        }
+        builder.validLocations(validLocations);
+        buildArguments(builder, annotatedClass);
+
+        return builder.build();
+    }
+
+    private void buildArguments(GraphQLDirective.Builder builder, Class<?> annotatedClass) {
+        Arrays.stream(annotatedClass.getDeclaredFields()).forEach(x ->
+                builder.argument(directiveArgumentCreator.getArgument(x, annotatedClass)));
+    }
+
+
+    private Introspection.DirectiveLocation[] getValidLocations(Class<?> annotatedClass) {
+        DirectiveLocations directiveLocationsAnnotation = annotatedClass.getAnnotation(DirectiveLocations.class);
+        if (directiveLocationsAnnotation != null) {
+            return directiveLocationsAnnotation.value();
+        }
+        return null;
+    }
+
+}