Compare DocumentNode used in refetchQueries as strings

.changeset/gorgeous-sheep-knock.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": minor
+---
+
+Fix an issue with `refetchQueries` where comparing `DocumentNode`s internally by references could lead to an unknown query, even though the `DocumentNode` was indeed an active query—with a different reference. They are now compared as strings.

src/core/QueryManager.ts

@@ -899,15 +899,15 @@ export class QueryManager<TStore> {
     include: InternalRefetchQueriesInclude = "active"
   ) {
     const queries = new Map<string, ObservableQuery<any>>();
-    const queryNamesAndDocs = new Map<string | DocumentNode, boolean>();
+    const queryNamesAndDocs = new Map<string, boolean>();
     const legacyQueryOptions = new Set<QueryOptions>();
 
     if (Array.isArray(include)) {
       include.forEach((desc) => {
         if (typeof desc === "string") {
           queryNamesAndDocs.set(desc, false);
         } else if (isDocumentNode(desc)) {
-          queryNamesAndDocs.set(this.transform(desc), false);
+          queryNamesAndDocs.set(print(this.transform(desc)), false);
         } else if (isNonNullObject(desc) && desc.query) {
           legacyQueryOptions.add(desc);
         }
@@ -936,11 +936,11 @@ export class QueryManager<TStore> {
         if (
           include === "active" ||
           (queryName && queryNamesAndDocs.has(queryName)) ||
-          (document && queryNamesAndDocs.has(document))
+          (document && queryNamesAndDocs.has(print(document)))
         ) {
           queries.set(queryId, oq);
           if (queryName) queryNamesAndDocs.set(queryName, true);
-          if (document) queryNamesAndDocs.set(document, true);
+          if (document) queryNamesAndDocs.set(print(document), true);
         }
       }
     });
@@ -973,9 +973,7 @@ export class QueryManager<TStore> {
       queryNamesAndDocs.forEach((included, nameOrDoc) => {
         if (!included) {
           invariant.warn(
-            typeof nameOrDoc === "string" ?
-              `Unknown query named "%s" requested in refetchQueries options.include array`
-            : `Unknown query %o requested in refetchQueries options.include array`,
+            `Unknown query %s requested in refetchQueries options.include array`,
             nameOrDoc
           );
         }

src/core/__tests__/QueryManager/index.ts

@@ -5075,7 +5075,7 @@ describe("QueryManager", () => {
           (result) => {
             expect(result.data).toEqual(secondReqData);
             expect(consoleWarnSpy).toHaveBeenLastCalledWith(
-              'Unknown query named "%s" requested in refetchQueries options.include array',
+              "Unknown query %s requested in refetchQueries options.include array",
               "fakeQuery"
             );
           }
@@ -5148,7 +5148,7 @@ describe("QueryManager", () => {
           })
           .then(() => {
             expect(consoleWarnSpy).toHaveBeenLastCalledWith(
-              'Unknown query named "%s" requested in refetchQueries options.include array',
+              "Unknown query %s requested in refetchQueries options.include array",
               "getAuthors"
             );
           })
@@ -5237,6 +5237,169 @@ describe("QueryManager", () => {
       await expect(stream).not.toEmitAnything();
     });
 
+    it("also works with a query document node", async () => {
+      const mutation = gql`
+        mutation changeAuthorName($id: ID!) {
+          changeAuthorName(newName: "Jack Smith", id: $id) {
+            firstName
+            lastName
+          }
+        }
+      `;
+      const mutationData = {
+        changeAuthorName: {
+          firstName: "Jack",
+          lastName: "Smith",
+        },
+      };
+      const query = gql`
+        query getAuthors($id: ID!) {
+          author(id: $id) {
+            firstName
+            lastName
+          }
+        }
+      `;
+      const data = {
+        author: {
+          firstName: "John",
+          lastName: "Smith",
+        },
+      };
+      const secondReqData = {
+        author: {
+          firstName: "Jane",
+          lastName: "Johnson",
+        },
+      };
+
+      const variables = { id: "1234" };
+      const mutationVariables = { id: "2345" };
+      const queryManager = mockQueryManager(
+        {
+          request: { query, variables },
+          result: { data },
+          delay: 10,
+        },
+        {
+          request: { query, variables },
+          result: { data: secondReqData },
+          delay: 100,
+        },
+        {
+          request: { query: mutation, variables: mutationVariables },
+          result: { data: mutationData },
+          delay: 10,
+        }
+      );
+      const observable = queryManager.watchQuery<any>({ query, variables });
+      const stream = new ObservableStream(observable);
+
+      await expect(stream).toEmitMatchedValue({ data });
+
+      await queryManager.mutate({
+        mutation,
+        variables: mutationVariables,
+        refetchQueries: [query],
+      });
+
+      await expect(stream).toEmitMatchedValue(
+        { data: secondReqData },
+        { timeout: 150 }
+      );
+      expect(observable.getCurrentResult().data).toEqual(secondReqData);
+
+      await wait(10);
+
+      queryManager["queries"].forEach((_, queryId) => {
+        expect(queryId).not.toContain("legacyOneTimeQuery");
+      });
+
+      await expect(stream).not.toEmitAnything();
+    });
+
+    it("also works with different references of a same query document node", async () => {
+      const mutation = gql`
+        mutation changeAuthorName($id: ID!) {
+          changeAuthorName(newName: "Jack Smith", id: $id) {
+            firstName
+            lastName
+          }
+        }
+      `;
+      const mutationData = {
+        changeAuthorName: {
+          firstName: "Jack",
+          lastName: "Smith",
+        },
+      };
+      const query = gql`
+        query getAuthors($id: ID!) {
+          author(id: $id) {
+            firstName
+            lastName
+          }
+        }
+      `;
+      const data = {
+        author: {
+          firstName: "John",
+          lastName: "Smith",
+        },
+      };
+      const secondReqData = {
+        author: {
+          firstName: "Jane",
+          lastName: "Johnson",
+        },
+      };
+
+      const variables = { id: "1234" };
+      const mutationVariables = { id: "2345" };
+      const queryManager = mockQueryManager(
+        {
+          request: { query, variables },
+          result: { data },
+          delay: 10,
+        },
+        {
+          request: { query, variables },
+          result: { data: secondReqData },
+          delay: 100,
+        },
+        {
+          request: { query: mutation, variables: mutationVariables },
+          result: { data: mutationData },
+          delay: 10,
+        }
+      );
+      const observable = queryManager.watchQuery<any>({ query, variables });
+      const stream = new ObservableStream(observable);
+
+      await expect(stream).toEmitMatchedValue({ data });
+
+      await queryManager.mutate({
+        mutation,
+        variables: mutationVariables,
+        // spread the query into a new object to simulate multiple instances
+        refetchQueries: [{ ...query }],
+      });
+
+      await expect(stream).toEmitMatchedValue(
+        { data: secondReqData },
+        { timeout: 150 }
+      );
+      expect(observable.getCurrentResult().data).toEqual(secondReqData);
+
+      await wait(10);
+
+      queryManager["queries"].forEach((_, queryId) => {
+        expect(queryId).not.toContain("legacyOneTimeQuery");
+      });
+
+      await expect(stream).not.toEmitAnything();
+    });
+
     itAsync(
       "also works with a conditional function that returns false",
       (resolve, reject) => {