feat(object-types): support implementing multi-inherited interface

Author: MichalLytek

CHANGELOG.md

@@ -12,6 +12,7 @@
 - support disabling inferring default values (#793)
 - support readonly arrays for roles of `@Authorized` decorator (#935)
 - add sync version of `buildTypeDefsAndResolvers` function (#803)
+- lift restriction of listing all interfaces from inheritance chain in `implements` option of `@ObjectType` decorator (#1435)
 ### Fixes
 - **Breaking Change**: properly emit types nullability when `defaultValue` is provided and remove `ConflictingDefaultWithNullableError` error (#751)
 - allow defining extension on field resolver level for fields also defined as a property of the class (#776)

docs/interfaces.md

@@ -80,10 +80,10 @@ class Person extends Node {
 }
 ```
 
-Also, when we implement the interface that already implements other interface, we need to put them all in `implements` array in `@ObjectType` decorator option, e.g.:
+Also, when we implement the interface that already implements other interface, there's no need to put them all in `implements` array in `@ObjectType` decorator option - only the closest one in the inheritance chain is required, e.g.:
 
 ```typescript
-@ObjectType({ implements: [Person, Node] })
+@ObjectType({ implements: [Person] })
 class Student extends Person {
   @Field()
   universityName: string;

src/schema/schema-generator.ts

@@ -246,9 +246,9 @@ export abstract class SchemaGenerator {
       const objectSuperClass = Object.getPrototypeOf(objectType.target);
       const hasExtended = objectSuperClass.prototype !== undefined;
       const getSuperClassType = () => {
-        const superClassTypeInfo = this.objectTypesInfo.find(
-          type => type.target === objectSuperClass,
-        );
+        const superClassTypeInfo =
+          this.objectTypesInfo.find(type => type.target === objectSuperClass) ??
+          this.interfaceTypesInfo.find(type => type.target === objectSuperClass);
         return superClassTypeInfo ? superClassTypeInfo.type : undefined;
       };
       const interfaceClasses = objectType.interfaceClasses || [];

tests/functional/nested-interface-inheritance.ts

@@ -0,0 +1,77 @@
+import "reflect-metadata";
+import { GraphQLSchema, printSchema } from "graphql";
+import { Field, InterfaceType, ObjectType, Query, Resolver } from "../../src";
+
+import { getSchemaInfo } from "../helpers/getSchemaInfo";
+
+describe("nested interface inheritance", () => {
+  let schema: GraphQLSchema;
+  beforeAll(async () => {
+    @InterfaceType()
+    abstract class A {
+      @Field()
+      a!: string;
+    }
+
+    @InterfaceType({ implements: A })
+    abstract class B extends A {
+      @Field()
+      b!: string;
+    }
+
+    @InterfaceType({ implements: B })
+    abstract class C extends B {
+      @Field()
+      c!: string;
+    }
+
+    @ObjectType({ implements: C })
+    class D extends C {
+      @Field()
+      d!: string;
+    }
+
+    @Resolver()
+    class TestResolver {
+      @Query()
+      testQuery(): string {
+        return "testQuery";
+      }
+    }
+    const schemaInfo = await getSchemaInfo({
+      resolvers: [TestResolver],
+      orphanedTypes: [A, B, C, D],
+    });
+    schema = schemaInfo.schema;
+  });
+
+  it("should properly generate object type, implementing multi-inherited interface, with only one `implements`", async () => {
+    expect(printSchema(schema)).toMatchInlineSnapshot(`
+      "type D implements C & B & A {
+        a: String!
+        b: String!
+        c: String!
+        d: String!
+      }
+
+      interface A {
+        a: String!
+      }
+
+      interface B implements A {
+        a: String!
+        b: String!
+      }
+
+      interface C implements B & A {
+        a: String!
+        b: String!
+        c: String!
+      }
+
+      type Query {
+        testQuery: String!
+      }"
+    `);
+  });
+});