fix(interfaces): support GraphQL extensions (#1776)

Co-authored-by: Michał Lytek <[email protected]>

Author: johnsonjo4531

src/schema/schema-generator.ts

@@ -405,6 +405,7 @@ export abstract class SchemaGenerator {
             name: interfaceType.name,
             description: interfaceType.description,
             astNode: getInterfaceTypeDefinitionNode(interfaceType.name, interfaceType.directives),
+            extensions: interfaceType.extensions,
             interfaces: () => {
               let interfaces = (interfaceType.interfaceClasses || []).map<GraphQLInterfaceType>(
                 interfaceClass =>

tests/functional/extensions.ts

@@ -2,6 +2,7 @@ import "reflect-metadata";
 import {
   type GraphQLFieldMap,
   type GraphQLInputObjectType,
+  GraphQLInterfaceType,
   type GraphQLObjectType,
   type GraphQLSchema,
 } from "graphql";
@@ -11,6 +12,7 @@ import {
   Field,
   FieldResolver,
   InputType,
+  InterfaceType,
   Mutation,
   ObjectType,
   Query,
@@ -90,6 +92,29 @@ describe("Extensions", () => {
         }
       }
 
+      @InterfaceType()
+      @Extensions({ meta: "interfaceExtensionData" })
+      class SampleInterfaceType {
+        @Field()
+        @Extensions({ meta: "interfaceFieldExtensionData" })
+        withInterfaceFieldExtension!: string;
+      }
+
+      @ObjectType({
+        implements: [SampleInterfaceType],
+      })
+      class SampleObjectInterfaceImplementation extends SampleInterfaceType {}
+
+      @InterfaceType({
+        implements: [SampleInterfaceType],
+      })
+      class SampleInterfaceInterfaceImplementation extends SampleInterfaceType {}
+
+      @ObjectType({
+        implements: [SampleInterfaceInterfaceImplementation],
+      })
+      class SampleObjectInterfaceInterfaceImplementation extends SampleInterfaceInterfaceImplementation {}
+
       @Resolver()
       class SampleResolver {
         @Query(() => SampleObjectType)
@@ -102,6 +127,26 @@ describe("Extensions", () => {
           return new ExtensionsOnClassObjectType();
         }
 
+        @Query(() => SampleObjectInterfaceImplementation)
+        sampleObjectInterfaceImplementation(): SampleObjectInterfaceImplementation {
+          return new SampleObjectInterfaceImplementation();
+        }
+
+        @Query(() => SampleInterfaceInterfaceImplementation)
+        sampleInterfaceInterfaceImplementation(): SampleInterfaceInterfaceImplementation {
+          return new SampleInterfaceInterfaceImplementation();
+        }
+
+        @Query(() => SampleObjectInterfaceInterfaceImplementation)
+        sampleObjectInterfaceInterfaceImplementation(): SampleObjectInterfaceInterfaceImplementation {
+          return new SampleObjectInterfaceInterfaceImplementation();
+        }
+
+        @Query(() => SampleInterfaceType)
+        sampleInterfaceType(): SampleInterfaceType {
+          return new SampleObjectInterfaceImplementation();
+        }
+
         @Query()
         @Extensions({ mandatory: true })
         queryWithExtensions(): string {
@@ -269,6 +314,78 @@ describe("Extensions", () => {
       });
     });
 
+    describe("Interface Fields", () => {
+      it("should add extensions to interface types", async () => {
+        const fields = (schema.getType("SampleInterfaceType") as GraphQLObjectType).getFields();
+        expect(fields.withInterfaceFieldExtension.extensions).toEqual({
+          meta: "interfaceFieldExtensionData",
+        });
+      });
+
+      it("should add extensions to ObjectType which extends InterfaceType", async () => {
+        const fields = (
+          schema.getType("SampleObjectInterfaceImplementation") as GraphQLObjectType
+        ).getFields();
+        expect(fields.withInterfaceFieldExtension.extensions).toEqual({
+          meta: "interfaceFieldExtensionData",
+        });
+      });
+
+      it("should add extensions to Interface which extends InterfaceType", async () => {
+        const fields = (
+          schema.getType("SampleInterfaceInterfaceImplementation") as GraphQLObjectType
+        ).getFields();
+        expect(fields.withInterfaceFieldExtension.extensions).toEqual({
+          meta: "interfaceFieldExtensionData",
+        });
+      });
+
+      it("should add extensions to ObjectType which extends InterfaceType which extends InterfaceType", async () => {
+        const fields = (
+          schema.getType("SampleInterfaceInterfaceImplementation") as GraphQLObjectType
+        ).getFields();
+        expect(fields.withInterfaceFieldExtension.extensions).toEqual({
+          meta: "interfaceFieldExtensionData",
+        });
+      });
+    });
+
+    describe("Interface Class", () => {
+      it("should add extensions to interface types", async () => {
+        const sampleInterface = schema.getType("SampleInterfaceType") as GraphQLInterfaceType;
+        expect(sampleInterface.extensions).toEqual({
+          meta: "interfaceExtensionData",
+        });
+      });
+
+      it("should add extensions to ObjectType which extends InterfaceType", async () => {
+        const sampleInterface = schema.getType(
+          "SampleObjectInterfaceImplementation",
+        ) as GraphQLInterfaceType;
+        expect(sampleInterface.extensions).toEqual({
+          meta: "interfaceExtensionData",
+        });
+      });
+
+      it("should add extensions to InterfaceType which extends InterfaceType", async () => {
+        const sampleInterface = schema.getType(
+          "SampleInterfaceInterfaceImplementation",
+        ) as GraphQLInterfaceType;
+        expect(sampleInterface.extensions).toEqual({
+          meta: "interfaceExtensionData",
+        });
+      });
+
+      it("should add extensions to ObjectType which extends InterfaceType which extends InterfaceType", async () => {
+        const sampleInterface = schema.getType(
+          "SampleObjectInterfaceInterfaceImplementation",
+        ) as GraphQLInterfaceType;
+        expect(sampleInterface.extensions).toEqual({
+          meta: "interfaceExtensionData",
+        });
+      });
+    });
+
     describe("Inheritance", () => {
       beforeAll(async () => {
         getMetadataStorage().clear();