Fragment interface name edge case (#10580)

* fix: extracted typenames concrete name conflict

* added changeset

Author: Georgegriff

.changeset/icy-hotels-flash.md

@@ -0,0 +1,6 @@
+---
+'@graphql-codegen/visitor-plugin-common': patch
+'@graphql-codegen/typescript-operations': patch
+---
+
+fixed invalid extracted concrete type name on shared interface

packages/plugins/other/visitor-plugin-common/src/selection-set-to-object.ts

@@ -964,17 +964,36 @@ export class SelectionSetToObject<Config extends ParsedDocumentsConfig = ParsedD
 
     const schemaType = this._schema.getType(typeName);
 
-    // Check if current selection set has fragments (e.g., "... AppNotificationFragment" or "... on AppNotification")
-    const hasFragment =
-      this._selectionSet?.selections?.some(
-        selection => selection.kind === Kind.INLINE_FRAGMENT || selection.kind === Kind.FRAGMENT_SPREAD
-      ) ?? false;
+    // Check if current selection set has type-narrowing fragments.
+    // - Inline fragments are always type-narrowing
+    // - Fragment spreads are only type-narrowing if they are on a different type than the current parent schema type
+    //   (e.g. spreading `fragment Foo on Pet` while processing `Pet` is not type-narrowing).
+    const hasTypeNarrowingFragments =
+      this._selectionSet?.selections?.some(selection => {
+        if (selection.kind === Kind.INLINE_FRAGMENT) {
+          return true;
+        }
+
+        if (selection.kind === Kind.FRAGMENT_SPREAD) {
+          const spreadFragment = this._loadedFragments.find(lf => lf.name === selection.name.value);
+          // If we can't resolve fragment metadata (or the current parent type), treat it as type-narrowing.
+          // This avoids incorrectly using interface-rooted names in cases that are actually concrete-targeting.
+          return !spreadFragment || !this._parentSchemaType || spreadFragment.onType !== this._parentSchemaType.name;
+        }
+
+        return false;
+      }) ?? false;
 
     // When the parent schema type is an interface:
     // - If we're processing inline fragments, use the concrete type name
     // - If we're processing the interface directly, use the interface name
     // - If we're in a named fragment, always use the concrete type name
-    if (isObjectType(schemaType) && this._parentSchemaType && isInterfaceType(this._parentSchemaType) && !hasFragment) {
+    if (
+      isObjectType(schemaType) &&
+      this._parentSchemaType &&
+      isInterfaceType(this._parentSchemaType) &&
+      !hasTypeNarrowingFragments
+    ) {
       return `${parentName}_${this._parentSchemaType.name}`;
     }
 

packages/plugins/typescript/operations/tests/extract-all-types.spec.ts

@@ -1556,6 +1556,113 @@ describe('extractAllFieldsToTypes: true', () => {
     await validate(content, config, nestedInterfacesSchema);
   });
 
+  it('fragment spreads on the same interface should not force concrete parent type names (regression #10502)', async () => {
+    const interfaceFragmentSchema = buildSchema(/* GraphQL */ `
+      schema {
+        query: Query
+      }
+
+      type Query {
+        pet(petId: ID!): Pet
+      }
+
+      interface Pet {
+        id: ID!
+        home: Home
+      }
+
+      type Dog implements Pet {
+        id: ID!
+        home: Home
+      }
+
+      type Cat implements Pet {
+        id: ID!
+        home: Home
+      }
+
+      interface Home {
+        id: ID!
+      }
+
+      type House implements Home {
+        id: ID!
+      }
+    `);
+
+    const interfaceFragmentDoc = parse(/* GraphQL */ `
+      fragment GetFragmentPet on Pet {
+        id
+        home {
+          id
+        }
+      }
+
+      query GetPetData($petId: ID!) {
+        pet(petId: $petId) {
+          id
+          home {
+            id
+          }
+          ...GetFragmentPet
+        }
+      }
+    `);
+
+    const config: TypeScriptDocumentsPluginConfig = {
+      preResolveTypes: true,
+      extractAllFieldsToTypes: true,
+      nonOptionalTypename: true,
+      dedupeOperationSuffix: true,
+    };
+
+    const { content } = await plugin(
+      interfaceFragmentSchema,
+      [{ location: 'test-file.ts', document: interfaceFragmentDoc }],
+      config,
+      { outputFile: '' }
+    );
+
+    // Edge case: a fragment spread on the same interface should not cause extracted types
+    // for interface fields to be rooted to the first concrete parent (e.g. Cat).
+    expect(content).toMatchInlineSnapshot(`
+      "export type GetFragmentPetFragment_Pet_home_House = { __typename: 'House', id: string };
+
+      type GetFragmentPet_Dog_Fragment = { __typename: 'Dog', id: string, home?: GetFragmentPetFragment_Pet_home_House | null };
+
+      type GetFragmentPet_Cat_Fragment = { __typename: 'Cat', id: string, home?: GetFragmentPetFragment_Pet_home_House | null };
+
+      export type GetFragmentPetFragment =
+        | GetFragmentPet_Dog_Fragment
+        | GetFragmentPet_Cat_Fragment
+      ;
+
+      export type GetPetDataQuery_pet_Pet_home_House = { __typename: 'House', id: string };
+
+      export type GetPetDataQuery_pet_Dog = { __typename: 'Dog', id: string, home?: GetPetDataQuery_pet_Pet_home_House | null };
+
+      export type GetPetDataQuery_pet_Cat = { __typename: 'Cat', id: string, home?: GetPetDataQuery_pet_Pet_home_House | null };
+
+      export type GetPetDataQuery_pet =
+        | GetPetDataQuery_pet_Dog
+        | GetPetDataQuery_pet_Cat
+      ;
+
+      export type GetPetDataQuery_Query = { __typename: 'Query', pet?: GetPetDataQuery_pet | null };
+
+
+      export type GetPetDataQueryVariables = Exact<{
+        petId: Scalars['ID']['input'];
+      }>;
+
+
+      export type GetPetDataQuery = GetPetDataQuery_Query;
+      "
+    `);
+
+    await validate(content, config, interfaceFragmentSchema);
+  });
+
   // Exception case for Issue #10502 - shared schema for fragment tests
   const notificationSchema = buildSchema(/* GraphQL */ `
     type Query {