fix: handle originally unexpected errors correctly (#3968)

* fix: handle originally unexpected errors correctly

* Fix typings

* Test

* Fix

* F

* Remove unexpected thing

* ..

Author: ardatan

.changeset/deep-doodles-hang.md

@@ -0,0 +1,7 @@
+---
+'graphql-yoga': patch
+---
+
+Handle unexpected errors correctly.
+
+Yoga checks originalError to see if it is a wrapped error of an unexpected error, because execution engine can wrap it multiple times.

packages/graphql-yoga/__tests__/error-masking.spec.ts

@@ -759,4 +759,47 @@ describe('error masking', () => {
       ['Processing GraphQL Parameters done.'],
     ]);
   });
+
+  // Execution engine wraps errors recursively so the only way to make sure it is an unexpected error is to check originalError recursively
+  it('respects wrapped original errors', async () => {
+    const error = new Error('I like turtles');
+    const wrappedError = createGraphQLError('I like tortoises', {
+      originalError: error,
+    });
+    const wrappedOverWrappedError = createGraphQLError('I like animals', {
+      originalError: wrappedError,
+    });
+
+    const yoga = createYoga({
+      schema: createSchema({
+        typeDefs: /* GraphQL */ `
+          type Query {
+            a: String!
+          }
+        `,
+        resolvers: {
+          Query: {
+            a: () => wrappedOverWrappedError,
+          },
+        },
+      }),
+      logging: false,
+      maskedErrors: true,
+    });
+
+    const response = await yoga.fetch('http://yoga/graphql', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ query: '{ a }' }),
+    });
+
+    const body = await response.json();
+    expect(body).toMatchObject({
+      errors: [
+        {
+          message: 'Unexpected error.',
+        },
+      ],
+    });
+  });
 });

packages/graphql-yoga/src/utils/mask-error.ts

@@ -1,52 +1,50 @@
 import { createGraphQLError } from '@graphql-tools/utils';
-import { isGraphQLError } from '../error.js';
+import { isGraphQLError, isOriginalGraphQLError } from '../error.js';
 import { MaskError } from '../types.js';
 
+function serializeError(error: unknown) {
+  if (isGraphQLError(error)) {
+    return error.toJSON();
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      cause: error.cause,
+    };
+  }
+  return error;
+}
+
 export const maskError: MaskError = (
   error: unknown,
   message: string,
   isDev = globalThis.process?.env?.['NODE_ENV'] === 'development',
 ) => {
+  if (isOriginalGraphQLError(error)) {
+    return error;
+  }
+  const errorExtensions: Record<string, unknown> = {
+    code: 'INTERNAL_SERVER_ERROR',
+    unexpected: true,
+  };
+  const errorOptions: Parameters<typeof createGraphQLError>[1] = {
+    extensions: errorExtensions,
+  };
   if (isGraphQLError(error)) {
-    if (error.originalError) {
-      if (error.originalError.name === 'GraphQLError') {
-        return error;
-      }
-      return createGraphQLError(message, {
-        nodes: error.nodes,
-        source: error.source,
-        positions: error.positions,
-        path: error.path,
-        extensions: {
-          code: 'INTERNAL_SERVER_ERROR',
-          ...error.extensions,
-          unexpected: true,
-          ...(isDev
-            ? {
-                originalError: {
-                  message: error.originalError.message,
-                  stack: error.originalError.stack,
-                },
-              }
-            : {}),
-        },
-      });
+    errorOptions.nodes = error.nodes;
+    errorOptions.source = error.source;
+    errorOptions.positions = error.positions;
+    errorOptions.path = error.path;
+    if (isDev && error.originalError) {
+      errorExtensions['originalError'] = serializeError(error.originalError);
     }
-    return error;
+    if (error.extensions?.['http']) {
+      errorExtensions['http'] = error.extensions['http'];
+    }
+  } else if (isDev) {
+    errorExtensions['originalError'] = serializeError(error);
   }
 
-  return createGraphQLError(message, {
-    extensions: {
-      code: 'INTERNAL_SERVER_ERROR',
-      unexpected: true,
-      originalError: isDev
-        ? error instanceof Error
-          ? {
-              message: error.message,
-              stack: error.stack,
-            }
-          : error
-        : undefined,
-    },
-  });
+  return createGraphQLError(message, errorOptions);
 };