fix: clone fields array in buildClassMetadata to avoid dual-type leakage

src/metadata/metadata-storage.ts

@@ -444,7 +444,11 @@ export class MetadataStorage {
           ).map(it => it.directive);
           field.extensions = this.findExtensions(field.target, field.name);
         });
-        def.fields = fields;
+        // Clone the array so that classes sharing the same `target` (e.g. a class
+        // decorated with both `@ObjectType()` and `@InputType()`) don't share the
+        // same fields array reference - mutating one definition's fields (e.g. via
+        // `@FieldResolver()` registration) must not leak into the other definition.
+        def.fields = [...fields];
       }
       if (!def.directives) {
         def.directives = (this.classDirectivesByTargetCache.get(def.target) || []).map(

tests/functional/metadata-storage.ts

@@ -1,9 +1,11 @@
 import "reflect-metadata";
 import { createPubSub } from "@graphql-yoga/subscription";
 import {
+  Arg,
   type ClassType,
   Field,
   FieldResolver,
+  InputType,
   Mutation,
   ObjectType,
   Query,
@@ -121,4 +123,59 @@ describe("MetadataStorage", () => {
       expect(getMetadataStorage().fieldResolvers).toHaveLength(2);
     });
   });
+
+  describe("dual object/input type classes", () => {
+    beforeAll(() => {
+      getMetadataStorage().clear();
+    });
+
+    it("should not leak field-resolver-added fields from the object type into the input type", async () => {
+      @ObjectType("DualClass")
+      @InputType("DualClassInput")
+      class DualClass {
+        @Field()
+        ownField!: string;
+      }
+
+      @ObjectType()
+      class ExtraField {
+        @Field()
+        value!: string;
+      }
+
+      @Resolver(() => DualClass)
+      class DualClassResolver {
+        @Query(() => DualClass)
+        dualClassQuery(): DualClass {
+          return { ownField: "sample" };
+        }
+
+        @Mutation(() => Boolean)
+        dualClassInputMutation(@Arg("input", () => DualClass) _input: DualClass): boolean {
+          return true;
+        }
+
+        @FieldResolver(() => ExtraField)
+        computedField(): ExtraField {
+          return { value: "computed" };
+        }
+      }
+
+      await expect(
+        buildSchema({
+          resolvers: [DualClassResolver],
+        }),
+      ).resolves.not.toThrow();
+
+      const objectTypeMetadata = getMetadataStorage().objectTypes.find(
+        objectType => objectType.name === "DualClass",
+      );
+      const inputTypeMetadata = getMetadataStorage().inputTypes.find(
+        inputType => inputType.name === "DualClassInput",
+      );
+
+      expect(objectTypeMetadata!.fields!.map(field => field.name)).toContain("computedField");
+      expect(inputTypeMetadata!.fields!.map(field => field.name)).not.toContain("computedField");
+    });
+  });
 });