feat(gatsby): support GraphQL interface inheritance (#29427)

* feat(gatsby): support interface inheritance

* Move deprecation message to directive description

deprecationReason is not supported for directives :/

* Add deprecation warning for interfaces with @nodeInterface extension

* update docs

* minor tweak

* add tests for non-node interface inheritance

* update warning text

* update error text

Author: vladar

docs/docs/reference/graphql-data-layer/schema-customization.md

@@ -1000,18 +1000,17 @@ export const query = graphql`
 `
 ```
 
-### Queryable interfaces with the `@nodeInterface` extension
+### Queryable interfaces
 
-Since Gatsby 2.13.22, you can achieve the same thing as above by adding the `@nodeInterface`
-extension to the `TeamMember` interface. This will treat the interface like a normal
-top-level type that implements the `Node` interface, and thus automatically add root
-query fields for the interface.
+Since Gatsby 3.0.0, you can use interface inheritance to achieve the same thing as above:
+`TeamMember implements Node`. This will treat the interface like a normal top-level type that
+implements the `Node` interface, and thus automatically add root query fields for the interface.
 
 ```js:title=gatsby-node.js
 exports.createSchemaCustomization = ({ actions }) => {
   const { createTypes } = actions
   const typeDefs = `
-    interface TeamMember @nodeInterface {
+    interface TeamMember implements Node {
       id: ID!
       name: String!
       firstName: String!
@@ -1079,8 +1078,7 @@ data.allTeamMember.nodes.map(node => {
 })
 ```
 
-> Note: All types implementing an interface with the `@nodeInterface` extension
-> must also implement the `Node` interface.
+> Note: All types implementing a queryable interface must also implement the `Node` interface
 
 ## Extending third-party types
 

packages/gatsby/src/schema/__tests__/__snapshots__/build-schema.js.snap

@@ -41,6 +41,8 @@ directive @childOf(
 ) on OBJECT
 
 \\"\\"\\"
+DEPRECATED: Use interface inheritance instead, i.e. \\"interface Foo implements Node\\".
+
 Adds root query fields for an interface. All implementing types must also implement the Node interface.
 \\"\\"\\"
 directive @nodeInterface on INTERFACE

packages/gatsby/src/schema/__tests__/__snapshots__/print.js.snap

@@ -276,6 +276,11 @@ type OneMoreTest implements Node @dontInfer {
   bar: Boolean
 }
 
+interface ITest2 implements Node {
+  id: ID!
+  date: Date @dateformat(formatString: \\"YYYY\\")
+}
+
 union ThisOrThat = AnotherTest | OneMoreTest
 
 type Inline {
@@ -436,6 +441,11 @@ type OneMoreTest implements Node @dontInfer {
   bar: Boolean
 }
 
+interface ITest2 implements Node {
+  id: ID!
+  date: Date @dateformat(formatString: \\"YYYY\\")
+}
+
 union ThisOrThat = AnotherTest | OneMoreTest
 
 type Inline {

packages/gatsby/src/schema/__tests__/__snapshots__/rebuild-schema.js.snap

@@ -41,6 +41,8 @@ directive @childOf(
 ) on OBJECT
 
 \\"\\"\\"
+DEPRECATED: Use interface inheritance instead, i.e. \\"interface Foo implements Node\\".
+
 Adds root query fields for an interface. All implementing types must also implement the Node interface.
 \\"\\"\\"
 directive @nodeInterface on INTERFACE

packages/gatsby/src/schema/__tests__/build-schema.js

@@ -211,19 +211,23 @@ describe(`Build schema`, () => {
 
     it(`allows adding abstract types in SDL`, async () => {
       createTypes(`
-        interface FooBar {
+        interface Text {
+          text: String
+        }
+
+        interface FooBar implements Text {
           text: String!
         }
 
-        type Foo implements Node & FooBar {
+        type Foo implements Node & Text & FooBar {
           text: String!
         }
 
-        type Bar implements Node & FooBar {
+        type Bar implements Node & Text & FooBar {
           text: String!
         }
 
-        type Author implements Node & FooBar {
+        type Author implements Node & Text & FooBar {
           text: String!
         }
 
@@ -232,49 +236,64 @@ describe(`Build schema`, () => {
 
       const schema = await buildSchema()
 
-      const interfaceType = schema.getType(`FooBar`)
-      expect(interfaceType).toBeInstanceOf(GraphQLInterfaceType)
+      const textType = schema.getType(`Text`)
+      expect(textType).toBeInstanceOf(GraphQLInterfaceType)
+      const fooBarType = schema.getType(`FooBar`)
+      expect(fooBarType).toBeInstanceOf(GraphQLInterfaceType)
+      expect(fooBarType.getInterfaces()).toEqual([schema.getType(`Text`)])
       const unionType = schema.getType(`UFooBar`)
       expect(unionType).toBeInstanceOf(GraphQLUnionType)
       ;[(`Foo`, `Bar`, `Author`)].forEach(typeName => {
         const type = schema.getType(typeName)
         const typeSample = { internal: { type: typeName } }
-        expect(interfaceType.resolveType(typeSample)).toBe(typeName)
+        expect(textType.resolveType(typeSample)).toBe(typeName)
+        expect(fooBarType.resolveType(typeSample)).toBe(typeName)
         expect(unionType.resolveType(typeSample)).toBe(typeName)
         expect(new Set(type.getInterfaces())).toEqual(
-          new Set([schema.getType(`Node`), schema.getType(`FooBar`)])
+          new Set([
+            schema.getType(`Node`),
+            schema.getType(`FooBar`),
+            schema.getType(`Text`),
+          ])
         )
       })
     })
 
     it(`allows adding abstract types in gatsby type def language`, async () => {
       createTypes([
+        buildInterfaceType({
+          name: `Text`,
+          fields: {
+            text: `String!`,
+          },
+        }),
         buildInterfaceType({
           name: `FooBar`,
           fields: {
             text: `String!`,
           },
+          interfaces: [`Text`],
         }),
         buildObjectType({
           name: `Foo`,
           fields: {
             text: `String!`,
           },
-          interfaces: [`Node`, `FooBar`],
+          interfaces: [`Node`, `Text`, `FooBar`],
         }),
         buildObjectType({
           name: `Bar`,
           fields: {
             text: `String!`,
           },
-          interfaces: [`Node`, `FooBar`],
+          interfaces: [`Node`, `Text`, `FooBar`],
         }),
         buildObjectType({
           name: `Author`,
           fields: {
             text: `String!`,
           },
-          interfaces: [`Node`, `FooBar`],
+          interfaces: [`Node`, `Text`, `FooBar`],
         }),
         buildUnionType({
           name: `UFooBar`,
@@ -284,18 +303,26 @@ describe(`Build schema`, () => {
 
       const schema = await buildSchema()
 
-      const interfaceType = schema.getType(`FooBar`)
-      expect(interfaceType).toBeInstanceOf(GraphQLInterfaceType)
-      const unionType = schema.getType(`UFooBar`)
-      expect(unionType).toBeInstanceOf(GraphQLUnionType)
-      expect(unionType.getTypes().length).toBe(3)
+      const textType = schema.getType(`Text`)
+      expect(textType).toBeInstanceOf(GraphQLInterfaceType)
+      const fooBarType = schema.getType(`FooBar`)
+      expect(fooBarType).toBeInstanceOf(GraphQLInterfaceType)
+      expect(fooBarType.getInterfaces()).toEqual([textType])
+      const unionFooBarType = schema.getType(`UFooBar`)
+      expect(unionFooBarType).toBeInstanceOf(GraphQLUnionType)
+      expect(unionFooBarType.getTypes().length).toBe(3)
       ;[(`Foo`, `Bar`, `Author`)].forEach(typeName => {
         const type = schema.getType(typeName)
         const typeSample = { internal: { type: typeName } }
-        expect(interfaceType.resolveType(typeSample)).toBe(typeName)
-        expect(unionType.resolveType(typeSample)).toBe(typeName)
+        expect(textType.resolveType(typeSample)).toBe(typeName)
+        expect(fooBarType.resolveType(typeSample)).toBe(typeName)
+        expect(unionFooBarType.resolveType(typeSample)).toBe(typeName)
         expect(new Set(type.getInterfaces())).toEqual(
-          new Set([schema.getType(`Node`), schema.getType(`FooBar`)])
+          new Set([
+            schema.getType(`Node`),
+            schema.getType(`FooBar`),
+            schema.getType(`Text`),
+          ])
         )
       })
     })

packages/gatsby/src/schema/__tests__/print.js

@@ -93,6 +93,10 @@ describe(`Print type definitions`, () => {
         id: ID!
         date: Date @dateformat(formatString: "YYYY")
       }
+      interface ITest2 implements Node {
+        id: ID!
+        date: Date @dateformat(formatString: "YYYY")
+      }
       union ThisOrThat = AnotherTest | OneMoreTest
     `)
     typeDefs.push(

packages/gatsby/src/schema/extensions/__tests__/child-relations.js

@@ -830,7 +830,7 @@ describe(`Define parent-child relationships with field extensions`, () => {
     await buildSchema()
     expect(report.error).toBeCalledWith(
       `With the \`childOf\` extension, children fields can only be added to ` +
-        `interfaces which have the \`@nodeInterface\` extension.\n` +
+        `interfaces which implement the \`Node\` interface.\n` +
         `Check the type definition of \`Ancestors\`.`
     )
   })