allow unions to declare implementation of interfaces

WIP: more tests required

complete code coverage is already there, but goal is to have a test
where union implements an interface wherever there is a test for an
interface implementing interface

src/__testUtils__/kitchenSinkSDL.ts

@@ -79,6 +79,28 @@ extend union Feed = Photo | Video
 
 extend union Feed @onUnion
 
+interface Node {
+  id: ID
+}
+
+interface Resource {
+  url: String
+}
+
+extend type Photo implements Node {
+  id: ID
+  url: String
+}
+
+extend type Video implements Node {
+  id: ID
+  url: String
+}
+
+union Media implements Node = Photo | Video
+
+extend union Media implements Resource
+
 scalar CustomScalar
 
 scalar AnnotatedScalar @onScalar

src/execution/__tests__/union-interface-test.ts

@@ -212,7 +212,7 @@ describe('Execute: Union and intersection types', () => {
           kind: 'UNION',
           name: 'Pet',
           fields: null,
-          interfaces: null,
+          interfaces: [],
           possibleTypes: [{ name: 'Dog' }, { name: 'Cat' }],
           enumValues: null,
           inputFields: null,

src/language/__tests__/schema-parser-test.ts

@@ -230,6 +230,24 @@ describe('Schema Parser', () => {
     });
   });
 
+  it('Union extension without types', () => {
+    const doc = parse('extend union HelloOrGoodbye implements Greeting');
+    expectJSON(doc).toDeepEqual({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'UnionTypeExtension',
+          name: nameNode('HelloOrGoodbye', { start: 13, end: 27 }),
+          interfaces: [typeNode('Greeting', { start: 39, end: 47 })],
+          directives: [],
+          types: [],
+          loc: { start: 0, end: 47 },
+        },
+      ],
+      loc: { start: 0, end: 47 },
+    });
+  });
+
   it('Object extension without fields followed by extension', () => {
     const doc = parse(`
       extend type Hello implements Greeting
@@ -323,6 +341,36 @@ describe('Schema Parser', () => {
     });
   });
 
+  it('Union extension without types followed by extension', () => {
+    const doc = parse(`
+      extend union HelloOrGoodbye implements Greeting
+
+      extend union HelloOrGoodbye implements SecondGreeting
+    `);
+    expectJSON(doc).toDeepEqual({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'UnionTypeExtension',
+          name: nameNode('HelloOrGoodbye', { start: 20, end: 34 }),
+          interfaces: [typeNode('Greeting', { start: 46, end: 54 })],
+          directives: [],
+          types: [],
+          loc: { start: 7, end: 54 },
+        },
+        {
+          kind: 'UnionTypeExtension',
+          name: nameNode('HelloOrGoodbye', { start: 75, end: 89 }),
+          interfaces: [typeNode('SecondGreeting', { start: 101, end: 115 })],
+          directives: [],
+          types: [],
+          loc: { start: 62, end: 115 },
+        },
+      ],
+      loc: { start: 0, end: 120 },
+    });
+  });
+
   it('Object extension do not include descriptions', () => {
     expectSyntaxError(`
       "Description"
@@ -517,6 +565,26 @@ describe('Schema Parser', () => {
     });
   });
 
+  it('Simple union inheriting interface', () => {
+    const doc = parse('union Hello implements World = Subtype');
+
+    expectJSON(doc).toDeepEqual({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'UnionTypeDefinition',
+          name: nameNode('Hello', { start: 6, end: 11 }),
+          description: undefined,
+          interfaces: [typeNode('World', { start: 23, end: 28 })],
+          directives: [],
+          types: [typeNode('Subtype', { start: 31, end: 38 })],
+          loc: { start: 0, end: 38 },
+        },
+      ],
+      loc: { start: 0, end: 38 },
+    });
+  });
+
   it('Simple type inheriting multiple interfaces', () => {
     const doc = parse('type Hello implements Wo & rld { field: String }');
 
@@ -574,6 +642,29 @@ describe('Schema Parser', () => {
     });
   });
 
+  it('Simple union inheriting multiple interfaces', () => {
+    const doc = parse('union Hello implements Wo & rld = Subtype');
+
+    expectJSON(doc).toDeepEqual({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'UnionTypeDefinition',
+          name: nameNode('Hello', { start: 6, end: 11 }),
+          description: undefined,
+          interfaces: [
+            typeNode('Wo', { start: 23, end: 25 }),
+            typeNode('rld', { start: 28, end: 31 }),
+          ],
+          directives: [],
+          types: [typeNode('Subtype', { start: 34, end: 41 })],
+          loc: { start: 0, end: 41 },
+        },
+      ],
+      loc: { start: 0, end: 41 },
+    });
+  });
+
   it('Simple type inheriting multiple interfaces with leading ampersand', () => {
     const doc = parse('type Hello implements & Wo & rld { field: String }');
 
@@ -633,6 +724,29 @@ describe('Schema Parser', () => {
     });
   });
 
+  it('Simple union inheriting multiple interfaces with leading ampersand', () => {
+    const doc = parse('union Hello implements & Wo & rld = Subtype');
+
+    expectJSON(doc).toDeepEqual({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'UnionTypeDefinition',
+          name: nameNode('Hello', { start: 6, end: 11 }),
+          description: undefined,
+          interfaces: [
+            typeNode('Wo', { start: 25, end: 27 }),
+            typeNode('rld', { start: 30, end: 33 }),
+          ],
+          directives: [],
+          types: [typeNode('Subtype', { start: 36, end: 43 })],
+          loc: { start: 0, end: 43 },
+        },
+      ],
+      loc: { start: 0, end: 43 },
+    });
+  });
+
   it('Single value enum', () => {
     const doc = parse('enum Hello { WORLD }');
 
@@ -880,6 +994,7 @@ describe('Schema Parser', () => {
           kind: 'UnionTypeDefinition',
           name: nameNode('Hello', { start: 6, end: 11 }),
           description: undefined,
+          interfaces: [],
           directives: [],
           types: [typeNode('World', { start: 14, end: 19 })],
           loc: { start: 0, end: 19 },
@@ -899,6 +1014,7 @@ describe('Schema Parser', () => {
           kind: 'UnionTypeDefinition',
           name: nameNode('Hello', { start: 6, end: 11 }),
           description: undefined,
+          interfaces: [],
           directives: [],
           types: [
             typeNode('Wo', { start: 14, end: 16 }),
@@ -921,6 +1037,7 @@ describe('Schema Parser', () => {
           kind: 'UnionTypeDefinition',
           name: nameNode('Hello', { start: 6, end: 11 }),
           description: undefined,
+          interfaces: [],
           directives: [],
           types: [
             typeNode('Wo', { start: 16, end: 18 }),

src/language/__tests__/schema-printer-test.ts

@@ -110,6 +110,28 @@ describe('Printer: SDL document', () => {
 
       extend union Feed @onUnion
 
+      interface Node {
+        id: ID
+      }
+      
+      interface Resource {
+        url: String
+      }
+      
+      extend type Photo implements Node {
+        id: ID
+        url: String
+      }
+      
+      extend type Video implements Node {
+        id: ID
+        url: String
+      }
+      
+      union Media implements Node = Photo | Video
+      
+      extend union Media implements Resource
+      
       scalar CustomScalar
 
       scalar AnnotatedScalar @onScalar

src/language/ast.ts

@@ -262,7 +262,13 @@ export const QueryDocumentKeys: {
     'directives',
     'fields',
   ],
-  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],
+  UnionTypeDefinition: [
+    'description',
+    'name',
+    'interfaces',
+    'directives',
+    'types',
+  ],
   EnumTypeDefinition: ['description', 'name', 'directives', 'values'],
   EnumValueDefinition: ['description', 'name', 'directives'],
   InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],
@@ -274,7 +280,7 @@ export const QueryDocumentKeys: {
   ScalarTypeExtension: ['name', 'directives'],
   ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
   InterfaceTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
-  UnionTypeExtension: ['name', 'directives', 'types'],
+  UnionTypeExtension: ['name', 'interfaces', 'directives', 'types'],
   EnumTypeExtension: ['name', 'directives', 'values'],
   InputObjectTypeExtension: ['name', 'directives', 'fields'],
 };
@@ -624,6 +630,7 @@ export interface UnionTypeDefinitionNode {
   readonly loc?: Location;
   readonly description?: StringValueNode;
   readonly name: NameNode;
+  readonly interfaces?: ReadonlyArray<NamedTypeNode>;
   readonly directives?: ReadonlyArray<ConstDirectiveNode>;
   readonly types?: ReadonlyArray<NamedTypeNode>;
 }
@@ -716,6 +723,7 @@ export interface UnionTypeExtensionNode {
   readonly kind: Kind.UNION_TYPE_EXTENSION;
   readonly loc?: Location;
   readonly name: NameNode;
+  readonly interfaces?: ReadonlyArray<NamedTypeNode>;
   readonly directives?: ReadonlyArray<ConstDirectiveNode>;
   readonly types?: ReadonlyArray<NamedTypeNode>;
 }

src/language/parser.ts

@@ -970,12 +970,14 @@ export class Parser {
     const description = this.parseDescription();
     this.expectKeyword('union');
     const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
     const directives = this.parseConstDirectives();
     const types = this.parseUnionMemberTypes();
     return this.node<UnionTypeDefinitionNode>(start, {
       kind: Kind.UNION_TYPE_DEFINITION,
       description,
       name,
+      interfaces,
       directives,
       types,
     });
@@ -1249,14 +1251,20 @@ export class Parser {
     this.expectKeyword('extend');
     this.expectKeyword('union');
     const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
     const directives = this.parseConstDirectives();
     const types = this.parseUnionMemberTypes();
-    if (directives.length === 0 && types.length === 0) {
+    if (
+      interfaces.length === 0 &&
+      directives.length === 0 &&
+      types.length === 0
+    ) {
       throw this.unexpected();
     }
     return this.node<UnionTypeExtensionNode>(start, {
       kind: Kind.UNION_TYPE_EXTENSION,
       name,
+      interfaces,
       directives,
       types,
     });

src/language/printer.ts

@@ -202,10 +202,16 @@ const printDocASTReducer: ASTReducer<string> = {
   },
 
   UnionTypeDefinition: {
-    leave: ({ description, name, directives, types }) =>
+    leave: ({ description, name, interfaces, directives, types }) =>
       wrap('', description, '\n') +
       join(
-        ['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))],
+        [
+          'union',
+          name,
+          wrap('implements ', join(interfaces, ' & ')),
+          join(directives, ' '),
+          wrap('= ', join(types, ' | ')),
+        ],
         ' ',
       ),
   },
@@ -282,11 +288,12 @@ const printDocASTReducer: ASTReducer<string> = {
   },
 
   UnionTypeExtension: {
-    leave: ({ name, directives, types }) =>
+    leave: ({ name, interfaces, directives, types }) =>
       join(
         [
           'extend union',
           name,
+          wrap('implements ', join(interfaces, ' & ')),
           join(directives, ' '),
           wrap('= ', join(types, ' | ')),
         ],

src/type/__tests__/schema-test.ts

@@ -13,6 +13,7 @@ import {
   GraphQLList,
   GraphQLObjectType,
   GraphQLScalarType,
+  GraphQLUnionType,
 } from '../definition';
 import { GraphQLDirective } from '../directives';
 import { GraphQLBoolean, GraphQLInt, GraphQLString } from '../scalars';
@@ -212,6 +213,30 @@ describe('Type System: Schema', () => {
       expect(schema.getType('SomeSubtype')).to.equal(SomeSubtype);
     });
 
+    it("includes unions's thunk subtypes in the type map", () => {
+      const SomeUnion = new GraphQLUnionType({
+        name: 'SomeUnion',
+        types: () => [SomeSubtype],
+        interfaces: () => [SomeInterface],
+      });
+
+      const SomeInterface = new GraphQLInterfaceType({
+        name: 'SomeInterface',
+        fields: {},
+      });
+
+      const SomeSubtype = new GraphQLObjectType({
+        name: 'SomeSubtype',
+        fields: {},
+      });
+
+      const schema = new GraphQLSchema({ types: [SomeUnion] });
+
+      expect(schema.getType('SomeUnion')).to.equal(SomeUnion);
+      expect(schema.getType('SomeInterface')).to.equal(SomeInterface);
+      expect(schema.getType('SomeSubtype')).to.equal(SomeSubtype);
+    });
+
     it('includes nested input objects in the map', () => {
       const NestedInputObject = new GraphQLInputObjectType({
         name: 'NestedInputObject',