use the official proposal

Author: EmrysMyrddin

.changeset/floppy-women-poke.md

@@ -16,9 +16,6 @@ import { normalizedExecutor } from '@graphql-tools/executor'
 import { parse } from 'graphql'
 import schema from './schema'
 
-// You can also use `Symbol.for('graphql.error.schemaCoordinate')` to get the symbol if you don't
-// want to depend on `@graphql-tools/utils`
-
 const result = await normalizedExecutor({
   schema,
   document: parse(gql`...`),
@@ -29,6 +26,7 @@ if (result.errors) {
   for (const error of result.errors) {
     console.log(
       'Error in resolver ',
+      // You can also just use `error.coordinate`, but this function allows you to workaround types
       getSchemaCoordinate(error), ':',
       error.message
     )

packages/utils/src/errors.ts

@@ -1,4 +1,10 @@
-import { locatedError as _locatedError, ASTNode, GraphQLError, Source, versionInfo } from 'graphql';
+import {
+  GraphQLError as _GraphQLError,
+  locatedError as _locatedError,
+  ASTNode,
+  Source,
+  versionInfo,
+} from 'graphql';
 import { Maybe } from './types.js';
 
 interface GraphQLErrorOptions {
@@ -12,6 +18,24 @@ interface GraphQLErrorOptions {
     }
   >;
   extensions?: any;
+  coordinate?: string;
+}
+
+export class GraphQLError extends _GraphQLError {
+  /**
+   * Coordinate in the schema of the field which is the source of this error (`type.field`)
+   * Note: This is an experimental RFC proposal (https://github.com/graphql/graphql-spec/pull/1200)
+   */
+  coordinate?: string;
+
+  constructor(message: string, options?: GraphQLErrorOptions);
+  constructor(...args: ConstructorParameters<typeof _GraphQLError>);
+  constructor(message: string, options?: GraphQLErrorOptions | any, ...args: any[]) {
+    super(message, options, ...args);
+    if (options && 'coordinate' in options) {
+      this.coordinate = options.coordinate;
+    }
+  }
 }
 
 const possibleGraphQLErrorProperties = [
@@ -25,6 +49,7 @@ const possibleGraphQLErrorProperties = [
   'name',
   'stack',
   'extensions',
+  'coordinate',
 ];
 
 function isGraphQLErrorLike(error: any) {
@@ -61,23 +86,20 @@ export function createGraphQLError(message: string, options?: GraphQLErrorOption
 }
 
 type SchemaCoordinateInfo = { fieldName: string; parentType: { name: string } };
-export const ERROR_EXTENSION_SCHEMA_COORDINATE = Symbol.for('graphql.error.schemaCoordinate');
 function addSchemaCoordinateToError(error: GraphQLError, info: SchemaCoordinateInfo): void {
-  // @ts-expect-error extensions can't be Symbol in official GraphQL Error type
-  error.extensions[ERROR_EXTENSION_SCHEMA_COORDINATE] = `${info.parentType.name}.${info.fieldName}`;
+  error.coordinate = `${info.parentType.name}.${info.fieldName}`;
 }
 
 export function getSchemaCoordinate(error: GraphQLError): string | undefined {
-  // @ts-expect-error extensions can't be Symbol in official GraphQL Error type
-  return error.extensions[ERROR_EXTENSION_SCHEMA_COORDINATE];
+  return error.coordinate;
 }
 
 export function locatedError(
   rawError: unknown,
   nodes: ASTNode | ReadonlyArray<ASTNode> | undefined,
   path: Maybe<ReadonlyArray<string | number>>,
   info: SchemaCoordinateInfo | false | null | undefined,
-) {
+): GraphQLError {
   const error = _locatedError(rawError, nodes, path);
 
   if (info) {

packages/utils/tests/createGraphQLError.test.ts

@@ -0,0 +1,64 @@
+import { ASTNode, GraphQLError, Kind, versionInfo } from 'graphql';
+import { createGraphQLError, locatedError, relocatedError } from '../src/errors';
+
+describe('Errors', () => {
+  describe('relocatedError', () => {
+    it('should adjust the path of a GraphqlError', () => {
+      const originalError = createGraphQLError('test', {
+        path: ['test'],
+        coordinate: 'Query.test',
+      });
+      const newError = relocatedError(originalError, ['test', 1, 'id'], {
+        fieldName: 'id',
+        parentType: { name: 'Test' },
+      });
+      const expectedError = createGraphQLError('test', {
+        path: ['test', 1, 'id'],
+        coordinate: versionInfo.major === 16 ? undefined : 'Test.id',
+      });
+      expect(newError).toEqual(expectedError);
+    });
+  });
+
+  describe('locatedError', () => {
+    it('should add path, nodes and coordinate to error', () => {
+      const originalError = createGraphQLError('test');
+      const nodes: ASTNode[] = [{ kind: Kind.DOCUMENT, definitions: [] }];
+      const error = locatedError(originalError, nodes, ['test'], {
+        fieldName: 'test',
+        parentType: { name: 'Query' },
+      });
+      expect(error.nodes).toBe(nodes);
+      expect(error.path).toEqual(['test']);
+      if (versionInfo.major !== 16) {
+        expect(error.coordinate).toEqual('Query.test');
+      }
+    });
+  });
+
+  describe('createGraphQLError', () => {
+    it('should handle non Error originalError', () => {
+      const error = createGraphQLError('message', {
+        originalError: {
+          message: 'originalError',
+          extensions: { code: 'ORIGINAL_ERROR' },
+        } as any,
+      });
+      expect(error.originalError).toBeInstanceOf(GraphQLError);
+      expect(error).toMatchObject({
+        message: 'message',
+        originalError: {
+          message: 'originalError',
+          extensions: { code: 'ORIGINAL_ERROR' },
+        },
+      });
+    });
+
+    it('should handle coordinate', () => {
+      if (versionInfo.major !== 16) {
+        const error = createGraphQLError('message', { coordinate: 'Query.test' });
+        expect(error.coordinate).toBe('Query.test');
+      }
+    });
+  });
+});