[errors] add onResolvedError callback

Author: hayes

.changeset/cool-owls-sink.md

@@ -0,0 +1,5 @@
+---
+"@pothos/plugin-errors": minor
+---
+
+Add an onResolvedError callback to builder options for logging errors handled by the plugin

packages/plugin-errors/README.md

@@ -23,6 +23,7 @@ const builder = new SchemaBuilder({
   plugins: [ErrorsPlugin],
   errors: {
     defaultTypes: [],
+    // onResolvedError: (error) => console.error('Handled error:', error),
   },
 });
 
@@ -98,6 +99,7 @@ errors plugin will automatically resolve to the corresponding error object type.
 - `defaultTypes`: An array of Error classes to include in every field with error handling.
 - `directResult`: Sets the default for `directResult` option on fields (only affects non-list
   fields)
+- `onResolvedError`: A callback function that is called when an error is handled by the plugin
 - `defaultResultOptions`: Sets the defaults for `result` option on fields.
   - `name`: Function to generate a custom name on the generated result types.
     ```ts

packages/plugin-errors/src/index.ts

@@ -191,6 +191,7 @@ export class PothosErrorsPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
     const pothosItemErrors = fieldConfig.extensions?.pothosItemErrors as
       | (typeof Error)[]
       | undefined;
+    const onResolvedError = this.builder.options.errors?.onResolvedError;
 
     if (!pothosErrors && !pothosItemErrors) {
       return resolver;
@@ -205,7 +206,7 @@ export class PothosErrorsPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
         const result = (await resolver(source, args, context, info)) as never;
 
         if (pothosItemErrors && result && typeof result === 'object' && Symbol.iterator in result) {
-          return yieldErrors(result, pothosItemErrors);
+          return yieldErrors(result, pothosItemErrors, onResolvedError);
         }
 
         if (
@@ -214,13 +215,12 @@ export class PothosErrorsPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
           typeof result === 'object' &&
           Symbol.asyncIterator in result
         ) {
-          console.log(result, yieldAsyncErrors);
-          return yieldAsyncErrors(result, pothosItemErrors);
+          return yieldAsyncErrors(result, pothosItemErrors, onResolvedError);
         }
 
         return result;
       } catch (error: unknown) {
-        return wrapOrThrow(error, pothosErrors ?? []);
+        return wrapOrThrow(error, pothosErrors ?? [], onResolvedError);
       }
     };
   }
@@ -230,6 +230,7 @@ export class PothosErrorsPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
     fieldConfig: PothosOutputFieldConfig<Types>,
   ): GraphQLFieldResolver<unknown, Types['Context'], object> | undefined {
     const pothosErrors = fieldConfig.extensions?.pothosErrors as (typeof Error)[] | undefined;
+    const onResolvedError = this.builder.options.errors?.onResolvedError;
 
     if (!pothosErrors) {
       return subscribe;
@@ -248,7 +249,7 @@ export class PothosErrorsPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
             yield value;
           }
         } catch (error: unknown) {
-          yield wrapOrThrow(error, pothosErrors ?? []);
+          yield wrapOrThrow(error, pothosErrors ?? [], onResolvedError);
         }
       }
 
@@ -371,9 +372,14 @@ SchemaBuilder.registerPlugin(pluginName, PothosErrorsPlugin, {
   }),
 });
 
-function wrapOrThrow(error: unknown, pothosErrors: ErrorConstructor[]) {
+function wrapOrThrow(
+  error: unknown,
+  pothosErrors: ErrorConstructor[],
+  onResolvedError?: (error: Error) => void,
+) {
   for (const errorType of pothosErrors) {
     if (error instanceof errorType) {
+      onResolvedError?.(error);
       const result = createErrorProxy(error, errorType, { wrapped: true });
 
       errorTypeMap.set(result, errorType);
@@ -385,30 +391,38 @@ function wrapOrThrow(error: unknown, pothosErrors: ErrorConstructor[]) {
   throw error;
 }
 
-function* yieldErrors(result: Iterable<unknown>, pothosErrors: ErrorConstructor[]) {
+function* yieldErrors(
+  result: Iterable<unknown>,
+  pothosErrors: ErrorConstructor[],
+  onResolvedError?: (error: Error) => void,
+) {
   try {
     for (const item of result) {
       if (item instanceof Error) {
-        yield wrapOrThrow(item, pothosErrors);
+        yield wrapOrThrow(item, pothosErrors, onResolvedError);
       } else {
         yield item;
       }
     }
   } catch (error: unknown) {
-    yield wrapOrThrow(error, pothosErrors);
+    yield wrapOrThrow(error, pothosErrors, onResolvedError);
   }
 }
 
-async function* yieldAsyncErrors(result: AsyncIterable<unknown>, pothosErrors: ErrorConstructor[]) {
+async function* yieldAsyncErrors(
+  result: AsyncIterable<unknown>,
+  pothosErrors: ErrorConstructor[],
+  onResolvedError?: (error: Error) => void,
+) {
   try {
     for await (const item of result) {
       if (item instanceof Error) {
-        yield wrapOrThrow(item, pothosErrors);
+        yield wrapOrThrow(item, pothosErrors, onResolvedError);
       } else {
         yield item;
       }
     }
   } catch (error: unknown) {
-    yield wrapOrThrow(error, pothosErrors);
+    yield wrapOrThrow(error, pothosErrors, onResolvedError);
   }
 }

packages/plugin-errors/src/types.ts

@@ -35,6 +35,11 @@ export interface ErrorsPluginOptions<Types extends SchemaTypes> {
       name?: GetTypeName;
     }
   >;
+  /**
+   * Callback for logging any errors which are handled by the errors plugin, this
+   * function will not be called for errors that are not handled by the errors plugin
+   **/
+  onResolvedError?: (error: Error) => void;
 }
 
 export type ErrorFieldOptions<

packages/plugin-errors/tests/index.test.ts

@@ -1,5 +1,7 @@
+import SchemaBuilder from '@pothos/core';
 import { execute, printSchema, subscribe } from 'graphql';
 import { gql } from 'graphql-tag';
+import ErrorPlugin from '../src';
 import { builder, builderWithCustomErrorTypeNames } from './example/builder';
 import { createSchema } from './example/schema';
 
@@ -438,3 +440,236 @@ describe('errors plugin', () => {
     `);
   });
 });
+
+describe('onResolvedError callback', () => {
+  it('calls onResolvedError when errors are handled', async () => {
+    const resolvedErrors: Error[] = [];
+
+    const testBuilder = new SchemaBuilder<{}>({
+      plugins: [ErrorPlugin],
+      errors: {
+        defaultTypes: [],
+        onResolvedError: (error) => {
+          resolvedErrors.push(error);
+        },
+      },
+    });
+
+    testBuilder.objectType(Error, {
+      name: 'Error',
+      fields: (t) => ({
+        message: t.exposeString('message'),
+      }),
+    });
+
+    testBuilder.queryType({
+      fields: (t) => ({
+        testField: t.field({
+          type: 'String',
+          errors: {
+            types: [Error],
+          },
+          resolve: () => {
+            throw new Error('Test error message');
+          },
+        }),
+      }),
+    });
+
+    const testSchema = testBuilder.toSchema();
+
+    const result = await execute({
+      schema: testSchema,
+      document: gql`
+        query {
+          testField {
+            __typename
+            ... on Error {
+              message
+            }
+          }
+        }
+      `,
+      contextValue: {},
+    });
+
+    expect(resolvedErrors).toHaveLength(1);
+    expect(resolvedErrors[0]).toBeInstanceOf(Error);
+    expect(resolvedErrors[0].message).toBe('Test error message');
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "data": {
+          "testField": {
+            "__typename": "Error",
+            "message": "Test error message",
+          },
+        },
+      }
+    `);
+  });
+
+  it('does not call onResolvedError for unhandled errors', async () => {
+    const resolvedErrors: Error[] = [];
+
+    class HandledError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = 'HandledError';
+      }
+    }
+
+    class UnhandledError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = 'UnhandledError';
+      }
+    }
+
+    const testBuilder = new SchemaBuilder<{}>({
+      plugins: [ErrorPlugin],
+      errors: {
+        defaultTypes: [],
+        onResolvedError: (error) => {
+          resolvedErrors.push(error);
+        },
+      },
+    });
+
+    testBuilder.objectType(HandledError, {
+      name: 'HandledError',
+      fields: (t) => ({
+        message: t.exposeString('message'),
+      }),
+    });
+
+    testBuilder.queryType({
+      fields: (t) => ({
+        testField: t.field({
+          type: 'String',
+          errors: {
+            types: [HandledError],
+          },
+          resolve: () => {
+            throw new UnhandledError('This error is not handled by the plugin');
+          },
+        }),
+      }),
+    });
+
+    const testSchema = testBuilder.toSchema();
+
+    const result = await execute({
+      schema: testSchema,
+      document: gql`
+        query {
+          testField {
+            __typename
+          }
+        }
+      `,
+      contextValue: {},
+    });
+
+    expect(resolvedErrors).toHaveLength(0);
+    expect(result.errors).toBeDefined();
+    expect(result.errors?.[0].message).toContain('This error is not handled by the plugin');
+  });
+
+  it('calls onResolvedError for handled errors but not unhandled ones', async () => {
+    const resolvedErrors: Error[] = [];
+
+    class HandledError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = 'HandledError';
+      }
+    }
+
+    class UnhandledError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = 'UnhandledError';
+      }
+    }
+
+    const testBuilder = new SchemaBuilder<{}>({
+      plugins: [ErrorPlugin],
+      errors: {
+        defaultTypes: [],
+        onResolvedError: (error) => {
+          resolvedErrors.push(error);
+        },
+      },
+    });
+
+    testBuilder.objectType(HandledError, {
+      name: 'HandledError',
+      fields: (t) => ({
+        message: t.exposeString('message'),
+      }),
+    });
+
+    testBuilder.queryType({
+      fields: (t) => ({
+        handledField: t.field({
+          type: 'String',
+          errors: {
+            types: [HandledError],
+          },
+          resolve: () => {
+            throw new HandledError('This error is handled');
+          },
+        }),
+        unhandledField: t.field({
+          type: 'String',
+          errors: {
+            types: [HandledError], // Only catching HandledError
+          },
+          resolve: () => {
+            throw new UnhandledError('This error is not handled');
+          },
+        }),
+      }),
+    });
+
+    const testSchema = testBuilder.toSchema();
+
+    // Test handled error
+    const handledResult = await execute({
+      schema: testSchema,
+      document: gql`
+        query {
+          handledField {
+            __typename
+            ... on HandledError {
+              message
+            }
+          }
+        }
+      `,
+      contextValue: {},
+    });
+
+    expect(resolvedErrors).toHaveLength(1);
+    expect(resolvedErrors[0]).toBeInstanceOf(HandledError);
+    expect(resolvedErrors[0].message).toBe('This error is handled');
+    expect(handledResult.errors).toBeUndefined();
+
+    const unhandledResult = await execute({
+      schema: testSchema,
+      document: gql`
+        query {
+          unhandledField {
+            __typename
+          }
+        }
+      `,
+      contextValue: {},
+    });
+
+    expect(resolvedErrors).toHaveLength(1);
+    expect(unhandledResult.errors).toBeDefined();
+    expect(unhandledResult.errors?.[0].message).toContain('This error is not handled');
+  });
+});