Fix not registering object types when interface type is used as object type field type

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Fixes
 - fix crashing when of union's or interface type's `resolveType` function returns `undefined` or `null` (#731)
 - fix crashing when no reflected type available for fields with params decorators (#724)
+- fix not registering object types implementing interface type when interface type is used as object type field type (#736)
 
 ## v1.1.0
 ### Features

src/schema/schema-generator.ts

@@ -129,17 +129,21 @@ export abstract class SchemaGenerator {
     this.buildTypesInfo(options.resolvers);
 
     const orphanedTypes = options.orphanedTypes || (options.resolvers ? [] : undefined);
-    const schema = new GraphQLSchema({
+    const prebuiltSchema = new GraphQLSchema({
       query: this.buildRootQueryType(options.resolvers),
       mutation: this.buildRootMutationType(options.resolvers),
       subscription: this.buildRootSubscriptionType(options.resolvers),
-      types: this.buildOtherTypes(orphanedTypes),
       directives: options.directives,
     });
+    const finalSchema = new GraphQLSchema({
+      ...prebuiltSchema.toConfig(),
+      // run after first build to make `usedInterfaceTypes` working
+      types: this.buildOtherTypes(orphanedTypes),
+    })
 
     BuildContext.reset();
     this.usedInterfaceTypes = new Set<Function>();
-    return schema;
+    return finalSchema;
   }
 
   private static checkForErrors(options: SchemaGeneratorOptions) {

tests/functional/interfaces-and-inheritance.ts

@@ -1221,6 +1221,57 @@ describe("Interfaces and inheritance", () => {
       );
     });
 
+    it("should by default automatically register all and only the object types that implements an interface type used as field type", async () => {
+      getMetadataStorage().clear();
+      @InterfaceType()
+      class IFooBar {
+        @Field(() => String)
+        fooBarKind: string;
+      }
+      @ObjectType({ implements: IFooBar })
+      class Foo extends IFooBar {
+        fooBarKind = "Foo";
+      }
+      @ObjectType({ implements: IFooBar })
+      class Bar extends IFooBar {
+        fooBarKind = "Bar";
+      }
+      @ObjectType()
+      class FooBar {
+        @Field(() => IFooBar)
+        iFooBarField: IFooBar;
+      }
+      @Resolver()
+      class TestResolver {
+        @Query(() => FooBar)
+        foobar() {
+          return new FooBar();
+        }
+      }
+      const { schemaIntrospection } = await getSchemaInfo({
+        resolvers: [TestResolver],
+      });
+
+      expect(schemaIntrospection.types).toContainEqual(
+        expect.objectContaining({
+          kind: TypeKind.INTERFACE,
+          name: "IFooBar",
+        }),
+      );
+      expect(schemaIntrospection.types).toContainEqual(
+        expect.objectContaining({
+          kind: TypeKind.OBJECT,
+          name: "Bar",
+        }),
+      );
+      expect(schemaIntrospection.types).toContainEqual(
+        expect.objectContaining({
+          kind: TypeKind.OBJECT,
+          name: "Foo",
+        }),
+      );
+    });
+
     it("should register only the object types from orphanedType when interface type has disabled auto registering", async () => {
       @InterfaceType({ autoRegisterImplementations: false })
       abstract class SampleUsedInterface {