@@ -22,7 +22,6 @@
 import graphql.language.Type;
 import graphql.language.TypeDefinition;
 import graphql.language.TypeExtensionDefinition;
-import graphql.language.TypeName;
 import graphql.language.UnionTypeDefinition;
 import graphql.language.Value;
 import graphql.schema.DataFetcher;
@@ -253,6 +252,7 @@ private GraphQLInputType buildInputType(BuildContext buildCtx, Type rawType) {
     }
 
     private GraphQLObjectType buildObjectType(BuildContext buildCtx, ObjectTypeDefinition typeDefinition) {
+
         GraphQLObjectType.Builder builder = GraphQLObjectType.newObject();
         builder.name(typeDefinition.getName());
         builder.description(buildDescription(typeDefinition));
@@ -331,7 +331,8 @@ private GraphQLUnionType buildUnionType(BuildContext buildCtx, UnionTypeDefiniti
         builder.typeResolver(getTypeResolver(buildCtx, typeDefinition.getName()));
 
         typeDefinition.getMemberTypes().forEach(mt -> {
-            builder.possibleType(new GraphQLTypeReference(((TypeName) mt).getName()));
+            GraphQLObjectType objectType = buildOutputType(buildCtx, mt);
+            builder.possibleType(objectType);
         });
         return builder.build();
     }
 
@@ -4,7 +4,6 @@ import graphql.language.EnumTypeDefinition
 import graphql.language.InterfaceTypeDefinition
 import graphql.language.ObjectTypeDefinition
 import graphql.language.ScalarTypeDefinition
-import graphql.language.TypeExtensionDefinition
 import graphql.schema.idl.errors.SchemaProblem
 import spock.lang.Specification
 
@@ -141,4 +140,32 @@ class SchemaCompilerTest extends Specification {
         thrown(SchemaProblem)
     }
 
+    def "schema with union"() {
+        def schema = """     
+
+            type Query {
+                foobar: FooOrBar
+            }
+            
+            type Foo {
+               name: String 
+            }
+            
+            type Bar {
+                other: String
+            }
+            
+            union FooOrBar = Foo | Bar
+            
+            schema {
+              query: Query
+            }
+
+        """
+        when:
+        TypeDefinitionRegistry typeRegistry = new SchemaCompiler().compile(schema)
+        then:
+        typeRegistry.types().size() == 4
+    }
+
 }
@@ -70,7 +70,6 @@ class SchemaGeneratorTest extends Specification {
         assert authorField.arguments.get(0).type instanceof GraphQLNonNull
         assert unwrap(authorField.arguments.get(0).type).name == "Int"
 
-
         //type Post {
         //    id: Int!
         //            title: String
@@ -129,7 +128,6 @@ class SchemaGeneratorTest extends Specification {
     }
 
 
-
     def "test simple schema generate"() {
 
         def schemaSpec = """
@@ -185,6 +183,7 @@ class SchemaGeneratorTest extends Specification {
         commonSchemaAsserts(schema)
     }
 
+
     def "schema can come from multiple sources and be bound together"() {
         def schemaSpec1 = """
             type Author {
@@ -254,6 +253,123 @@ class SchemaGeneratorTest extends Specification {
         commonSchemaAsserts(schema)
 
 
+    }
+
+    def "union type: union member used two times "() {
+        def spec = """     
+
+            type Query {
+                foobar: FooOrBar
+                foo: Foo
+            }
+            
+            type Foo {
+               name: String 
+            }
+            
+            type Bar {
+                other: String
+            }
+            
+            union FooOrBar = Foo | Bar
+            
+            schema {
+              query: Query
+            }
+
+        """
+
+        def schema = generateSchema(spec, RuntimeWiring.newRuntimeWiring()
+                .type("FooOrBar", buildResolver())
+                .build())
+
+
+        expect:
+
+        def foobar = schema.getQueryType().getFieldDefinition("foobar")
+        foobar.type instanceof GraphQLUnionType
+        def types = ((GraphQLUnionType) foobar.type).getTypes();
+        types.size() == 2
+        types[0].name == "Foo"
+        types[1].name == "Bar"
+
+    }
+
+    def "union type: union members only used once"() {
+        def spec = """     
+
+            type Query {
+                foobar: FooOrBar
+            }
+            
+            type Foo {
+               name: String 
+            }
+            
+            type Bar {
+                other: String
+            }
+            
+            union FooOrBar = Foo | Bar
+            
+            schema {
+              query: Query
+            }
+
+        """
+
+        def schema = generateSchema(spec, RuntimeWiring.newRuntimeWiring()
+                .type("FooOrBar", buildResolver())
+                .build())
+
+
+        expect:
+
+        def foobar = schema.getQueryType().getFieldDefinition("foobar")
+        foobar.type instanceof GraphQLUnionType
+        def types = ((GraphQLUnionType) foobar.type).getTypes();
+        types.size() == 2
+        types[0].name == "Foo"
+        types[1].name == "Bar"
+
+    }
+
+    def "union type: union declared before members"() {
+        def spec = """     
+
+            union FooOrBar = Foo | Bar
+            
+            type Foo {
+               name: String 
+            }
+            
+            type Bar {
+                other: String
+            }
+            
+            type Query {
+                foobar: FooOrBar
+            }
+            
+            schema {
+              query: Query
+            }
+
+        """
+
+        def schema = generateSchema(spec, RuntimeWiring.newRuntimeWiring()
+                .type("FooOrBar", buildResolver())
+                .build())
+
+
+        expect:
+
+        def foobar = schema.getQueryType().getFieldDefinition("foobar")
+        foobar.type instanceof GraphQLUnionType
+        def types = ((GraphQLUnionType) foobar.type).getTypes();
+        types.size() == 2
+        types[0].name == "Foo"
+        types[1].name == "Bar"
 
     }
 
@@ -481,6 +597,5 @@ class SchemaGeneratorTest extends Specification {
         type.interfaces[0].name == "Character"
 
 
-
     }
 }