Added support for GraphQL Union type. Version bump to 0.1.0

Antoine Boyer · Antoine Boyer · commit 10ca51252cb0 · 2016-02-22T19:15:06.000+01:00
diff --git a/build.gradle b/build.gradle
@@ -1,6 +1,6 @@
 description = "GraphQL schema to Code"
 
-version = '0.0.1'
+version = '0.1.0'
 group = 'com.graphql_codegen'
 
 buildscript {
@@ -34,6 +34,7 @@ dependencies {
     compile 'com.samskivert:jmustache:1.11'
     compile 'io.airlift:airline:0.7'
     compile 'com.mashape.unirest:unirest-java:1.4.7'
+    compile 'com.graphql-java:graphql-java:2.0.0'
 
     testCompile group: 'junit', name: 'junit', version: '4.11'
     testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
diff --git a/src/main/java/graphql_codegen/builder/java/JavaGenerator.java b/src/main/java/graphql_codegen/builder/java/JavaGenerator.java
@@ -34,9 +34,7 @@ public Code convertFromGraphQLTypeToCode(GraphQLTypeDescription type) {
                 return convertGraphQLInterfaceTypeToCode(type);
             case ENUM:
                 return convertFromGraphQLEnumTypeToCode(type);
-            case UNION:
-                System.out.println("Unable to handle " + type.getKind() + " with name " + type.getName());
-                return null;
+            case UNION: // is handled with generic types
             default:
                 return null;
         }
@@ -206,6 +204,8 @@ public static JavaTypeReference getJavaTypeReference(GraphQLTypeDescription type
                     return new JavaTypeReference("INVALID_TYPE");
                 }
                 return getJavaTypeReference(type.getOfType());
+            case UNION:
+                return new JavaTypeReference(Util.capitalizeFirstLetter(type.getName()), true);
             default:
                 return new JavaTypeReference(Util.capitalizeFirstLetter(type.getName()));
         }
diff --git a/src/main/java/graphql_codegen/builder/java/JavaType.java b/src/main/java/graphql_codegen/builder/java/JavaType.java
@@ -2,10 +2,9 @@
 
 import graphql_codegen.Util;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -19,18 +18,20 @@ public class JavaType extends JavaCode {
     private final String superClass;
     private final List<JavaField> members;
     private final List<JavaTypeReference> inheritedTypes;
+    private final List<String> genericTypes;  // contains the generic types in  "class SomeClass<Type1,Type2>"
     private final boolean serializable;
     private final String description;
 
     private JavaType(String superClass, Set<String> imports,
                      List<JavaTypeReference> inheritedTypes, List<JavaField> members,
-                     String name, String packagePath, boolean serializable, String description) {
+                     String name, String packagePath, List<String> genericTypes, boolean serializable, String description) {
         this.superClass = superClass;
         this.imports = imports;
         this.inheritedTypes = inheritedTypes;
         this.members = members;
         this.name = name;
         this.packagePath = packagePath;
+        this.genericTypes = genericTypes;
         this.serializable = serializable;
         this.description = description;
     }
@@ -72,27 +73,31 @@ public String getDescription() {
         return description;
     }
 
+    public List<String> getGenericTypes() {
+        return genericTypes;
+    }
+
     public static Builder newJavaTypeBuilder() {
         return new Builder();
     }
 
     public static class Builder {
         private String superClass;
         private List<JavaTypeReference> inheritedTypes;
-        private List<JavaField> members;
+        private List<JavaField> members = new ArrayList<>();
         private String name;
         private String packagePath;
         private boolean serializable;
         private String description;
         private Map<String, String> typeNameToPackageOverrideMap = new HashMap<>();
+        private List<String> genericTypes;
 
         public Builder withImportMapOverride(Map<String,String> typeNameToPackageOverrideMap) {
             checkNotNull(typeNameToPackageOverrideMap);
             this.typeNameToPackageOverrideMap = typeNameToPackageOverrideMap;
             return this;
         }
 
-
         public Builder addImportOverride(String typeName, String packagePath) {
             typeNameToPackageOverrideMap.put(typeName, packagePath);
             return this;
@@ -109,7 +114,7 @@ public Builder withInheritedTypes(List<JavaTypeReference> inheritedTypes) {
         }
 
         public Builder withMembers(List<JavaField> members) {
-            this.members = members;
+            this.members.addAll(members);
             return this;
         }
 
@@ -134,7 +139,21 @@ public Builder withDescription(String description) {
         }
 
         public JavaType build() {
-            return new JavaType(superClass, buildImports(members, inheritedTypes, typeNameToPackageOverrideMap), inheritedTypes, members, name, packagePath, serializable, description);
+
+            Stream<String> membersStream = members.stream()
+                    .filter(javaField -> javaField.getTypeReference() != null && javaField.getTypeReference().isGeneric())
+                    .map(javaField -> javaField.getTypeReference().getTypeName());
+
+            Stream<String> membersGenericStream = members.stream()
+                    .filter(javaField -> javaField.getTypeReference() != null && !javaField.getTypeReference().getGenericParameters().isEmpty())
+                    .flatMap(javaField -> javaField.getTypeReference().getGenericParameters().stream())
+                    .filter(JavaTypeReference::isGeneric)
+                    .map(JavaTypeReference::getTypeName);
+
+            genericTypes = Stream.concat(membersGenericStream, membersStream).collect(Collectors.toList());
+
+            return new JavaType(superClass, buildImports(members, inheritedTypes, typeNameToPackageOverrideMap), inheritedTypes, members, name, packagePath,
+                                genericTypes, serializable, description);
         }
     }
 }
diff --git a/src/main/java/graphql_codegen/builder/java/JavaTypeReference.java b/src/main/java/graphql_codegen/builder/java/JavaTypeReference.java
@@ -4,22 +4,32 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 public class JavaTypeReference {
 
     private String typeName;
     private List<JavaTypeReference> genericParameters;
     private String generatedType;
+    private boolean generic; // whether it's a genericType e.g <T>
 
     public JavaTypeReference(String typeName, List<JavaTypeReference> genericParameters) {
+        checkNotNull(genericParameters);
         this.genericParameters = genericParameters;
         this.typeName = typeName;
         this.generatedType = code();
+        this.generic = false;
     }
 
     public JavaTypeReference(String typeName) {
         this(typeName, new ArrayList<>());
     }
 
+    public JavaTypeReference(String typeName, boolean generic) {
+        this(typeName, new ArrayList<>());
+        this.generic = generic;
+    }
+
     public String getGeneratedType() {
         return generatedType;
     }
@@ -32,6 +42,10 @@ public List<JavaTypeReference> getGenericParameters() {
         return genericParameters;
     }
 
+    public boolean isGeneric() {
+        return generic;
+    }
+
     public String code() {
         switch (typeName) {
             case "List":
diff --git a/src/main/resources/java/type.mustache b/src/main/resources/java/type.mustache
@@ -8,7 +8,7 @@ package {{packagePath}};
 * {{description}}
 **/
 {{/description}}
-public class {{name}}{{#superClass}} extends {{{superClass}}}{{/superClass}}{{#inheritedTypes}} implements {{typeName}}{{^-last}}, {{/-last}}{{/inheritedTypes}} {
+public class {{name}}{{#genericTypes}}<{{this}}{{^-last}}, {{/-last}}>{{/genericTypes}}{{#superClass}} extends {{{superClass}}}{{/superClass}}{{#inheritedTypes}} implements {{typeName}}{{^-last}}, {{/-last}}{{/inheritedTypes}} {
 
 {{#members}}
     {{>field}}
diff --git a/src/test/groovy/graphql_codegen/GarfieldSchema.groovy b/src/test/groovy/graphql_codegen/GarfieldSchema.groovy
@@ -0,0 +1,184 @@
+package graphql_codegen
+
+import graphql.Scalars
+import graphql.schema.*
+
+import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition
+import static graphql.schema.GraphQLInterfaceType.newInterface
+import static graphql.schema.GraphQLObjectType.newObject
+import static graphql.schema.GraphQLUnionType.newUnionType
+
+class GarfieldSchema {
+
+    public interface Named {
+        String getName();
+    }
+
+    public static class Dog implements Named {
+        private final String name;
+
+
+        private final boolean barks;
+
+        public Dog(String name, boolean barks) {
+            this.name = name;
+            this.barks = barks;
+        }
+
+        public boolean isBarks() {
+            return barks;
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+    }
+
+    public static class Cat implements Named {
+        private final String name;
+
+        private final boolean meows;
+
+        public Cat(String name, boolean meows) {
+            this.name = name;
+            this.meows = meows;
+        }
+
+        public boolean isMeows() {
+            return meows;
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+    }
+
+    public static class Person implements Named {
+        private final String name;
+        private List<Dog> dogs;
+        private List<Cat> cats;
+        private List<Named> friends;
+
+        public Person(String name) {
+            this(name, Collections.<Cat>emptyList(), Collections.<Dog>emptyList(), Collections.<Named>emptyList());
+        }
+
+        public Person(String name, List<Cat> cats, List<Dog> dogs, List<Named> friends) {
+            this.name = name;
+            this.dogs = dogs;
+            this.cats = cats;
+            this.friends = friends;
+        }
+
+        public List<Object> getPets() {
+            List<Object> pets = new ArrayList<Object>();
+            pets.addAll(cats);
+            pets.addAll(dogs);
+            return pets;
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        public List<Named> getFriends() {
+            return friends;
+        }
+    }
+
+    public static Cat garfield = new Cat("Garfield", false);
+    public static Dog odie = new Dog("Odie", true);
+    public static Person liz = new Person("Liz");
+    public static Person john = new Person("John", Arrays.asList(garfield), Arrays.asList(odie), Arrays.asList(liz, odie));
+
+    public static GraphQLInterfaceType NamedType = newInterface()
+            .name("Named")
+            .field(newFieldDefinition()
+            .name("name")
+            .type(Scalars.GraphQLString)
+            .build())
+            .typeResolver(new TypeResolver() {
+        @Override
+        public GraphQLObjectType getType(Object object) {
+            if (object instanceof Dog) {
+                return DogType;
+            }
+            if (object instanceof Person) {
+                return PersonType;
+            }
+            if (object instanceof Cat) {
+                return CatType;
+            }
+            return null;
+        }
+    })
+            .build();
+
+    public static GraphQLObjectType DogType = newObject()
+            .name("Dog")
+            .field(newFieldDefinition()
+            .name("name")
+            .type(Scalars.GraphQLString)
+            .build())
+            .field(newFieldDefinition()
+            .name("barks")
+            .type(Scalars.GraphQLBoolean)
+            .build())
+            .withInterface(NamedType)
+            .build();
+
+    public static GraphQLObjectType CatType = newObject()
+            .name("Cat")
+            .field(newFieldDefinition()
+            .name("name")
+            .type(Scalars.GraphQLString)
+            .build())
+            .field(newFieldDefinition()
+            .name("meows")
+            .type(Scalars.GraphQLBoolean)
+            .build())
+            .withInterface(NamedType)
+            .build();
+
+    public static GraphQLUnionType PetType = newUnionType()
+            .name("Pet")
+            .possibleType(CatType)
+            .possibleType(DogType)
+            .typeResolver(new TypeResolver() {
+        @Override
+        public GraphQLObjectType getType(Object object) {
+            if (object instanceof Cat) {
+                return CatType;
+            }
+            if (object instanceof Dog) {
+                return DogType;
+            }
+            return null;
+        }
+    })
+            .build();
+
+    public static GraphQLObjectType PersonType = newObject()
+            .name("Person")
+            .field(newFieldDefinition()
+            .name("name")
+            .type(Scalars.GraphQLString)
+            .build())
+            .field(newFieldDefinition()
+            .name("pets")
+            .type(new GraphQLList(PetType))
+            .build())
+            .field(newFieldDefinition()
+            .name("friends")
+            .type(new GraphQLList(NamedType))
+            .build())
+            .withInterface(NamedType)
+            .build();
+
+    public static GraphQLSchema GarfieldSchema = GraphQLSchema.newSchema()
+            .query(PersonType)
+            .build();
+}
diff --git a/src/test/groovy/graphql_codegen/builder/java/JavaUnionTest.groovy b/src/test/groovy/graphql_codegen/builder/java/JavaUnionTest.groovy

Original file line number	Diff line number	Diff line change
`@@ -34,9 +34,7 @@ public Code convertFromGraphQLTypeToCode(GraphQLTypeDescription type) {`
`34`	`34`	`return convertGraphQLInterfaceTypeToCode(type);`
`35`	`35`	`case ENUM:`
`36`	`36`	`return convertFromGraphQLEnumTypeToCode(type);`
`37`		`- case UNION:`
`38`		`- System.out.println("Unable to handle " + type.getKind() + " with name " + type.getName());`
`39`		`- return null;`
	`37`	`+ case UNION: // is handled with generic types`
`40`	`38`	`default:`
`41`	`39`	`return null;`
`42`	`40`	`}`
`@@ -206,6 +204,8 @@ public static JavaTypeReference getJavaTypeReference(GraphQLTypeDescription type`
`206`	`204`	`return new JavaTypeReference("INVALID_TYPE");`
`207`	`205`	`}`
`208`	`206`	`return getJavaTypeReference(type.getOfType());`
	`207`	`+ case UNION:`
	`208`	`+ return new JavaTypeReference(Util.capitalizeFirstLetter(type.getName()), true);`
`209`	`209`	`default:`
`210`	`210`	`return new JavaTypeReference(Util.capitalizeFirstLetter(type.getName()));`
`211`	`211`	`}`