fix(schema): match field resolvers by schemaName instead of methodName (#1806)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Michał Lytek <michal.wojciech.lytek@gmail.com>

Author: 3 people

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog and release notes
 
-<!-- ## Unreleased -->
+## Unreleased
+
+### Fixes
+
+- support resolver inheritance with dynamic field resolvers name by matching field resolvers by schemaName instead of methodName (#1806)
 
 <!-- Here goes all the unreleased changes descriptions -->
 

src/schema/schema-generator.ts

@@ -338,7 +338,8 @@ export abstract class SchemaGenerator {
                     it => it.kind === "internal" || resolvers.includes(it.target),
                   );
                   const fieldResolverMetadata = filteredFieldResolversMetadata.find(
-                    it => it.getObjectType!() === field.target && it.methodName === field.name,
+                    it =>
+                      it.getObjectType!() === field.target && it.schemaName === field.schemaName,
                   );
                   const type = this.getGraphQLOutputType(
                     field.target,
@@ -456,7 +457,7 @@ export abstract class SchemaGenerator {
                   const fieldResolverMetadata = this.metadataStorage.fieldResolvers.find(
                     resolver =>
                       resolver.getObjectType!() === field.target &&
-                      resolver.methodName === field.name,
+                      resolver.schemaName === field.schemaName,
                   );
                   const type = this.getGraphQLOutputType(
                     field.target,

tests/functional/resolvers.ts

@@ -2618,6 +2618,62 @@ describe("Resolvers", () => {
       expect(dynamicField1).toBeDefined();
       expect(dynamicField2).toBeDefined();
     });
+
+    it("should resolve independent factory-created field resolvers with different schema names correctly", async () => {
+      getMetadataStorage().clear();
+
+      @ObjectType()
+      class FactoryUser {
+        @Field()
+        name!: string;
+      }
+
+      function createFieldResolver(fieldName: string, returnValue: string) {
+        @Resolver(() => FactoryUser)
+        class DynamicFieldResolver {
+          @FieldResolver(() => [String], { name: fieldName })
+          getItems(): string[] {
+            return [returnValue];
+          }
+        }
+        return DynamicFieldResolver;
+      }
+
+      const FollowersResolver = createFieldResolver("followers", "follower1");
+      const FollowingResolver = createFieldResolver("following", "following1");
+
+      @Resolver()
+      class FactoryUserResolver {
+        @Query(() => FactoryUser)
+        factoryUser(): FactoryUser {
+          return { name: "TestUser" } as FactoryUser;
+        }
+      }
+
+      const schemaInfo = await getSchemaInfo({
+        resolvers: [FactoryUserResolver, FollowersResolver, FollowingResolver],
+      });
+      const { schema: factorySchema, schemaIntrospection: factorySchemaIntrospection } = schemaInfo;
+
+      // Introspection check
+      const factoryUserType = factorySchemaIntrospection.types.find(
+        type => type.name === "FactoryUser",
+      ) as IntrospectionObjectType;
+      expect(factoryUserType.fields.find(f => f.name === "followers")).toBeDefined();
+      expect(factoryUserType.fields.find(f => f.name === "following")).toBeDefined();
+
+      // Runtime execution check
+      const query = `{ factoryUser { name followers following } }`;
+      const result = await graphql({ schema: factorySchema, source: query });
+      expect(result.errors).toBeUndefined();
+      expect(result.data).toEqual({
+        factoryUser: {
+          name: "TestUser",
+          followers: ["follower1"],
+          following: ["following1"],
+        },
+      });
+    });
   });
 
   describe("Shared generic resolver", () => {