adjust types, add test

Author: phryneas

src/core/QueryInfo.ts

@@ -1,4 +1,4 @@
-import type { DocumentNode } from "graphql";
+import type { DocumentNode, GraphQLFormattedError } from "graphql";
 import { equal } from "@wry/equality";
 
 import type { Cache, ApolloCache } from "../cache/index.js";
@@ -15,10 +15,7 @@ import {
   canUseWeakMap,
 } from "../utilities/index.js";
 import { NetworkStatus, isNetworkRequestInFlight } from "./networkStatus.js";
-import type {
-  ApolloError,
-  GraphQLErrorsFromResponse,
-} from "../errors/index.js";
+import type { ApolloError } from "../errors/index.js";
 import type { QueryManager } from "./QueryManager.js";
 
 export type QueryStoreValue = Pick<
@@ -85,7 +82,7 @@ export class QueryInfo {
   variables?: Record<string, any>;
   networkStatus?: NetworkStatus;
   networkError?: Error | null;
-  graphQLErrors?: GraphQLErrorsFromResponse;
+  graphQLErrors?: ReadonlyArray<GraphQLFormattedError>;
   stopped = false;
 
   private cache: ApolloCache<any>;

src/errors/__tests__/ApolloError.ts

@@ -1,5 +1,5 @@
 import { ApolloError } from "..";
-import { GraphQLError } from "graphql";
+import { ExecutableDefinitionNode, GraphQLError, parse, Source } from "graphql";
 
 describe("ApolloError", () => {
   it("should construct itself correctly", () => {
@@ -107,4 +107,38 @@ describe("ApolloError", () => {
     });
     expect(apolloError.stack).toBeDefined();
   });
+
+  it("will revive `GraphQLError` instances from `graphQLErrors`", () => {
+    const source = new Source(`
+      {
+        field
+      }
+    `);
+    const ast = parse(source);
+    const operationNode = ast.definitions[0] as ExecutableDefinitionNode;
+    const fieldNode = operationNode.selectionSet.selections[0];
+    const original = new GraphQLError("msg" /* message */, {
+      nodes: [fieldNode],
+      source,
+      positions: [1, 2, 3],
+      path: ["a", "b", "c"],
+      originalError: new Error("test"),
+      extensions: { foo: "bar" },
+    });
+
+    const apolloError = new ApolloError({
+      graphQLErrors: [JSON.parse(JSON.stringify(original))],
+    });
+    const graphQLError = apolloError.graphQLErrors[0];
+
+    console.log({
+      graphQLError,
+      original,
+      serialized: JSON.stringify(original),
+    });
+
+    expect(graphQLError).toBeInstanceOf(GraphQLError);
+    // test equality of enumberable fields. non-enumerable fields will differ
+    expect({ ...graphQLError }).toStrictEqual({ ...original });
+  });
 });

src/errors/index.ts

@@ -1,6 +1,6 @@
 import "../utilities/globals/index.js";
 
-import type { GraphQLErrorExtensions } from "graphql";
+import type { GraphQLErrorExtensions, GraphQLFormattedError } from "graphql";
 import { GraphQLError } from "graphql";
 
 import { isNonNullObject } from "../utilities/index.js";
@@ -18,7 +18,7 @@ type FetchResultWithSymbolExtensions<T> = FetchResult<T> & {
 };
 
 export interface ApolloErrorOptions {
-  graphQLErrors?: GraphQLErrorsFromResponse;
+  graphQLErrors?: ReadonlyArray<GraphQLFormattedError>;
   protocolErrors?: ReadonlyArray<{
     message: string;
     extensions?: GraphQLErrorExtensions[];
@@ -68,25 +68,14 @@ const generateErrorMessage = (err: ApolloError) => {
   );
 };
 
-/**
- * A GraphQLError, as received from the server in a GraphQL Response
- *
- * See https://github.com/graphql/graphql-spec/blob/main/spec/Section%207%20--%20Response.md#errors
- * (scroll down to Error Result Format)
- * Only `message` is mandatory in the spec, the other fields are optional.
- */
-export type GraphQLErrorFromResponse = Pick<GraphQLError, "message"> &
-  Partial<GraphQLError>;
-export type GraphQLErrorsFromResponse = ReadonlyArray<GraphQLErrorFromResponse>;
-
 export type GraphQLErrors = ReadonlyArray<GraphQLError>;
 
 export type NetworkError = Error | ServerParseError | ServerError | null;
 
 export class ApolloError extends Error {
   public name: string;
   public message: string;
-  public graphQLErrors: GraphQLErrorsFromResponse;
+  public graphQLErrors: GraphQLError[];
   public protocolErrors: ReadonlyArray<{
     message: string;
     extensions?: GraphQLErrorExtensions[];
@@ -132,7 +121,7 @@ export class ApolloError extends Error {
     this.cause =
       [
         networkError,
-        ...(graphQLErrors || []),
+        ...(this.graphQLErrors || []),
         ...(protocolErrors || []),
         ...(clientErrors || []),
       ].find((e) => !!e) || null;
@@ -149,16 +138,18 @@ export class ApolloError extends Error {
  * spec, but they are not optional in the `GraphQLError` type.
  * This function ensures that all errors are instances of the `GraphQLError` class.
  */
-export function reviveGraphQLError(
-  error: GraphQLErrorFromResponse
-): GraphQLError {
+export function reviveGraphQLError(error: GraphQLFormattedError): GraphQLError {
   return error instanceof GraphQLError ? error : (
-      new GraphQLError(
-        error.message,
-        // This will pass `message` into the `options` parameter.
-        // The constructor does not expect that, but it will ignore it and we
-        // don't need to destructure `error`, saving some bundle size.
-        error
+      Object.assign(
+        new GraphQLError(
+          error.message,
+          // This will pass `message` into the `options` parameter.
+          // The constructor does not expect that, but it will ignore it and we
+          // don't need to destructure `error`, saving some bundle size.
+          error
+        ),
+        //
+        { locations: error.locations }
       )
     );
 }

src/link/core/types.ts

@@ -1,10 +1,9 @@
-import type { GraphQLError } from "graphql";
+import type { GraphQLError, GraphQLFormattedError } from "graphql";
 import type { DocumentNode } from "graphql";
 import type { DefaultContext } from "../../core/index.js";
 export type { DocumentNode };
 
 import type { Observable } from "../../utilities/index.js";
-import type { GraphQLErrorsFromResponse } from "../../errors/index.js";
 
 export type Path = ReadonlyArray<string | number>;
 
@@ -96,7 +95,7 @@ export interface SingleExecutionResult<
   // data might be undefined if errorPolicy was set to 'ignore'
   data?: TData | null;
   context?: TContext;
-  errors?: GraphQLErrorsFromResponse;
+  errors?: ReadonlyArray<GraphQLFormattedError>;
   extensions?: TExtensions;
 }
 

src/link/error/index.ts

@@ -1,15 +1,12 @@
-import type { ExecutionResult } from "graphql";
+import type { ExecutionResult, GraphQLFormattedError } from "graphql";
 
-import type {
-  NetworkError,
-  GraphQLErrorsFromResponse,
-} from "../../errors/index.js";
+import type { NetworkError } from "../../errors/index.js";
 import { Observable } from "../../utilities/index.js";
 import type { Operation, FetchResult, NextLink } from "../core/index.js";
 import { ApolloLink } from "../core/index.js";
 
 export interface ErrorResponse {
-  graphQLErrors?: GraphQLErrorsFromResponse;
+  graphQLErrors?: ReadonlyArray<GraphQLFormattedError>;
   networkError?: NetworkError;
   response?: ExecutionResult;
   operation: Operation;

src/link/persisted-queries/index.ts

@@ -1,7 +1,12 @@
 import { invariant } from "../../utilities/globals/index.js";
 
 import { print } from "../../utilities/index.js";
-import type { DocumentNode, ExecutionResult, GraphQLError } from "graphql";
+import type {
+  DocumentNode,
+  ExecutionResult,
+  GraphQLError,
+  GraphQLFormattedError,
+} from "graphql";
 
 import type { Operation } from "../core/index.js";
 import { ApolloLink } from "../core/index.js";
@@ -10,11 +15,7 @@ import type {
   ObservableSubscription,
 } from "../../utilities/index.js";
 import { Observable, compact, isNonEmptyArray } from "../../utilities/index.js";
-import type {
-  GraphQLErrorFromResponse,
-  GraphQLErrorsFromResponse,
-  NetworkError,
-} from "../../errors/index.js";
+import type { NetworkError } from "../../errors/index.js";
 import type { ServerError } from "../utils/index.js";
 import {
   cacheSizes,
@@ -25,7 +26,7 @@ import {
 export const VERSION = 1;
 
 export interface ErrorResponse {
-  graphQLErrors?: GraphQLErrorsFromResponse;
+  graphQLErrors?: ReadonlyArray<GraphQLFormattedError>;
   networkError?: NetworkError;
   response?: ExecutionResult;
   operation: Operation;
@@ -64,8 +65,8 @@ export namespace PersistedQueryLink {
 
 function processErrors(
   graphQLErrors:
-    | GraphQLErrorFromResponse[]
-    | readonly GraphQLErrorFromResponse[]
+    | GraphQLFormattedError[]
+    | ReadonlyArray<GraphQLFormattedError>
     | undefined
 ): ErrorMeta {
   const byMessage = Object.create(null),
@@ -187,7 +188,7 @@ export const createPersistedQueryLink = (
           if (!retried && ((response && response.errors) || networkError)) {
             retried = true;
 
-            const graphQLErrors: GraphQLErrorFromResponse[] = [];
+            const graphQLErrors: GraphQLFormattedError[] = [];
 
             const responseErrors = response && response.errors;
             if (isNonEmptyArray(responseErrors)) {