fix(batch-delegate): correct error paths in case of batch delegation

Author: ardatan

.changeset/breezy-weeks-camp.md

@@ -0,0 +1,6 @@
+---
+'@graphql-tools/batch-delegate': patch
+'@graphql-tools/delegate': patch
+---
+
+Correct error paths in case of batch delegation with the same error

packages/batch-delegate/src/batchDelegateToSchema.ts

@@ -1,5 +1,8 @@
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
+import { GraphQLError } from 'graphql';
 import { getLoader } from './getLoader.js';
 import { BatchDelegateOptions } from './types.js';
+import { pathToArray, relocatedError } from '@graphql-tools/utils';
 
 export function batchDelegateToSchema<TContext = any, K = any, V = any, C = K>(
   options: BatchDelegateOptions<TContext, K, V, C>,
@@ -11,5 +14,14 @@ export function batchDelegateToSchema<TContext = any, K = any, V = any, C = K>(
     return [];
   }
   const loader = getLoader(options);
-  return Array.isArray(key) ? loader.loadMany(key) : loader.load(key);
+  return handleMaybePromise(
+    () => (Array.isArray(key) ? loader.loadMany(key) : loader.load(key)),
+    res => res,
+    error => {
+      if (options.info?.path && error instanceof GraphQLError) {
+        return relocatedError(error, pathToArray(options.info.path));
+      }
+      return error;
+    }
+  );
 }

packages/batch-delegate/tests/errorPaths.test.ts

@@ -0,0 +1,162 @@
+import { GraphQLError, parse } from 'graphql';
+import { batchDelegateToSchema } from '@graphql-tools/batch-delegate';
+import { delegateToSchema } from '@graphql-tools/delegate';
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { stitchSchemas } from '@graphql-tools/stitch';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { normalizedExecutor } from '@graphql-tools/executor';
+
+class NotFoundError extends GraphQLError {
+    constructor(id: unknown) {
+        super('Not Found', {
+            extensions: { id },
+        })
+    }
+}
+
+describe('preserves error path indices', () => {
+    const getProperty = vi.fn((id: unknown) => {
+        return new NotFoundError(id);
+    });
+
+    beforeEach(() => {
+        getProperty.mockClear();
+    });
+
+    const subschema = makeExecutableSchema({
+        typeDefs: /* GraphQL */ `
+      type Property {
+        id: ID!
+      }
+
+      type Object {
+        id: ID!
+        propertyId: ID!
+      }
+
+      type Query {
+        objects: [Object!]!
+        propertyById(id: ID!): Property
+        propertiesByIds(ids: [ID!]!): [Property]!
+      }
+    `,
+        resolvers: {
+            Query: {
+                objects: () => {
+                    return [
+                        { id: '1', propertyId: '1' },
+                        { id: '2', propertyId: '1' },
+                    ];
+                },
+                propertyById: (_, args) => getProperty(args.id),
+                propertiesByIds: (_, args) => args.ids.map(getProperty),
+            },
+        },
+    });
+
+    const subschemas = [subschema];
+    const typeDefs = /* GraphQL */ `
+    extend type Object {
+      property: Property
+    }
+  `;
+
+    const query = /* GraphQL */ `
+    query {
+      objects {
+        id
+        property {
+          id
+        }
+      }
+    }
+  `;
+
+    const expected = {
+        errors: [
+            {
+                message: 'Not Found',
+                extensions: { id: '1' },
+                path: ['objects', 0, 'property'],
+            },
+            {
+                message: 'Not Found',
+                extensions: { id: '1' },
+                path: ['objects', 1, 'property'],
+            },
+        ],
+        data: {
+            objects: [
+                {
+                    id: '1',
+                    property: null as null,
+                },
+                {
+                    id: '2',
+                    property: null as null,
+                },
+            ],
+        },
+    };
+
+    test('using delegateToSchema', async () => {
+        const schema = stitchSchemas({
+            subschemas,
+            typeDefs,
+            resolvers: {
+                Object: {
+                    property: {
+                        selectionSet: '{ propertyId }',
+                        resolve: (source, _, context, info) => {
+                            return delegateToSchema({
+                                schema: subschema,
+                                fieldName: 'propertyById',
+                                args: { id: source.propertyId },
+                                context,
+                                info,
+                            });
+                        },
+                    },
+                },
+            },
+        });
+
+
+        const result = await normalizedExecutor({
+            schema,
+            document: parse(query),
+        })
+
+        expect(getProperty).toBeCalledTimes(2);
+        expect(result).toMatchObject(expected);
+    });
+
+    test('using batchDelegateToSchema', async () => {
+        const schema = stitchSchemas({
+            subschemas,
+            typeDefs,
+            resolvers: {
+                Object: {
+                    property: {
+                        selectionSet: '{ propertyId }',
+                        resolve: (source, _, context, info) => batchDelegateToSchema({
+                            schema: subschema,
+                            fieldName: 'propertiesByIds',
+                            key: source.propertyId,
+                            context,
+                            info,
+                        }),
+                    },
+                },
+            },
+        });
+
+        const result = await normalizedExecutor({
+            schema,
+            document: parse(query),
+        })
+
+        expect(getProperty).toBeCalledTimes(1);
+        expect(result).toMatchObject(expected);
+    });
+});

packages/delegate/src/resolveExternalValue.ts

@@ -182,15 +182,15 @@ function resolveExternalList<TContext extends Record<string, any>>(
   );
 }
 
-const reportedErrors = new WeakMap<GraphQLError, boolean>();
+const reportedErrors = new WeakSet<GraphQLError>();
 
 function reportUnpathedErrorsViaNull(unpathedErrors: Array<GraphQLError>) {
   if (unpathedErrors.length) {
     const unreportedErrors: Array<GraphQLError> = [];
     for (const error of unpathedErrors) {
       if (!reportedErrors.has(error)) {
         unreportedErrors.push(error);
-        reportedErrors.set(error, true);
+        reportedErrors.add(error);
       }
     }