Fix duplicated entries for resolver classes that use inheritance

src/metadata/metadata-storage.ts

@@ -263,13 +263,13 @@ export class MetadataStorage {
       while (superResolver.prototype) {
         const superResolverMetadata = this.resolverClasses.find(it => it.target === superResolver);
         if (superResolverMetadata) {
-          this.queries.unshift(...mapSuperResolverHandlers(this.queries, superResolver, def));
-          this.mutations.unshift(...mapSuperResolverHandlers(this.mutations, superResolver, def));
-          this.subscriptions.unshift(
-            ...mapSuperResolverHandlers(this.subscriptions, superResolver, def),
-          );
-          this.fieldResolvers.unshift(
-            ...mapSuperFieldResolverHandlers(this.fieldResolvers, superResolver, def),
+          this.queries = mapSuperResolverHandlers(this.queries, superResolver, def);
+          this.mutations = mapSuperResolverHandlers(this.mutations, superResolver, def);
+          this.subscriptions = mapSuperResolverHandlers(this.subscriptions, superResolver, def);
+          this.fieldResolvers = mapSuperFieldResolverHandlers(
+            this.fieldResolvers,
+            superResolver,
+            def,
           );
         }
         superResolver = Object.getPrototypeOf(superResolver);

src/metadata/utils.ts

@@ -13,28 +13,34 @@ export function mapSuperResolverHandlers<T extends BaseResolverMetadata>(
   superResolver: Function,
   resolverMetadata: ResolverClassMetadata,
 ): T[] {
-  const superMetadata = definitions.filter(subscription => subscription.target === superResolver);
-
-  return superMetadata.map<T>(metadata => ({
-    ...(metadata as any),
-    target: resolverMetadata.target,
-    resolverClassMetadata: resolverMetadata,
-  }));
+  return definitions.map(metadata => {
+    return metadata.target === superResolver
+      ? {
+          ...metadata,
+          target: resolverMetadata.target,
+          resolverClassMetadata: resolverMetadata,
+        }
+      : metadata;
+  });
 }
 
 export function mapSuperFieldResolverHandlers(
   definitions: FieldResolverMetadata[],
   superResolver: Function,
   resolverMetadata: ResolverClassMetadata,
-): FieldResolverMetadata[] {
+) {
   const superMetadata = mapSuperResolverHandlers(definitions, superResolver, resolverMetadata);
 
-  return superMetadata.map<FieldResolverMetadata>(metadata => ({
-    ...metadata,
-    getObjectType: isThrowing(metadata.getObjectType!)
-      ? resolverMetadata.getObjectType!
-      : metadata.getObjectType!,
-  }));
+  return superMetadata.map(metadata => {
+    return metadata.target === superResolver
+      ? {
+          ...metadata,
+          getObjectType: isThrowing(metadata.getObjectType!)
+            ? resolverMetadata.getObjectType
+            : metadata.getObjectType,
+        }
+      : metadata;
+  });
 }
 
 export function mapMiddlewareMetadataToArray(

tests/functional/metadata-storage.ts

@@ -0,0 +1,121 @@
+import "reflect-metadata";
+
+import { getMetadataStorage } from "../../src/metadata/getMetadataStorage";
+import {
+  Resolver,
+  Query,
+  buildSchema,
+  Mutation,
+  Subscription,
+  FieldResolver,
+  ObjectType,
+  ClassType,
+  Field,
+} from "../../src";
+
+describe("MetadataStorage", () => {
+  describe("resolvers inheritance", () => {
+    const INHERITED_QUERY_NAME = "inheritedQueryName";
+    const INHERITED_MUTATION_NAME = "inheritedMutationName";
+    const INHERITED_SUBSCRIPTION_NAME = "inheritedSubscriptionName";
+    const INHERITED_FIELD_RESOLVER_NAME = "inheritedFieldResolverName";
+
+    beforeAll(async () => {
+      getMetadataStorage().clear();
+
+      function createAbstractResolver(classType: ClassType) {
+        @Resolver(() => classType, { isAbstract: true })
+        abstract class AbstractResolver {
+          @Query({ name: INHERITED_QUERY_NAME })
+          abstractQuery(): boolean {
+            return true;
+          }
+
+          @Mutation({ name: INHERITED_MUTATION_NAME })
+          abstractMutation(): boolean {
+            return true;
+          }
+
+          @Subscription({ name: INHERITED_SUBSCRIPTION_NAME, topics: "sampleTopic" })
+          abstractSubscription(): boolean {
+            return true;
+          }
+
+          @FieldResolver({ name: INHERITED_FIELD_RESOLVER_NAME })
+          abstractFieldResolver(): boolean {
+            return true;
+          }
+        }
+        return AbstractResolver;
+      }
+
+      @ObjectType()
+      class SampleObject {
+        @Field()
+        sampleField: boolean;
+
+        @Field({ name: INHERITED_FIELD_RESOLVER_NAME })
+        abstractSampleField: boolean;
+      }
+
+      @Resolver(() => SampleObject)
+      class SubClassResolver extends createAbstractResolver(SampleObject) {
+        @Query()
+        subClassQuery(): boolean {
+          return true;
+        }
+
+        @Mutation()
+        subClassMutation(): boolean {
+          return true;
+        }
+
+        @Subscription({ topics: "sampleTopic" })
+        subClassSubscription(): boolean {
+          return true;
+        }
+
+        @FieldResolver()
+        sampleField(): boolean {
+          return true;
+        }
+      }
+
+      await buildSchema({ resolvers: [SubClassResolver] });
+    });
+
+    it("should not have duplicated query metadata for inherited resolvers", async () => {
+      expect(
+        getMetadataStorage().queries.filter(query => query.schemaName === INHERITED_QUERY_NAME),
+      ).toHaveLength(1);
+      expect(getMetadataStorage().queries).toHaveLength(2);
+    });
+
+    it("should not have duplicated mutation metadata for inherited resolvers", async () => {
+      expect(
+        getMetadataStorage().mutations.filter(
+          mutation => mutation.schemaName === INHERITED_MUTATION_NAME,
+        ),
+      ).toHaveLength(1);
+      expect(getMetadataStorage().mutations).toHaveLength(2);
+    });
+
+    it("should not have duplicated subscription metadata for inherited resolvers", async () => {
+      expect(
+        getMetadataStorage().subscriptions.filter(
+          subscription => subscription.schemaName === INHERITED_SUBSCRIPTION_NAME,
+        ),
+      ).toHaveLength(1);
+      expect(getMetadataStorage().subscriptions).toHaveLength(2);
+    });
+
+    it("should not have duplicated fieldResolver metadata for inherited resolvers", async () => {
+      expect(
+        getMetadataStorage().fieldResolvers.filter(
+          fieldResolver => fieldResolver.schemaName === INHERITED_FIELD_RESOLVER_NAME,
+        ),
+      ).toHaveLength(1);
+      expect(getMetadataStorage().fieldResolvers).toHaveLength(2);
+    });
+  });
+});