Repository: apollographql/apollo-client

Problem statement:
[4.0] Add `data` property to `CombinedGraphQLErrors` to access partial data
When using `errorPolicy: 'none'` (the default), data returned from the server is discarded when errors are also returned. We'd like to make any partial data returned from the server available on the `CombinedGraphQLErrors` instance.


Hints:

Patch:
diff --git a/src/config/jest/areCombinedGraphQLErrorsEqual.ts b/src/config/jest/areCombinedGraphQLErrorsEqual.ts
--- a/src/config/jest/areCombinedGraphQLErrorsEqual.ts
+++ b/src/config/jest/areCombinedGraphQLErrorsEqual.ts
@@ -12,7 +12,9 @@ export const areCombinedGraphQLErrorsEqual: Tester = function (
 
   if (isACombinedGraphQLErrors && isBCombinedGraphQLErrors) {
     return (
-      a.message === b.message && this.equals(a.errors, b.errors, customTesters)
+      a.message === b.message &&
+      this.equals(a.errors, b.errors, customTesters) &&
+      this.equals(a.data, b.data, customTesters)
     );
   } else if (isACombinedGraphQLErrors === isBCombinedGraphQLErrors) {
     return undefined;
diff --git a/src/core/QueryManager.ts b/src/core/QueryManager.ts
--- a/src/core/QueryManager.ts
+++ b/src/core/QueryManager.ts
@@ -339,9 +339,7 @@ export class QueryManager {
           mergeMap((result) => {
             const hasErrors = graphQLResultHasError(result);
             if (hasErrors && errorPolicy === "none") {
-              throw new CombinedGraphQLErrors(
-                getGraphQLErrorsFromResult(result)
-              );
+              throw new CombinedGraphQLErrors(result);
             }
 
             if (mutationStoreValue) {
@@ -401,9 +399,7 @@ export class QueryManager {
               };
 
               if (graphQLResultHasError(storeResult)) {
-                result.error = new CombinedGraphQLErrors(
-                  getGraphQLErrorsFromResult(storeResult)
-                );
+                result.error = new CombinedGraphQLErrors(storeResult);
               }
 
               if (storeResult.extensions) {
@@ -1065,7 +1061,7 @@ export class QueryManager {
           };
 
           if (graphQLResultHasError(rawResult)) {
-            result.error = new CombinedGraphQLErrors(rawResult.errors!);
+            result.error = new CombinedGraphQLErrors(rawResult);
           } else if (graphQLResultHasProtocolErrors(rawResult)) {
             result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
             // Don't emit protocol errors added by HttpLink
@@ -1262,7 +1258,7 @@ export class QueryManager {
             queryInfo.resetLastWrite();
             queryInfo.reset();
             // Throwing here effectively calls observer.error.
-            throw new CombinedGraphQLErrors(graphQLErrors);
+            throw new CombinedGraphQLErrors(result);
           }
           // Use linkDocument rather than queryInfo.document so the
           // operation/fragments used to write the result are the same as the
@@ -1291,7 +1287,7 @@ export class QueryManager {
         }
 
         if (hasErrors && errorPolicy !== "ignore") {
-          aqr.error = new CombinedGraphQLErrors(graphQLErrors);
+          aqr.error = new CombinedGraphQLErrors(result);
           aqr.networkStatus = NetworkStatus.error;
         }
 
diff --git a/src/errors/CombinedGraphQLErrors.ts b/src/errors/CombinedGraphQLErrors.ts
--- a/src/errors/CombinedGraphQLErrors.ts
+++ b/src/errors/CombinedGraphQLErrors.ts
@@ -1,5 +1,8 @@
 import type { GraphQLFormattedError } from "graphql";
 
+import type { FetchResult } from "@apollo/client/core";
+import { getGraphQLErrorsFromResult } from "@apollo/client/utilities";
+
 /**
  * Represents the combined list of GraphQL errors returned from the server in a
  * GraphQL response.
@@ -8,13 +11,19 @@ export class CombinedGraphQLErrors extends Error {
   /**
    * The raw list of GraphQL errors returned in a GraphQL response.
    */
-  errors: ReadonlyArray<GraphQLFormattedError>;
+  readonly errors: ReadonlyArray<GraphQLFormattedError>;
+
+  /**
+   * Partial data returned in the GraphQL response.
+   */
+  readonly data: Record<string, unknown> | null | undefined;
+
+  constructor(result: FetchResult<unknown>) {
+    const errors = getGraphQLErrorsFromResult(result);
 
-  constructor(
-    errors: Array<GraphQLFormattedError> | ReadonlyArray<GraphQLFormattedError>
-  ) {
     super(formatMessage(errors));
     this.errors = errors;
+    this.data = result.data as Record<string, unknown>;
     this.name = "CombinedGraphQLErrors";
 
     Object.setPrototypeOf(this, CombinedGraphQLErrors.prototype);
diff --git a/src/link/subscriptions/index.ts b/src/link/subscriptions/index.ts
--- a/src/link/subscriptions/index.ts
+++ b/src/link/subscriptions/index.ts
@@ -77,7 +77,9 @@ export class GraphQLWsLink extends ApolloLink {
             }
 
             return observer.error(
-              new CombinedGraphQLErrors(Array.isArray(err) ? err : [err])
+              new CombinedGraphQLErrors({
+                errors: Array.isArray(err) ? err : [err],
+              })
             );
           },
           // casting around a wrong type in graphql-ws, which incorrectly expects `Sink<ExecutionResult>`


Test patch:
diff --git a/src/__tests__/client.ts b/src/__tests__/client.ts
--- a/src/__tests__/client.ts
+++ b/src/__tests__/client.ts
@@ -593,7 +593,7 @@ describe("client", () => {
     });
 
     await expect(client.query({ query })).rejects.toEqual(
-      new CombinedGraphQLErrors(errors)
+      new CombinedGraphQLErrors({ errors })
     );
   });
 
@@ -638,7 +638,7 @@ describe("client", () => {
     });
 
     await expect(client.query({ query })).rejects.toEqual(
-      new CombinedGraphQLErrors(errors)
+      new CombinedGraphQLErrors({ data, errors })
     );
   });
 
@@ -1950,7 +1950,9 @@ describe("client", () => {
 
       await expect(stream).toEmitApolloQueryResult({
         data: initialData,
-        error: new CombinedGraphQLErrors([{ message: "network failure" }]),
+        error: new CombinedGraphQLErrors({
+          errors: [{ message: "network failure" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: false,
@@ -2189,7 +2191,7 @@ describe("client", () => {
     });
 
     await expect(client.mutate({ mutation })).rejects.toEqual(
-      new CombinedGraphQLErrors(errors)
+      new CombinedGraphQLErrors({ data, errors })
     );
   });
 
@@ -2205,9 +2207,11 @@ describe("client", () => {
       }
     `;
     const data = {
-      person: {
-        firstName: "John",
-        lastName: "Smith",
+      newPerson: {
+        person: {
+          firstName: "John",
+          lastName: "Smith",
+        },
       },
     };
     const errors = [{ message: "Some kind of GraphQL error." }];
@@ -2216,9 +2220,7 @@ describe("client", () => {
         request: { query: mutation },
         result: {
           errors,
-          data: {
-            newPerson: data,
-          },
+          data,
         },
       }),
       cache: new InMemoryCache(),
@@ -2227,8 +2229,8 @@ describe("client", () => {
     await expect(
       client.mutate({ mutation, errorPolicy: "all" })
     ).resolves.toEqualStrictTyped({
-      data: { newPerson: data },
-      error: new CombinedGraphQLErrors(errors),
+      data,
+      error: new CombinedGraphQLErrors({ data, errors }),
     });
   });
 
@@ -2782,9 +2784,10 @@ describe("client", () => {
       client.query({ query, errorPolicy: "all" })
     ).resolves.toEqualStrictTyped({
       data: { posts: null },
-      error: new CombinedGraphQLErrors([
-        { message: 'Cannot query field "foo" on type "Post".' },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: { posts: null },
+        errors: [{ message: 'Cannot query field "foo" on type "Post".' }],
+      }),
     });
   });
 
@@ -3771,7 +3774,7 @@ describe("@connection", () => {
 
       expect(result).toEqualStrictTyped({
         data: undefined,
-        error: new CombinedGraphQLErrors(errors),
+        error: new CombinedGraphQLErrors({ errors }),
       });
     });
 
diff --git a/src/__tests__/dataMasking.ts b/src/__tests__/dataMasking.ts
--- a/src/__tests__/dataMasking.ts
+++ b/src/__tests__/dataMasking.ts
@@ -978,7 +978,17 @@ describe("client.watchQuery", () => {
           name: null,
         },
       },
-      error: new CombinedGraphQLErrors([{ message: "Couldn't get name" }]),
+      error: new CombinedGraphQLErrors({
+        data: {
+          currentUser: {
+            __typename: "User",
+            id: 1,
+            name: null,
+            age: 34,
+          },
+        },
+        errors: [{ message: "Couldn't get name" }],
+      }),
       loading: false,
       networkStatus: NetworkStatus.error,
       partial: false,
@@ -3832,7 +3842,7 @@ describe("client.query", () => {
     });
 
     await expect(client.query({ query, errorPolicy: "none" })).rejects.toEqual(
-      new CombinedGraphQLErrors([{ message: "User not logged in" }])
+      new CombinedGraphQLErrors({ errors: [{ message: "User not logged in" }] })
     );
   });
 
@@ -3871,7 +3881,10 @@ describe("client.query", () => {
 
     expect(result).toEqualStrictTyped({
       data: { currentUser: null },
-      error: new CombinedGraphQLErrors([{ message: "User not logged in" }]),
+      error: new CombinedGraphQLErrors({
+        data: { currentUser: null },
+        errors: [{ message: "User not logged in" }],
+      }),
     });
   });
 
@@ -3923,9 +3936,17 @@ describe("client.query", () => {
           name: "Test User",
         },
       },
-      error: new CombinedGraphQLErrors([
-        { message: "Could not determine age" },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: {
+          currentUser: {
+            __typename: "User",
+            id: 1,
+            name: "Test User",
+            age: null,
+          },
+        },
+        errors: [{ message: "Could not determine age" }],
+      }),
     });
   });
 
@@ -4384,7 +4405,10 @@ describe("client.subscribe", () => {
 
     await expect(stream).toEmitStrictTyped({
       data: undefined,
-      error: new CombinedGraphQLErrors([{ message: "Something went wrong" }]),
+      error: new CombinedGraphQLErrors({
+        data: { addedComment: null },
+        errors: [{ message: "Something went wrong" }],
+      }),
     });
   });
 
@@ -4428,7 +4452,10 @@ describe("client.subscribe", () => {
 
     await expect(stream).toEmitStrictTyped({
       data: { addedComment: null },
-      error: new CombinedGraphQLErrors([{ message: "Something went wrong" }]),
+      error: new CombinedGraphQLErrors({
+        data: { addedComment: null },
+        errors: [{ message: "Something went wrong" }],
+      }),
     });
   });
 
@@ -4477,7 +4504,17 @@ describe("client.subscribe", () => {
 
     await expect(stream).toEmitStrictTyped({
       data: { addedComment: { __typename: "Comment", id: 1 } },
-      error: new CombinedGraphQLErrors([{ message: "Could not get author" }]),
+      error: new CombinedGraphQLErrors({
+        data: {
+          addedComment: {
+            __typename: "Comment",
+            id: 1,
+            comment: "Test comment",
+            author: null,
+          },
+        },
+        errors: [{ message: "Could not get author" }],
+      }),
     });
   });
 
@@ -5471,7 +5508,7 @@ describe("client.mutate", () => {
     await expect(
       client.mutate({ mutation, errorPolicy: "none" })
     ).rejects.toEqual(
-      new CombinedGraphQLErrors([{ message: "User not logged in" }])
+      new CombinedGraphQLErrors({ errors: [{ message: "User not logged in" }] })
     );
   });
 
@@ -5529,7 +5566,10 @@ describe("client.mutate", () => {
       })
     ).resolves.toEqualStrictTyped({
       data: { updateUser: null },
-      error: new CombinedGraphQLErrors([{ message: "User not logged in" }]),
+      error: new CombinedGraphQLErrors({
+        data: { updateUser: null },
+        errors: [{ message: "User not logged in" }],
+      }),
     });
   });
 
@@ -5598,9 +5638,17 @@ describe("client.mutate", () => {
           name: "Test User",
         },
       },
-      error: new CombinedGraphQLErrors([
-        { message: "Could not determine age" },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: {
+          updateUser: {
+            __typename: "User",
+            id: 1,
+            name: "Test User",
+            age: null,
+          },
+        },
+        errors: [{ message: "Could not determine age" }],
+      }),
     });
   });
 
diff --git a/src/__tests__/graphqlSubscriptions.ts b/src/__tests__/graphqlSubscriptions.ts
--- a/src/__tests__/graphqlSubscriptions.ts
+++ b/src/__tests__/graphqlSubscriptions.ts
@@ -171,18 +171,21 @@ describe("GraphQL Subscriptions", () => {
 
     await expect(stream).toEmitStrictTyped({
       data: undefined,
-      error: new CombinedGraphQLErrors([
-        {
-          message: "This is an error",
-          locations: [
-            {
-              column: 3,
-              line: 2,
-            },
-          ],
-          path: ["result"],
-        },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: null,
+        errors: [
+          {
+            message: "This is an error",
+            locations: [
+              {
+                column: 3,
+                line: 2,
+              },
+            ],
+            path: ["result"],
+          },
+        ],
+      }),
     });
   });
 
@@ -216,18 +219,21 @@ describe("GraphQL Subscriptions", () => {
 
     await expect(stream).toEmitStrictTyped({
       data: undefined,
-      error: new CombinedGraphQLErrors([
-        {
-          message: "This is an error",
-          locations: [
-            {
-              column: 3,
-              line: 2,
-            },
-          ],
-          path: ["result"],
-        },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: null,
+        errors: [
+          {
+            message: "This is an error",
+            locations: [
+              {
+                column: 3,
+                line: 2,
+              },
+            ],
+            path: ["result"],
+          },
+        ],
+      }),
     });
 
     link.simulateResult(results[0]);
@@ -288,7 +294,10 @@ describe("GraphQL Subscriptions", () => {
 
     await expect(stream).toEmitStrictTyped({
       data: undefined,
-      error: new CombinedGraphQLErrors([{ message: "This is an error" }]),
+      error: new CombinedGraphQLErrors({
+        data: null,
+        errors: [{ message: "This is an error" }],
+      }),
     });
 
     await expect(stream).toComplete();
diff --git a/src/__tests__/local-state/general.ts b/src/__tests__/local-state/general.ts
--- a/src/__tests__/local-state/general.ts
+++ b/src/__tests__/local-state/general.ts
@@ -1179,7 +1179,10 @@ describe("Combining client and server state/operations", () => {
 
     await expect(stream).toEmitApolloQueryResult({
       data: undefined,
-      error: new CombinedGraphQLErrors([error]),
+      error: new CombinedGraphQLErrors({
+        data: { user: null },
+        errors: [error],
+      }),
       loading: false,
       networkStatus: NetworkStatus.error,
       partial: true,
diff --git a/src/__tests__/mutationResults.ts b/src/__tests__/mutationResults.ts
--- a/src/__tests__/mutationResults.ts
+++ b/src/__tests__/mutationResults.ts
@@ -346,7 +346,12 @@ describe("mutation results", () => {
           newName: "Hugh Willson",
         },
       })
-    ).rejects.toThrow(new CombinedGraphQLErrors([expectedFakeError]));
+    ).rejects.toThrow(
+      new CombinedGraphQLErrors({
+        data: { newPerson: { __typename: "Person", name: "Hugh Willson" } },
+        errors: [expectedFakeError],
+      })
+    );
 
     expect(client.cache.extract()).toMatchSnapshot();
 
@@ -384,7 +389,10 @@ describe("mutation results", () => {
           name: "Ellen Shapiro",
         },
       },
-      error: new CombinedGraphQLErrors([expectedFakeError]),
+      error: new CombinedGraphQLErrors({
+        data: { newPerson: { __typename: "Person", name: "Ellen Shapiro" } },
+        errors: [expectedFakeError],
+      }),
     });
 
     expect(client.cache.extract()).toMatchSnapshot();
@@ -529,7 +537,10 @@ describe("mutation results", () => {
       })
     ).resolves.toEqualStrictTyped({
       data: { newPerson: null },
-      error: new CombinedGraphQLErrors([{ message: "Oops" }]),
+      error: new CombinedGraphQLErrors({
+        data: { newPerson: null },
+        errors: [{ message: "Oops" }],
+      }),
       extensions: {
         requestLimit: 10,
       },
@@ -1143,7 +1154,9 @@ describe("mutation results", () => {
             },
           },
         })
-      ).rejects.toThrow(new CombinedGraphQLErrors([{ message: "mock error" }]));
+      ).rejects.toThrow(
+        new CombinedGraphQLErrors({ errors: [{ message: "mock error" }] })
+      );
 
       await expect(
         client.mutate({
@@ -1157,7 +1170,9 @@ describe("mutation results", () => {
             },
           },
         })
-      ).rejects.toThrow(new CombinedGraphQLErrors([{ message: "mock error" }]));
+      ).rejects.toThrow(
+        new CombinedGraphQLErrors({ errors: [{ message: "mock error" }] })
+      );
       await obsQuery.refetch();
     });
 
@@ -1739,7 +1754,9 @@ describe("mutation results", () => {
             });
           },
         })
-      ).rejects.toThrow(new CombinedGraphQLErrors([{ message: "mock error" }]));
+      ).rejects.toThrow(
+        new CombinedGraphQLErrors({ errors: [{ message: "mock error" }] })
+      );
 
       await expect(
         client.mutate({
@@ -1774,7 +1791,9 @@ describe("mutation results", () => {
             });
           },
         })
-      ).rejects.toThrow(new CombinedGraphQLErrors([{ message: "mock error" }]));
+      ).rejects.toThrow(
+        new CombinedGraphQLErrors({ errors: [{ message: "mock error" }] })
+      );
 
       await obsQuery.refetch();
     });
diff --git a/src/core/__tests__/ApolloClient/general.test.ts b/src/core/__tests__/ApolloClient/general.test.ts
--- a/src/core/__tests__/ApolloClient/general.test.ts
+++ b/src/core/__tests__/ApolloClient/general.test.ts
@@ -111,9 +111,9 @@ describe("ApolloClient", () => {
 
     await expect(stream).toEmitApolloQueryResult({
       data: undefined,
-      error: new CombinedGraphQLErrors([
-        { message: "This is an error message." },
-      ]),
+      error: new CombinedGraphQLErrors({
+        errors: [{ message: "This is an error message." }],
+      }),
       loading: false,
       networkStatus: NetworkStatus.error,
       partial: true,
@@ -145,9 +145,9 @@ describe("ApolloClient", () => {
     await expect(stream).toEmitApolloQueryResult({
       data: undefined,
       loading: false,
-      error: new CombinedGraphQLErrors([
-        { message: "This is an error message." },
-      ]),
+      error: new CombinedGraphQLErrors({
+        errors: [{ message: "This is an error message." }],
+      }),
       networkStatus: 8,
       partial: true,
     });
@@ -178,9 +178,10 @@ describe("ApolloClient", () => {
 
     await expect(stream).toEmitApolloQueryResult({
       data: undefined,
-      error: new CombinedGraphQLErrors([
-        { message: "This is an error message." },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: { allPeople: { people: { name: "Ada Lovelace" } } },
+        errors: [{ message: "This is an error message." }],
+      }),
       loading: false,
       networkStatus: NetworkStatus.error,
       partial: true,
@@ -246,7 +247,7 @@ describe("ApolloClient", () => {
 
     await expect(stream).toEmitApolloQueryResult({
       data: undefined,
-      error: new CombinedGraphQLErrors([null as any]),
+      error: new CombinedGraphQLErrors({ errors: [null as any] }),
       loading: false,
       networkStatus: NetworkStatus.error,
       partial: true,
@@ -1748,7 +1749,7 @@ describe("ApolloClient", () => {
     });
 
     await expect(client.mutate({ mutation })).rejects.toThrow(
-      new CombinedGraphQLErrors(errors)
+      new CombinedGraphQLErrors({ errors })
     );
   });
 
@@ -2198,7 +2199,7 @@ describe("ApolloClient", () => {
           },
         ]),
       }).query({ query })
-    ).rejects.toEqual(new CombinedGraphQLErrors(graphQLErrors));
+    ).rejects.toEqual(new CombinedGraphQLErrors({ errors: graphQLErrors }));
   });
 
   it("should not empty the store when a non-polling query fails due to a network error", async () => {
@@ -2944,7 +2945,9 @@ describe("ApolloClient", () => {
       partial: false,
     });
 
-    const expectedError = new CombinedGraphQLErrors(secondResult.errors);
+    const expectedError = new CombinedGraphQLErrors({
+      errors: secondResult.errors,
+    });
 
     await expect(handle.refetch()).rejects.toThrow(expectedError);
     await expect(stream).toEmitApolloQueryResult({
diff --git a/src/core/__tests__/ObservableQuery.ts b/src/core/__tests__/ObservableQuery.ts
--- a/src/core/__tests__/ObservableQuery.ts
+++ b/src/core/__tests__/ObservableQuery.ts
@@ -81,7 +81,10 @@ describe("ObservableQuery", () => {
   const error = new GraphQLError("is offline.", undefined, null, null, [
     "people_one",
   ]);
-  const wrappedError = new CombinedGraphQLErrors([error]);
+  const wrappedError = new CombinedGraphQLErrors({
+    data: dataOne,
+    errors: [error],
+  });
 
   describe("reobserve", () => {
     describe("to change pollInterval", () => {
@@ -449,7 +452,7 @@ describe("ObservableQuery", () => {
           },
           {
             request: { query, variables },
-            result: { errors: [error] },
+            result: { data: dataOne, errors: [error] },
           },
           {
             request: { query, variables },
@@ -468,12 +471,12 @@ describe("ObservableQuery", () => {
       });
 
       await expect(observable.refetch()).rejects.toThrow(
-        new CombinedGraphQLErrors([error])
+        new CombinedGraphQLErrors({ data: dataOne, errors: [error] })
       );
 
       await expect(stream).toEmitApolloQueryResult({
         data: dataOne,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ data: dataOne, errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: false,
@@ -1028,14 +1031,14 @@ describe("ObservableQuery", () => {
 
       await expect(stream).toEmitApolloQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
       });
       expect(observable.getCurrentResult()).toEqualStrictTyped({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -2300,7 +2303,7 @@ describe("ObservableQuery", () => {
 
       await expect(stream).toEmitApolloQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -2308,7 +2311,7 @@ describe("ObservableQuery", () => {
 
       expect(observable.getCurrentResult()).toEqualStrictTyped({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -2331,7 +2334,7 @@ describe("ObservableQuery", () => {
 
       await expect(stream).toEmitApolloQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -2342,7 +2345,7 @@ describe("ObservableQuery", () => {
 
       expect(currentResult).toEqualStrictTyped({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -2371,14 +2374,14 @@ describe("ObservableQuery", () => {
 
       await expect(stream).toEmitApolloQueryResult({
         data: dataOne,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ data: dataOne, errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: false,
       });
       expect(observable.getCurrentResult()).toEqualStrictTyped({
         data: dataOne,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ data: dataOne, errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: false,
@@ -2435,7 +2438,7 @@ describe("ObservableQuery", () => {
 
       await expect(stream).toEmitApolloQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ data: dataOne, errors: [error] }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
diff --git a/src/core/__tests__/equalByQuery.ts b/src/core/__tests__/equalByQuery.ts
--- a/src/core/__tests__/equalByQuery.ts
+++ b/src/core/__tests__/equalByQuery.ts
@@ -290,7 +290,10 @@ describe("equalByQuery", () => {
         { data: data123 },
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         }
       )
     ).toBe(false);
@@ -300,7 +303,10 @@ describe("equalByQuery", () => {
         query,
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         },
         { data: data123 }
       )
@@ -311,11 +317,17 @@ describe("equalByQuery", () => {
         query,
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         },
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         }
       )
     ).toBe(true);
@@ -325,11 +337,17 @@ describe("equalByQuery", () => {
         query,
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         },
         {
           data: data123,
-          error: new CombinedGraphQLErrors([differentError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [differentError],
+          }),
         }
       )
     ).toBe(false);
@@ -339,11 +357,17 @@ describe("equalByQuery", () => {
         query,
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         },
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         }
       )
     ).toBe(true);
@@ -353,11 +377,17 @@ describe("equalByQuery", () => {
         query,
         {
           data: data123,
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: data123,
+            errors: [oopsError],
+          }),
         },
         {
           data: { ...data123, b: 100 },
-          error: new CombinedGraphQLErrors([oopsError]),
+          error: new CombinedGraphQLErrors({
+            data: { ...data123, b: 100 },
+            errors: [oopsError],
+          }),
         }
       )
     ).toBe(true);
@@ -365,18 +395,30 @@ describe("equalByQuery", () => {
     expect(
       equalByQuery(
         query,
-        { data: data123, error: new CombinedGraphQLErrors([]) },
-        { data: data123, error: new CombinedGraphQLErrors([]) }
+        {
+          data: data123,
+          error: new CombinedGraphQLErrors({ data: data123, errors: [] }),
+        },
+        {
+          data: data123,
+          error: new CombinedGraphQLErrors({ data: data123, errors: [] }),
+        }
       )
     ).toBe(true);
 
     expect(
       equalByQuery(
         query,
-        { data: data123, error: new CombinedGraphQLErrors([]) },
+        {
+          data: data123,
+          error: new CombinedGraphQLErrors({ data: data123, errors: [] }),
+        },
         {
           data: { ...data123, b: 100 },
-          error: new CombinedGraphQLErrors([]),
+          error: new CombinedGraphQLErrors({
+            data: { ...data123, b: 100 },
+            errors: [],
+          }),
         }
       )
     ).toBe(true);
diff --git a/src/link/subscriptions/__tests__/graphqlWsLink.ts b/src/link/subscriptions/__tests__/graphqlWsLink.ts
--- a/src/link/subscriptions/__tests__/graphqlWsLink.ts
+++ b/src/link/subscriptions/__tests__/graphqlWsLink.ts
@@ -169,7 +169,7 @@ describe("GraphQLWSlink", () => {
 
       const obs = execute(link, { query: subscription });
       await expect(observableToArray(obs)).rejects.toEqual(
-        new CombinedGraphQLErrors([{ message: "Foo bar." }])
+        new CombinedGraphQLErrors({ errors: [{ message: "Foo bar." }] })
       );
     });
   });
diff --git a/src/react/hooks/__tests__/useBackgroundQuery.test.tsx b/src/react/hooks/__tests__/useBackgroundQuery.test.tsx
--- a/src/react/hooks/__tests__/useBackgroundQuery.test.tsx
+++ b/src/react/hooks/__tests__/useBackgroundQuery.test.tsx
@@ -2550,7 +2550,7 @@ it("applies `errorPolicy` on next fetch when it changes between renders", async
       error: null,
       result: {
         data: { greeting: "Hello" },
-        error: new CombinedGraphQLErrors([{ message: "oops" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "oops" }] }),
         networkStatus: NetworkStatus.error,
       },
     });
@@ -3197,7 +3197,7 @@ it("properly handles changing options along with changing `variables`", async ()
             name: "Doctor Strangecache",
           },
         },
-        error: new CombinedGraphQLErrors([{ message: "oops" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "oops" }] }),
         networkStatus: NetworkStatus.error,
       },
     });
@@ -4817,7 +4817,17 @@ it("masks partial data returned from data on errors with errorPolicy `all`", asy
           name: null,
         },
       },
-      error: new CombinedGraphQLErrors([{ message: "Couldn't get name" }]),
+      error: new CombinedGraphQLErrors({
+        data: {
+          currentUser: {
+            __typename: "User",
+            id: 1,
+            name: null,
+            age: 34,
+          },
+        },
+        errors: [{ message: "Couldn't get name" }],
+      }),
       networkStatus: NetworkStatus.error,
     });
   }
@@ -5206,7 +5216,9 @@ describe("refetch", () => {
 
       expect(renderedComponents).toStrictEqual(["ErrorFallback"]);
       expect(snapshot.error).toEqual(
-        new CombinedGraphQLErrors([{ message: "Something went wrong" }])
+        new CombinedGraphQLErrors({
+          errors: [{ message: "Something went wrong" }],
+        })
       );
     }
 
@@ -5400,9 +5412,9 @@ describe("refetch", () => {
               name: "Spider-Man",
             },
           },
-          error: new CombinedGraphQLErrors([
-            { message: "Something went wrong" },
-          ]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "Something went wrong" }],
+          }),
           networkStatus: NetworkStatus.error,
         },
       });
@@ -5501,9 +5513,16 @@ describe("refetch", () => {
               name: null,
             },
           },
-          error: new CombinedGraphQLErrors([
-            { message: "Something went wrong" },
-          ]),
+          error: new CombinedGraphQLErrors({
+            data: {
+              character: {
+                __typename: "Character",
+                id: "1",
+                name: null,
+              },
+            },
+            errors: [{ message: "Something went wrong" }],
+          }),
           networkStatus: NetworkStatus.error,
         },
       });
@@ -5608,7 +5627,10 @@ describe("refetch", () => {
 
       expect(renderedComponents).toStrictEqual([ErrorFallback]);
       expect(snapshot).toEqual({
-        error: new CombinedGraphQLErrors([{ message: "Oops couldn't fetch" }]),
+        error: new CombinedGraphQLErrors({
+          data: null,
+          errors: [{ message: "Oops couldn't fetch" }],
+        }),
         result: null,
       });
     }
@@ -5629,7 +5651,10 @@ describe("refetch", () => {
         // TODO: We should reset the snapshot between renders to better capture
         // the actual result. This makes it seem like the error is rendered, but
         // in this is just leftover from the previous snapshot.
-        error: new CombinedGraphQLErrors([{ message: "Oops couldn't fetch" }]),
+        error: new CombinedGraphQLErrors({
+          data: null,
+          errors: [{ message: "Oops couldn't fetch" }],
+        }),
         result: {
           data: { todo: { id: "1", name: "Clean room", completed: true } },
           error: undefined,
@@ -5735,7 +5760,10 @@ describe("refetch", () => {
 
       expect(renderedComponents).toStrictEqual([ErrorFallback]);
       expect(snapshot).toEqual({
-        error: new CombinedGraphQLErrors([{ message: "Oops couldn't fetch" }]),
+        error: new CombinedGraphQLErrors({
+          data: null,
+          errors: [{ message: "Oops couldn't fetch" }],
+        }),
         result: null,
       });
     }
@@ -5753,9 +5781,10 @@ describe("refetch", () => {
 
       expect(renderedComponents).toStrictEqual([ErrorFallback]);
       expect(snapshot).toEqual({
-        error: new CombinedGraphQLErrors([
-          { message: "Oops couldn't fetch again" },
-        ]),
+        error: new CombinedGraphQLErrors({
+          data: null,
+          errors: [{ message: "Oops couldn't fetch again" }],
+        }),
         result: null,
       });
     }
diff --git a/src/react/hooks/__tests__/useLazyQuery.test.tsx b/src/react/hooks/__tests__/useLazyQuery.test.tsx
--- a/src/react/hooks/__tests__/useLazyQuery.test.tsx
+++ b/src/react/hooks/__tests__/useLazyQuery.test.tsx
@@ -1695,7 +1695,7 @@ describe("useLazyQuery Hook", () => {
     }
 
     await expect(execute()).rejects.toEqual(
-      new CombinedGraphQLErrors([{ message: "error 1" }])
+      new CombinedGraphQLErrors({ errors: [{ message: "error 1" }] })
     );
 
     {
@@ -1707,13 +1707,13 @@ describe("useLazyQuery Hook", () => {
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
-        error: new CombinedGraphQLErrors([{ message: "error 1" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "error 1" }] }),
         variables: {},
       });
     }
 
     await expect(execute()).rejects.toEqual(
-      new CombinedGraphQLErrors([{ message: "error 2" }])
+      new CombinedGraphQLErrors({ errors: [{ message: "error 2" }] })
     );
 
     {
@@ -1725,7 +1725,7 @@ describe("useLazyQuery Hook", () => {
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
-        error: new CombinedGraphQLErrors([{ message: "error 2" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "error 2" }] }),
         variables: {},
       });
     }
@@ -1788,7 +1788,10 @@ describe("useLazyQuery Hook", () => {
 
     await expect(execute()).resolves.toEqualStrictTyped({
       data: { currentUser: null },
-      error: new CombinedGraphQLErrors([{ message: "Not logged in" }]),
+      error: new CombinedGraphQLErrors({
+        data: { currentUser: null },
+        errors: [{ message: "Not logged in" }],
+      }),
     });
 
     {
@@ -1800,14 +1803,20 @@ describe("useLazyQuery Hook", () => {
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Not logged in" }]),
+        error: new CombinedGraphQLErrors({
+          data: { currentUser: null },
+          errors: [{ message: "Not logged in" }],
+        }),
         variables: {},
       });
     }
 
     await expect(execute()).resolves.toEqualStrictTyped({
       data: { currentUser: null },
-      error: new CombinedGraphQLErrors([{ message: "Not logged in 2" }]),
+      error: new CombinedGraphQLErrors({
+        data: { currentUser: null },
+        errors: [{ message: "Not logged in 2" }],
+      }),
     });
 
     {
@@ -1819,7 +1828,10 @@ describe("useLazyQuery Hook", () => {
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Not logged in 2" }]),
+        error: new CombinedGraphQLErrors({
+          data: { currentUser: null },
+          errors: [{ message: "Not logged in 2" }],
+        }),
         variables: {},
       });
     }
@@ -2411,7 +2423,7 @@ describe("useLazyQuery Hook", () => {
     expect(execute).toBe(originalExecute);
 
     await expect(execute({ variables: { id: "2" } })).rejects.toEqual(
-      new CombinedGraphQLErrors([{ message: "Oops" }])
+      new CombinedGraphQLErrors({ errors: [{ message: "Oops" }] })
     );
 
     {
@@ -2419,7 +2431,7 @@ describe("useLazyQuery Hook", () => {
 
       expect(result).toEqualLazyQueryResult({
         data: { user: { id: "1", name: "John Doe" } },
-        error: new CombinedGraphQLErrors([{ message: "Oops" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "Oops" }] }),
         called: true,
         loading: false,
         networkStatus: NetworkStatus.error,
@@ -2446,7 +2458,7 @@ describe("useLazyQuery Hook", () => {
 
       expect(result).toEqualLazyQueryResult({
         data: { user: { id: "1", name: "John Doe" } },
-        error: new CombinedGraphQLErrors([{ message: "Oops" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "Oops" }] }),
         called: true,
         loading: false,
         networkStatus: NetworkStatus.error,
@@ -4271,9 +4283,10 @@ test("applies `errorPolicy` on next fetch when it changes between renders", asyn
       data: {
         character: null,
       },
-      error: new CombinedGraphQLErrors([
-        { message: "Could not find character 1" },
-      ]),
+      error: new CombinedGraphQLErrors({
+        data: { character: null },
+        errors: [{ message: "Could not find character 1" }],
+      }),
       called: true,
       loading: false,
       networkStatus: NetworkStatus.error,
diff --git a/src/react/hooks/__tests__/useLoadableQuery.test.tsx b/src/react/hooks/__tests__/useLoadableQuery.test.tsx
--- a/src/react/hooks/__tests__/useLoadableQuery.test.tsx
+++ b/src/react/hooks/__tests__/useLoadableQuery.test.tsx
@@ -1804,7 +1804,7 @@ it("applies `errorPolicy` on next fetch when it changes between renders", async
     expect(renderedComponents).not.toContain(ErrorFallback);
     expect(snapshot.result).toEqual({
       data: { greeting: "Hello" },
-      error: new CombinedGraphQLErrors([{ message: "oops" }]),
+      error: new CombinedGraphQLErrors({ errors: [{ message: "oops" }] }),
       networkStatus: NetworkStatus.error,
     });
   }
@@ -2723,7 +2723,9 @@ it("throws errors when errors are returned after calling `refetch`", async () =>
 
     expect(renderedComponents).toStrictEqual([ErrorFallback]);
     expect(snapshot.error).toEqual(
-      new CombinedGraphQLErrors([{ message: "Something went wrong" }])
+      new CombinedGraphQLErrors({
+        errors: [{ message: "Something went wrong" }],
+      })
     );
   }
 });
@@ -2895,7 +2897,9 @@ it('returns errors after calling `refetch` when errorPolicy is set to "all"', as
     expect(snapshot.error).toBeNull();
     expect(snapshot.result).toEqual({
       data: { character: { id: "1", name: "Captain Marvel" } },
-      error: new CombinedGraphQLErrors([{ message: "Something went wrong" }]),
+      error: new CombinedGraphQLErrors({
+        errors: [{ message: "Something went wrong" }],
+      }),
       networkStatus: NetworkStatus.error,
     });
   }
@@ -2983,7 +2987,10 @@ it('handles partial data results after calling `refetch` when errorPolicy is set
     expect(snapshot.error).toBeNull();
     expect(snapshot.result).toEqual({
       data: { character: { id: "1", name: null } },
-      error: new CombinedGraphQLErrors([{ message: "Something went wrong" }]),
+      error: new CombinedGraphQLErrors({
+        data: { character: { id: "1", name: null } },
+        errors: [{ message: "Something went wrong" }],
+      }),
       networkStatus: NetworkStatus.error,
     });
   }
diff --git a/src/react/hooks/__tests__/useMutation.test.tsx b/src/react/hooks/__tests__/useMutation.test.tsx
--- a/src/react/hooks/__tests__/useMutation.test.tsx
+++ b/src/react/hooks/__tests__/useMutation.test.tsx
@@ -430,12 +430,18 @@ describe("useMutation Hook", () => {
       const [createTodo] = getCurrentSnapshot();
 
       await expect(createTodo({ variables })).rejects.toThrow(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }])
+        new CombinedGraphQLErrors({
+          data: CREATE_TODO_RESULT,
+          errors: [{ message: CREATE_TODO_ERROR }],
+        })
       );
 
       expect(onError).toHaveBeenCalledTimes(1);
       expect(onError).toHaveBeenLastCalledWith(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+        new CombinedGraphQLErrors({
+          data: CREATE_TODO_RESULT,
+          errors: [{ message: CREATE_TODO_ERROR }],
+        }),
         expect.anything()
       );
     });
@@ -483,7 +489,7 @@ describe("useMutation Hook", () => {
       const [createTodo] = getCurrentSnapshot();
 
       await expect(createTodo({ variables })).rejects.toThrow(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }])
+        new CombinedGraphQLErrors({ errors: [{ message: CREATE_TODO_ERROR }] })
       );
 
       {
@@ -502,7 +508,9 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: CREATE_TODO_ERROR }],
+          }),
           loading: false,
           called: true,
         });
@@ -555,7 +563,7 @@ describe("useMutation Hook", () => {
       const [createTodo] = getCurrentSnapshot();
 
       await expect(createTodo({ variables })).rejects.toThrow(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }])
+        new CombinedGraphQLErrors({ errors: [{ message: CREATE_TODO_ERROR }] })
       );
 
       {
@@ -574,7 +582,10 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+          error: new CombinedGraphQLErrors({
+            data: CREATE_TODO_RESULT,
+            errors: [{ message: CREATE_TODO_ERROR }],
+          }),
           loading: false,
           called: true,
         });
@@ -628,7 +639,10 @@ describe("useMutation Hook", () => {
 
       await expect(createTodo({ variables })).resolves.toEqualStrictTyped({
         data: CREATE_TODO_RESULT,
-        error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+        error: new CombinedGraphQLErrors({
+          data: CREATE_TODO_RESULT,
+          errors: [{ message: CREATE_TODO_ERROR }],
+        }),
       });
 
       {
@@ -647,7 +661,10 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: CREATE_TODO_RESULT,
-          error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+          error: new CombinedGraphQLErrors({
+            data: CREATE_TODO_RESULT,
+            errors: [{ message: CREATE_TODO_ERROR }],
+          }),
           loading: false,
           called: true,
         });
@@ -709,7 +726,10 @@ describe("useMutation Hook", () => {
 
       await expect(createTodo({ variables })).resolves.toEqualStrictTyped({
         data: CREATE_TODO_RESULT,
-        error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+        error: new CombinedGraphQLErrors({
+          data: CREATE_TODO_RESULT,
+          errors: [{ message: CREATE_TODO_ERROR }],
+        }),
       });
 
       {
@@ -728,7 +748,10 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: CREATE_TODO_RESULT,
-          error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+          error: new CombinedGraphQLErrors({
+            data: CREATE_TODO_RESULT,
+            errors: [{ message: CREATE_TODO_ERROR }],
+          }),
           loading: false,
           called: true,
         });
@@ -736,7 +759,10 @@ describe("useMutation Hook", () => {
 
       expect(onError).toHaveBeenCalledTimes(1);
       expect(onError).toHaveBeenLastCalledWith(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+        new CombinedGraphQLErrors({
+          data: CREATE_TODO_RESULT,
+          errors: [{ message: CREATE_TODO_ERROR }],
+        }),
         expect.anything()
       );
       expect(onCompleted).not.toHaveBeenCalled();
@@ -1473,7 +1499,7 @@ describe("useMutation Hook", () => {
 
       await expect(
         createTodo({ variables, onCompleted, onError })
-      ).rejects.toThrow(new CombinedGraphQLErrors(errors));
+      ).rejects.toThrow(new CombinedGraphQLErrors({ errors }));
 
       {
         const [, result] = await takeSnapshot();
@@ -1491,7 +1517,7 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: undefined,
-          error: new CombinedGraphQLErrors(errors),
+          error: new CombinedGraphQLErrors({ errors }),
           loading: false,
           called: true,
         });
@@ -1502,7 +1528,7 @@ describe("useMutation Hook", () => {
       expect(onCompleted).toHaveBeenCalledTimes(0);
       expect(onError).toHaveBeenCalledTimes(1);
       expect(onError).toHaveBeenCalledWith(
-        new CombinedGraphQLErrors(errors),
+        new CombinedGraphQLErrors({ errors }),
         expect.objectContaining({ variables })
       );
     });
@@ -1552,7 +1578,7 @@ describe("useMutation Hook", () => {
       const [createTodo] = getCurrentSnapshot();
       const onError = jest.fn();
       await expect(createTodo({ variables, onError })).rejects.toThrow(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }])
+        new CombinedGraphQLErrors({ errors: [{ message: CREATE_TODO_ERROR }] })
       );
 
       {
@@ -1571,7 +1597,9 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: CREATE_TODO_ERROR }],
+          }),
           loading: false,
           called: true,
         });
@@ -1579,7 +1607,7 @@ describe("useMutation Hook", () => {
 
       expect(onError).toHaveBeenCalledTimes(1);
       expect(onError).toHaveBeenCalledWith(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+        new CombinedGraphQLErrors({ errors: [{ message: CREATE_TODO_ERROR }] }),
         expect.objectContaining({ variables })
       );
       expect(hookOnError).not.toHaveBeenCalled();
@@ -1652,7 +1680,7 @@ describe("useMutation Hook", () => {
       }
 
       await expect(createTodo({ variables })).rejects.toThrow(
-        new CombinedGraphQLErrors(errors)
+        new CombinedGraphQLErrors({ errors })
       );
 
       {
@@ -1671,7 +1699,7 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: undefined,
-          error: new CombinedGraphQLErrors(errors),
+          error: new CombinedGraphQLErrors({ errors }),
           loading: false,
           called: true,
         });
@@ -1683,7 +1711,7 @@ describe("useMutation Hook", () => {
       expect(onError).toHaveBeenCalledTimes(0);
       expect(onError1).toHaveBeenCalledTimes(1);
       expect(onError1).toHaveBeenCalledWith(
-        new CombinedGraphQLErrors(errors),
+        new CombinedGraphQLErrors({ errors }),
         expect.objectContaining({ variables })
       );
     });
@@ -4000,7 +4028,7 @@ describe("useMutation Hook", () => {
       );
 
       await expect(promise).rejects.toThrow(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }])
+        new CombinedGraphQLErrors({ errors: [{ message: CREATE_TODO_ERROR }] })
       );
 
       {
@@ -4008,7 +4036,9 @@ describe("useMutation Hook", () => {
 
         expect(result).toEqualStrictTyped({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: CREATE_TODO_ERROR }],
+          }),
           loading: false,
           called: true,
         });
@@ -4018,7 +4048,7 @@ describe("useMutation Hook", () => {
 
       expect(onError).toHaveBeenCalledTimes(1);
       expect(onError).toHaveBeenLastCalledWith(
-        new CombinedGraphQLErrors([{ message: CREATE_TODO_ERROR }]),
+        new CombinedGraphQLErrors({ errors: [{ message: CREATE_TODO_ERROR }] }),
         expect.anything()
       );
       expect(consoleSpies.error).not.toHaveBeenCalled();
diff --git a/src/react/hooks/__tests__/useQuery.test.tsx b/src/react/hooks/__tests__/useQuery.test.tsx
--- a/src/react/hooks/__tests__/useQuery.test.tsx
+++ b/src/react/hooks/__tests__/useQuery.test.tsx
@@ -2913,7 +2913,7 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error" }]),
+          error: new CombinedGraphQLErrors({ errors: [{ message: "error" }] }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -2968,9 +2968,10 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([
-            { message: 'Could not fetch "hello"' },
-          ]),
+          error: new CombinedGraphQLErrors({
+            data: { hello: null },
+            errors: [{ message: 'Could not fetch "hello"' }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3137,9 +3138,10 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: { hello: null },
-          error: new CombinedGraphQLErrors([
-            { message: 'Could not fetch "hello"' },
-          ]),
+          error: new CombinedGraphQLErrors({
+            data: { hello: null },
+            errors: [{ message: 'Could not fetch "hello"' }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3251,7 +3253,7 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error" }]),
+          error: new CombinedGraphQLErrors({ errors: [{ message: "error" }] }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3266,7 +3268,7 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error" }]),
+          error: new CombinedGraphQLErrors({ errors: [{ message: "error" }] }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3562,7 +3564,7 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error" }]),
+          error: new CombinedGraphQLErrors({ errors: [{ message: "error" }] }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3678,7 +3680,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error 1" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "error 1" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3687,7 +3691,7 @@ describe("useQuery Hook", () => {
       }
 
       await expect(getCurrentSnapshot().refetch()).rejects.toEqual(
-        new CombinedGraphQLErrors([{ message: "error 2" }])
+        new CombinedGraphQLErrors({ errors: [{ message: "error 2" }] })
       );
 
       {
@@ -3707,7 +3711,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error 2" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "error 2" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3771,7 +3777,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error 1" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "error 1" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3780,7 +3788,7 @@ describe("useQuery Hook", () => {
       }
 
       await expect(getCurrentSnapshot().refetch()).rejects.toEqual(
-        new CombinedGraphQLErrors([{ message: "error 2" }])
+        new CombinedGraphQLErrors({ errors: [{ message: "error 2" }] })
       );
 
       {
@@ -3788,7 +3796,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "error 2" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "error 2" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3852,7 +3862,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "same error" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "same error" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3861,7 +3873,7 @@ describe("useQuery Hook", () => {
       }
 
       await expect(getCurrentSnapshot().refetch()).rejects.toEqual(
-        new CombinedGraphQLErrors([{ message: "same error" }])
+        new CombinedGraphQLErrors({ errors: [{ message: "same error" }] })
       );
 
       {
@@ -3881,7 +3893,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "same error" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "same error" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3951,7 +3965,9 @@ describe("useQuery Hook", () => {
 
         expect(result).toEqualQueryResult({
           data: undefined,
-          error: new CombinedGraphQLErrors([{ message: "same error" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "same error" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
@@ -3985,7 +4001,7 @@ describe("useQuery Hook", () => {
       }
 
       await expect(getCurrentSnapshot().refetch()).rejects.toEqual(
-        new CombinedGraphQLErrors([{ message: "same error" }])
+        new CombinedGraphQLErrors({ errors: [{ message: "same error" }] })
       );
 
       {
@@ -4004,7 +4020,9 @@ describe("useQuery Hook", () => {
         expect(result).toEqualQueryResult({
           // TODO: Is this correct behavior here?
           data: { hello: "world" },
-          error: new CombinedGraphQLErrors([{ message: "same error" }]),
+          error: new CombinedGraphQLErrors({
+            errors: [{ message: "same error" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: { hello: "world" },
@@ -4947,7 +4965,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -4972,7 +4993,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -4994,7 +5018,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5007,7 +5034,10 @@ describe("useQuery Hook", () => {
         snapshot.useQueryResult?.observable.getCurrentResult(false)!
       ).toEqualStrictTyped({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -5051,7 +5081,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5064,7 +5097,10 @@ describe("useQuery Hook", () => {
         snapshot.useQueryResult?.observable.getCurrentResult(false)!
       ).toEqualStrictTyped({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         partial: true,
@@ -5218,7 +5254,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5243,7 +5282,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5268,7 +5310,10 @@ describe("useQuery Hook", () => {
       // the other query has finished and re-rendered.
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5464,7 +5509,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5489,7 +5537,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -5511,7 +5562,10 @@ describe("useQuery Hook", () => {
 
       expect(snapshot.useQueryResult!).toEqualQueryResult({
         data: undefined,
-        error: new CombinedGraphQLErrors([{ message: "Intentional error" }]),
+        error: new CombinedGraphQLErrors({
+          data: { person: null },
+          errors: [{ message: "Intentional error" }],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: undefined,
@@ -9368,13 +9422,15 @@ describe("useQuery Hook", () => {
             name: "R2-D2",
           },
         },
-        error: new CombinedGraphQLErrors([
-          {
-            message:
-              "homeWorld for character with ID 1000 could not be fetched.",
-            path: ["hero", "heroFriends", 0, "homeWorld"],
-          },
-        ]),
+        error: new CombinedGraphQLErrors({
+          errors: [
+            {
+              message:
+                "homeWorld for character with ID 1000 could not be fetched.",
+              path: ["hero", "heroFriends", 0, "homeWorld"],
+            },
+          ],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: {
@@ -9542,13 +9598,24 @@ describe("useQuery Hook", () => {
             name: "R2-D2",
           },
         },
-        error: new CombinedGraphQLErrors([
-          {
-            message:
-              "homeWorld for character with ID 1000 could not be fetched.",
-            path: ["hero", "heroFriends", 0, "homeWorld"],
+        error: new CombinedGraphQLErrors({
+          data: {
+            hero: {
+              heroFriends: [
+                { homeWorld: null, id: "1000", name: "Luke Skywalker" },
+                { homeWorld: "Alderaan", id: "1003", name: "Leia Organa" },
+              ],
+              name: "R2-D2",
+            },
           },
-        ]),
+          errors: [
+            {
+              message:
+                "homeWorld for character with ID 1000 could not be fetched.",
+              path: ["hero", "heroFriends", 0, "homeWorld"],
+            },
+          ],
+        }),
         loading: false,
         networkStatus: NetworkStatus.error,
         previousData: {
@@ -10002,7 +10069,10 @@ describe("useQuery Hook", () => {
 
     await expect(takeSnapshot()).resolves.toEqualQueryResult({
       data: undefined,
-      error: new CombinedGraphQLErrors([graphQLError]),
+      error: new CombinedGraphQLErrors({
+        data: { user: { __typename: "User", id: "1", name: null } },
+        errors: [graphQLError],
+      }),
       loading: false,
       networkStatus: NetworkStatus.error,
       previousData: undefined,
@@ -10024,7 +10094,10 @@ describe("useQuery Hook", () => {
 
     await expect(takeSnapshot()).resolves.toEqualQueryResult({
       data: undefined,
-      error: new CombinedGraphQLErrors([graphQLError]),
+      error: new CombinedGraphQLErrors({
+        data: { user: { __typename: "User", id: "1", name: null } },
+        errors: [graphQLError],
+      }),
       loading: false,
       networkStatus: NetworkStatus.error,
       previousData: undefined,
@@ -10999,7 +11072,12 @@ describe("useQuery Hook", () => {
               name: null,
             },
           },
-          error: new CombinedGraphQLErrors([{ message: "Couldn't get name" }]),
+          error: new CombinedGraphQLErrors({
+            data: {
+              currentUser: { __typename: "User", id: 1, name: null, age: 34 },
+            },
+            errors: [{ message: "Couldn't get name" }],
+          }),
           loading: false,
           networkStatus: NetworkStatus.error,
           previousData: undefined,
diff --git a/src/react/hooks/__tests__/useSubscription.test.tsx b/src/react/hooks/__tests__/useSubscription.test.tsx
--- a/src/react/hooks/__tests__/useSubscription.test.tsx
+++ b/src/react/hooks/__tests__/useSubscription.test.tsx
@@ -154,7 +154,10 @@ describe("useSubscription Hook", () => {
 
     await expect(takeSnapshot()).resolves.toEqualStrictTyped({
       data: undefined,
-      error: new CombinedGraphQLErrors([{ message: "test" }]),
+      error: new CombinedGraphQLErrors({
+        data: errorResult.result.data,
+        errors: [{ message: "test" }],
+      }),
       loading: false,
     });
 
@@ -162,7 +165,10 @@ describe("useSubscription Hook", () => {
 
     expect(onError).toHaveBeenCalledTimes(1);
     expect(onError).toHaveBeenCalledWith(
-      new CombinedGraphQLErrors([{ message: "test" }])
+      new CombinedGraphQLErrors({
+        data: errorResult.result.data,
+        errors: [{ message: "test" }],
+      })
     );
   });
 
@@ -233,14 +239,20 @@ describe("useSubscription Hook", () => {
 
     await expect(takeSnapshot()).resolves.toEqualStrictTyped({
       data: undefined,
-      error: new CombinedGraphQLErrors([{ message: "test" }]),
+      error: new CombinedGraphQLErrors({
+        data: errorResult.result.data,
+        errors: [{ message: "test" }],
+      }),
       loading: false,
     });
 
     expect(onData).toHaveBeenCalledTimes(1);
     expect(onError).toHaveBeenCalledTimes(1);
     expect(onError).toHaveBeenLastCalledWith(
-      new CombinedGraphQLErrors([{ message: "test" }])
+      new CombinedGraphQLErrors({
+        data: errorResult.result.data,
+        errors: [{ message: "test" }],
+      })
     );
     expect(onComplete).toHaveBeenCalledTimes(0);
 
@@ -1241,16 +1253,14 @@ followed by new in-flight setup", async () => {
             const snapshot = await takeSnapshot();
             expect(snapshot).toEqualStrictTyped({
               loading: false,
-              error: new CombinedGraphQLErrors(
-                graphQlErrorResult.result!.errors as any
-              ),
+              error: new CombinedGraphQLErrors(graphQlErrorResult.result!),
               data: undefined,
             });
           }
 
           expect(onError).toHaveBeenCalledTimes(1);
           expect(onError).toHaveBeenCalledWith(
-            new CombinedGraphQLErrors(graphQlErrorResult.result!.errors!)
+            new CombinedGraphQLErrors(graphQlErrorResult.result!)
           );
           expect(onData).toHaveBeenCalledTimes(0);
           expect(errorBoundaryOnError).toHaveBeenCalledTimes(0);
@@ -1275,16 +1285,14 @@ followed by new in-flight setup", async () => {
           const snapshot = await takeSnapshot();
           expect(snapshot).toEqualStrictTyped({
             loading: false,
-            error: new CombinedGraphQLErrors(
-              graphQlErrorResult.result!.errors!
-            ),
+            error: new CombinedGraphQLErrors(graphQlErrorResult.result!),
             data: { totalLikes: 42 },
           });
         }
 
         expect(onError).toHaveBeenCalledTimes(1);
         expect(onError).toHaveBeenCalledWith(
-          new CombinedGraphQLErrors(graphQlErrorResult.result!.errors!)
+          new CombinedGraphQLErrors(graphQlErrorResult.result!)
         );
         expect(onData).toHaveBeenCalledTimes(0);
         expect(errorBoundaryOnError).toHaveBeenCalledTimes(0);
@@ -1754,7 +1762,7 @@ describe("`restart` callback", () => {
       expect(snapshot).toEqualStrictTyped({
         loading: false,
         data: undefined,
-        error: new CombinedGraphQLErrors([error]),
+        error: new CombinedGraphQLErrors({ errors: [error] }),
       });
     }
 
diff --git a/src/react/hooks/__tests__/useSuspenseQuery.test.tsx b/src/react/hooks/__tests__/useSuspenseQuery.test.tsx
--- a/src/react/hooks/__tests__/useSuspenseQuery.test.tsx
+++ b/src/react/hooks/__tests__/useSuspenseQuery.test.tsx
@@ -3560,7 +3560,9 @@ describe("useSuspenseQuery", () => {
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
     expect(error).toEqual(
-      new CombinedGraphQLErrors([{ message: "`id` should not be null" }])
+      new CombinedGraphQLErrors({
+        errors: [{ message: "`id` should not be null" }],
+      })
     );
   });
 
@@ -3697,7 +3699,9 @@ describe("useSuspenseQuery", () => {
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
     expect(error).toEqual(
-      new CombinedGraphQLErrors([{ message: "`id` should not be null" }])
+      new CombinedGraphQLErrors({
+        errors: [{ message: "`id` should not be null" }],
+      })
     );
   });
 
@@ -3725,7 +3729,7 @@ describe("useSuspenseQuery", () => {
     const [error] = renders.errors;
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
-    expect(error).toEqual(new CombinedGraphQLErrors(graphQLErrors));
+    expect(error).toEqual(new CombinedGraphQLErrors({ errors: graphQLErrors }));
   });
 
   it('does not throw or return network errors when errorPolicy is set to "ignore"', async () => {
@@ -3952,7 +3956,7 @@ describe("useSuspenseQuery", () => {
       expect(result.current).toEqualStrictTyped({
         data: undefined,
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([graphQLError]),
+        error: new CombinedGraphQLErrors({ errors: [graphQLError] }),
       });
     });
 
@@ -3964,14 +3968,16 @@ describe("useSuspenseQuery", () => {
       {
         data: undefined,
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([graphQLError]),
+        error: new CombinedGraphQLErrors({ errors: [graphQLError] }),
       },
     ]);
 
     const { error } = result.current;
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
-    expect(error).toEqual(new CombinedGraphQLErrors([graphQLError]));
+    expect(error).toEqual(
+      new CombinedGraphQLErrors({ errors: [graphQLError] })
+    );
   });
 
   it('responds to cache updates and clears errors after an error returns when errorPolicy is set to "all"', async () => {
@@ -3993,7 +3999,7 @@ describe("useSuspenseQuery", () => {
       expect(result.current).toEqualStrictTyped({
         data: undefined,
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([graphQLError]),
+        error: new CombinedGraphQLErrors({ errors: [graphQLError] }),
       });
     });
 
@@ -4027,7 +4033,7 @@ describe("useSuspenseQuery", () => {
       {
         data: undefined,
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([graphQLError]),
+        error: new CombinedGraphQLErrors({ errors: [graphQLError] }),
       },
       {
         data: { currentUser: { id: "1", name: "Cache User" } },
@@ -4050,7 +4056,7 @@ describe("useSuspenseQuery", () => {
       { mocks }
     );
 
-    const expectedError = new CombinedGraphQLErrors(graphQLErrors);
+    const expectedError = new CombinedGraphQLErrors({ errors: graphQLErrors });
 
     await waitFor(() => {
       expect(result.current).toEqualStrictTyped({
@@ -4091,7 +4097,10 @@ describe("useSuspenseQuery", () => {
       { mocks }
     );
 
-    const expectedError = new CombinedGraphQLErrors([graphQLError]);
+    const expectedError = new CombinedGraphQLErrors({
+      data: { currentUser: { id: "1", name: null } },
+      errors: [graphQLError],
+    });
 
     await waitFor(() => {
       expect(result.current).toEqualStrictTyped({
@@ -4122,7 +4131,7 @@ describe("useSuspenseQuery", () => {
       { mocks }
     );
 
-    const expectedError = new CombinedGraphQLErrors([graphQLError]);
+    const expectedError = new CombinedGraphQLErrors({ errors: [graphQLError] });
 
     await waitFor(() => {
       expect(result.current.error).toEqual(expectedError);
@@ -4168,7 +4177,7 @@ describe("useSuspenseQuery", () => {
       { mocks, initialProps: { id: "1" } }
     );
 
-    const expectedError = new CombinedGraphQLErrors(graphQLErrors);
+    const expectedError = new CombinedGraphQLErrors({ errors: graphQLErrors });
 
     await waitFor(() => {
       expect(result.current).toEqualStrictTyped({
@@ -4584,7 +4593,9 @@ describe("useSuspenseQuery", () => {
     });
 
     expect(renders.errors).toEqual([
-      new CombinedGraphQLErrors([{ message: "Something went wrong" }]),
+      new CombinedGraphQLErrors({
+        errors: [{ message: "Something went wrong" }],
+      }),
     ]);
     expect(renders.frames).toEqualStrictTyped([
       {
@@ -4695,9 +4706,9 @@ describe("useSuspenseQuery", () => {
       { mocks }
     );
 
-    const expectedError = new CombinedGraphQLErrors([
-      { message: "Something went wrong" },
-    ]);
+    const expectedError = new CombinedGraphQLErrors({
+      errors: [{ message: "Something went wrong" }],
+    });
 
     await waitFor(() => {
       expect(result.current).toEqualStrictTyped({
@@ -4772,9 +4783,10 @@ describe("useSuspenseQuery", () => {
       { mocks }
     );
 
-    const expectedError = new CombinedGraphQLErrors([
-      { message: "Something went wrong" },
-    ]);
+    const expectedError = new CombinedGraphQLErrors({
+      data: { user: { id: "1", name: null } },
+      errors: [{ message: "Something went wrong" }],
+    });
 
     await waitFor(() => {
       expect(result.current).toEqualStrictTyped({
@@ -6089,7 +6101,7 @@ describe("useSuspenseQuery", () => {
       expect(result.current).toEqualStrictTyped({
         ...successMock.result,
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([{ message: "oops" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "oops" }] }),
       });
     });
 
@@ -6114,7 +6126,7 @@ describe("useSuspenseQuery", () => {
       {
         ...successMock.result,
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([{ message: "oops" }]),
+        error: new CombinedGraphQLErrors({ errors: [{ message: "oops" }] }),
       },
     ]);
   });
@@ -6664,7 +6676,9 @@ describe("useSuspenseQuery", () => {
       void result.current.refetch();
     });
 
-    const expectedError = new CombinedGraphQLErrors([{ message: "oops" }]);
+    const expectedError = new CombinedGraphQLErrors({
+      errors: [{ message: "oops" }],
+    });
 
     await waitFor(() => {
       expect(result.current).toEqualStrictTyped({
@@ -8577,7 +8591,9 @@ describe("useSuspenseQuery", () => {
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
     expect(error).toEqual(
-      new CombinedGraphQLErrors([{ message: "Could not fetch greeting" }])
+      new CombinedGraphQLErrors({
+        errors: [{ message: "Could not fetch greeting" }],
+      })
     );
   });
 
@@ -8623,7 +8639,10 @@ describe("useSuspenseQuery", () => {
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
     expect(error).toEqual(
-      new CombinedGraphQLErrors([{ message: "Could not fetch greeting" }])
+      new CombinedGraphQLErrors({
+        data: { greeting: null },
+        errors: [{ message: "Could not fetch greeting" }],
+      })
     );
   });
 
@@ -8754,12 +8773,15 @@ describe("useSuspenseQuery", () => {
 
     expect(error).toBeInstanceOf(CombinedGraphQLErrors);
     expect(error).toEqual(
-      new CombinedGraphQLErrors([
-        {
-          message: "homeWorld for character with ID 1000 could not be fetched.",
-          path: ["hero", "heroFriends", 0, "homeWorld"],
-        },
-      ])
+      new CombinedGraphQLErrors({
+        errors: [
+          {
+            message:
+              "homeWorld for character with ID 1000 could not be fetched.",
+            path: ["hero", "heroFriends", 0, "homeWorld"],
+          },
+        ],
+      })
     );
   });
 
@@ -8877,13 +8899,32 @@ describe("useSuspenseQuery", () => {
           },
         },
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([
-          {
-            message:
-              "homeWorld for character with ID 1000 could not be fetched.",
-            path: ["hero", "heroFriends", 0, "homeWorld"],
+        error: new CombinedGraphQLErrors({
+          data: {
+            hero: {
+              heroFriends: [
+                {
+                  id: "1000",
+                  name: "Luke Skywalker",
+                  homeWorld: null,
+                },
+                {
+                  id: "1003",
+                  name: "Leia Organa",
+                  homeWorld: "Alderaan",
+                },
+              ],
+              name: "R2-D2",
+            },
           },
-        ]),
+          errors: [
+            {
+              message:
+                "homeWorld for character with ID 1000 could not be fetched.",
+              path: ["hero", "heroFriends", 0, "homeWorld"],
+            },
+          ],
+        }),
       });
     });
 
@@ -8928,13 +8969,32 @@ describe("useSuspenseQuery", () => {
           },
         },
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([
-          {
-            message:
-              "homeWorld for character with ID 1000 could not be fetched.",
-            path: ["hero", "heroFriends", 0, "homeWorld"],
+        error: new CombinedGraphQLErrors({
+          data: {
+            hero: {
+              heroFriends: [
+                {
+                  id: "1000",
+                  name: "Luke Skywalker",
+                  homeWorld: null,
+                },
+                {
+                  id: "1003",
+                  name: "Leia Organa",
+                  homeWorld: "Alderaan",
+                },
+              ],
+              name: "R2-D2",
+            },
           },
-        ]),
+          errors: [
+            {
+              message:
+                "homeWorld for character with ID 1000 could not be fetched.",
+              path: ["hero", "heroFriends", 0, "homeWorld"],
+            },
+          ],
+        }),
       },
     ]);
   });
@@ -9198,13 +9258,24 @@ describe("useSuspenseQuery", () => {
           },
         },
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([
-          {
-            message:
-              "homeWorld for character with ID 1000 could not be fetched.",
-            path: ["hero", "heroFriends", 0, "homeWorld"],
+        error: new CombinedGraphQLErrors({
+          data: {
+            hero: {
+              heroFriends: [
+                { id: "1000", name: "Luke Skywalker", homeWorld: null },
+                { id: "1003", name: "Leia Organa", homeWorld: "Alderaan" },
+              ],
+              name: "R2-D2",
+            },
           },
-        ]),
+          errors: [
+            {
+              message:
+                "homeWorld for character with ID 1000 could not be fetched.",
+              path: ["hero", "heroFriends", 0, "homeWorld"],
+            },
+          ],
+        }),
       });
     });
 
@@ -9345,13 +9416,24 @@ describe("useSuspenseQuery", () => {
           },
         },
         networkStatus: NetworkStatus.error,
-        error: new CombinedGraphQLErrors([
-          {
-            message:
-              "homeWorld for character with ID 1000 could not be fetched.",
-            path: ["hero", "heroFriends", 0, "homeWorld"],
+        error: new CombinedGraphQLErrors({
+          data: {
+            hero: {
+              heroFriends: [
+                { id: "1000", name: "Luke Skywalker", homeWorld: null },
+                { id: "1003", name: "Leia Organa", homeWorld: "Alderaan" },
+              ],
+              name: "R2-D2",
+            },
           },
-        ]),
+          errors: [
+            {
+              message:
+                "homeWorld for character with ID 1000 could not be fetched.",
+              path: ["hero", "heroFriends", 0, "homeWorld"],
+            },
+          ],
+        }),
       },
       {
         data: {
@@ -10670,7 +10752,10 @@ describe("useSuspenseQuery", () => {
 
       expect(renderedComponents).toStrictEqual([ErrorFallback]);
       expect(snapshot.error).toEqual(
-        new CombinedGraphQLErrors([{ message: "Could not fetch letters" }])
+        new CombinedGraphQLErrors({
+          data: null,
+          errors: [{ message: "Could not fetch letters" }],
+        })
       );
     }
 
@@ -11611,7 +11696,17 @@ describe("useSuspenseQuery", () => {
       });
 
       expect(result?.error).toEqual(
-        new CombinedGraphQLErrors([{ message: "Couldn't get name" }])
+        new CombinedGraphQLErrors({
+          data: {
+            currentUser: {
+              __typename: "User",
+              id: 1,
+              name: null,
+              age: 34,
+            },
+          },
+          errors: [{ message: "Couldn't get name" }],
+        })
       );
     }
   });
diff --git a/src/react/query-preloader/__tests__/createQueryPreloader.test.tsx b/src/react/query-preloader/__tests__/createQueryPreloader.test.tsx
--- a/src/react/query-preloader/__tests__/createQueryPreloader.test.tsx
+++ b/src/react/query-preloader/__tests__/createQueryPreloader.test.tsx
@@ -1499,7 +1499,7 @@ test("throws when error is returned", async () => {
 
     expect(renderedComponents).toStrictEqual(["ErrorFallback"]);
     expect(snapshot.error).toEqual(
-      new CombinedGraphQLErrors([{ message: "Oops" }])
+      new CombinedGraphQLErrors({ errors: [{ message: "Oops" }] })
     );
   }
 });
@@ -1532,7 +1532,7 @@ test("returns error when error policy is 'all'", async () => {
     expect(renderedComponents).toStrictEqual(["ReadQueryHook"]);
     expect(snapshot.result).toEqual({
       data: undefined,
-      error: new CombinedGraphQLErrors([{ message: "Oops" }]),
+      error: new CombinedGraphQLErrors({ errors: [{ message: "Oops" }] }),
       networkStatus: NetworkStatus.error,
     });
     expect(snapshot.error).toEqual(null);
diff --git a/src/react/ssr/__tests__/getDataFromTree.test.tsx b/src/react/ssr/__tests__/getDataFromTree.test.tsx
--- a/src/react/ssr/__tests__/getDataFromTree.test.tsx
+++ b/src/react/ssr/__tests__/getDataFromTree.test.tsx
@@ -125,7 +125,10 @@ describe("SSR", () => {
           expect(data).toMatchObject({ allPeople: { people: null } });
           expect(error).toBeDefined();
           expect(error).toEqual(
-            new CombinedGraphQLErrors([{ message: "this is an error" }])
+            new CombinedGraphQLErrors({
+              data: { allPeople: { people: null } },
+              errors: [{ message: "this is an error" }],
+            })
           );
         }
 
diff --git a/src/testing/experimental/__tests__/createTestSchema.test.tsx b/src/testing/experimental/__tests__/createTestSchema.test.tsx
--- a/src/testing/experimental/__tests__/createTestSchema.test.tsx
+++ b/src/testing/experimental/__tests__/createTestSchema.test.tsx
@@ -743,9 +743,12 @@ describe("schema proxy", () => {
       const { snapshot } = await renderStream.takeRender();
 
       expect(snapshot.error).toEqual(
-        new CombinedGraphQLErrors([
-          { message: "Could not resolve type", path: ["viewer", "book"] },
-        ])
+        new CombinedGraphQLErrors({
+          data: null,
+          errors: [
+            { message: "Could not resolve type", path: ["viewer", "book"] },
+          ],
+        })
       );
     }
   });
@@ -818,9 +821,11 @@ describe("schema proxy", () => {
       const { snapshot } = await renderStream.takeRender();
 
       expect(snapshot.error).toEqual(
-        new CombinedGraphQLErrors([
-          { message: 'Expected { foo: "bar" } to be a GraphQL schema.' },
-        ])
+        new CombinedGraphQLErrors({
+          errors: [
+            { message: 'Expected { foo: "bar" } to be a GraphQL schema.' },
+          ],
+        })
       );
     }
   });