Add support for @onerror

Author: martinbonnin

src/execution/__tests__/onerror-test.ts

@@ -0,0 +1,93 @@
+import { describe, it } from 'mocha';
+
+import { expectJSON } from '../../__testUtils__/expectJSON.js';
+
+import type { PromiseOrValue } from '../../jsutils/PromiseOrValue.js';
+
+import { parse } from '../../language/parser.js';
+
+import { buildSchema } from '../../utilities/buildASTSchema.js';
+
+import { execute } from '../execute.js';
+import type { ExecutionResult } from '../types.js';
+
+const syncError = new Error('bar');
+
+const throwingData = {
+  foo() {
+    throw syncError;
+  },
+};
+
+const schema = buildSchema(`
+  type Query {
+    foo : Int!
+  }
+
+  enum _ErrorAction { PROPAGATE, NULL }
+  directive @onError(action: _ErrorAction) on QUERY | MUTATION | SUBSCRIPTION
+`);
+
+function executeQuery(
+  query: string,
+  rootValue: unknown,
+): PromiseOrValue<ExecutionResult> {
+  return execute({ schema, document: parse(query), rootValue });
+}
+
+describe('Execute: handles errors', () => {
+  it('with `@onError(action: NULL) returns null', async () => {
+    const query = `
+      query getFoo @onError(action: NULL) {
+        foo
+      }
+    `;
+    const result = await executeQuery(query, throwingData);
+    expectJSON(result).toDeepEqual({
+      data: { foo: null },
+      errors: [
+        {
+          message: 'bar',
+          path: ['foo'],
+          locations: [{ line: 3, column: 9 }],
+        },
+      ],
+    });
+  });
+  it('with `@onError(action: PROPAGATE) propagates the error', async () => {
+    const query = `
+      query getFoo @onError(action: PROPAGATE) {
+        foo
+      }
+    `;
+    const result = await executeQuery(query, throwingData);
+    expectJSON(result).toDeepEqual({
+      data: null,
+      errors: [
+        {
+          message: 'bar',
+          path: ['foo'],
+          locations: [{ line: 3, column: 9 }],
+        },
+      ],
+    });
+  });
+  it('by default propagates the error', async () => {
+    const query = `
+      query getFoo {
+        foo
+      }
+    `;
+    const result = await executeQuery(query, throwingData);
+    expectJSON(result).toDeepEqual({
+      data: null,
+      errors: [
+        {
+          message: 'bar',
+          path: ['foo'],
+          locations: [{ line: 3, column: 9 }],
+        },
+      ],
+    });
+  });
+});

src/execution/execute.ts

@@ -44,7 +44,11 @@ import {
   isNonNullType,
   isObjectType,
 } from '../type/definition.js';
-import { GraphQLStreamDirective } from '../type/directives.js';
+import {
+  ErrorAction,
+  GraphQLOnErrorDirective,
+  GraphQLStreamDirective,
+} from '../type/directives.js';
 import type { GraphQLSchema } from '../type/schema.js';
 import { assertValidSchema } from '../type/validate.js';
 
@@ -170,6 +174,7 @@ export interface ExecutionContext {
   abortSignalListener: AbortSignalListener | undefined;
   completed: boolean;
   cancellableStreams: Set<CancellableStreamRecord> | undefined;
+  propagateErrors: boolean;
 }
 
 interface IncrementalContext {
@@ -314,6 +319,12 @@ export function executeQueryOrMutationOrSubscriptionEvent(
   return ensureSinglePayload(result);
 }
 
+function propagateErrors(operation: OperationDefinitionNode): boolean {
+  const value = getDirectiveValues(GraphQLOnErrorDirective, operation);
+
+  return value?.action !== ErrorAction.NULL;
+}
+
 export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(
   validatedExecutionArgs: ValidatedExecutionArgs,
 ): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults> {
@@ -326,6 +337,7 @@ export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(
       : undefined,
     completed: false,
     cancellableStreams: undefined,
+    propagateErrors: propagateErrors(validatedExecutionArgs.operation),
   };
   try {
     const {
@@ -976,7 +988,7 @@ function handleFieldError(
 
   // If the field type is non-nullable, then it is resolved without any
   // protection from errors, however it still properly locates the error.
-  if (isNonNullType(returnType)) {
+  if (exeContext.propagateErrors && isNonNullType(returnType)) {
     throw error;
   }
 

src/type/directives.ts

@@ -9,14 +9,19 @@ import { toObjMapWithSymbols } from '../jsutils/toObjMap.js';
 
 import type { DirectiveDefinitionNode } from '../language/ast.js';
 import { DirectiveLocation } from '../language/directiveLocation.js';
+import { Kind } from '../language/kinds.js';
 
 import { assertName } from './assertName.js';
 import type {
   GraphQLArgumentConfig,
   GraphQLFieldNormalizedConfigArgumentMap,
   GraphQLSchemaElement,
 } from './definition.js';
-import { GraphQLArgument, GraphQLNonNull } from './definition.js';
+import {
+  GraphQLArgument,
+  GraphQLEnumType,
+  GraphQLNonNull,
+} from './definition.js';
 import { GraphQLBoolean, GraphQLInt, GraphQLString } from './scalars.js';
 
 /**
@@ -276,6 +281,54 @@ export const GraphQLOneOfDirective: GraphQLDirective = new GraphQLDirective({
   args: {},
 });
 
+/**
+ * Possible error handling actions.
+ */
+export const ErrorAction = {
+  PROPAGATE: 'PROPAGATE' as const,
+  NULL: 'NULL' as const,
+} as const;
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type ErrorAction = (typeof ErrorAction)[keyof typeof ErrorAction];
+
+export const _ErrorAction = new GraphQLEnumType({
+  name: '_ErrorAction',
+  description: 'Possible error handling actions.',
+  values: {
+    PROPAGATE: {
+      value: ErrorAction.PROPAGATE,
+      description:
+        'Non-nullable positions that error cause the error to propagate to the nearest nullable ancestor position. The error is added to the "errors" list.',
+    },
+    NULL: {
+      value: ErrorAction.NULL,
+      description:
+        'Positions that error are replaced with a `null` and an error is added to the "errors list.',
+    },
+  },
+});
+
+/**
+ * Controls how the executor handles errors.
+ */
+export const GraphQLOnErrorDirective = new GraphQLDirective({
+  name: 'onError',
+  description: 'Controls how the executor handles errors.',
+  locations: [
+    DirectiveLocation.QUERY,
+    DirectiveLocation.MUTATION,
+    DirectiveLocation.SUBSCRIPTION,
+  ],
+  args: {
+    action: {
+      type: new GraphQLNonNull(_ErrorAction),
+      description: 'The action to execute when a field error is encountered.',
+      default: { literal: { kind: Kind.ENUM, value: 'PROPAGATE' } },
+    },
+  },
+});
+
 /**
  * The full list of specified directives.
  */