@graphql-tools/utils 10.7.2 → 12.0.1

package/esm/helpers.js

@@ -1,5 +1,25 @@
 import { parse } from 'graphql';
-function isURL(str) {
+const URL_REGEXP = /^(https?|wss?|file):\/\//;
+/**
+ * Checks if the given string is a valid URL.
+ *
+ * @param str - The string to validate as a URL
+ * @returns A boolean indicating whether the string is a valid URL
+ *
+ * @remarks
+ * This function first attempts to use the `URL.canParse` method if available.
+ * If not, it falls back to creating a new `URL` object to validate the string.
+ */
+export function isUrl(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    if (!URL_REGEXP.test(str)) {
+        return false;
+    }
+    if (URL.canParse) {
+        return URL.canParse(str);
+    }
     try {
         const url = new URL(str);
         return !!url;
@@ -10,6 +30,21 @@ function isURL(str) {
 }
 export const asArray = (fns) => (Array.isArray(fns) ? fns : fns ? [fns] : []);
 const invalidDocRegex = /\.[a-z0-9]+$/i;
+/**
+ * Determines if a given input is a valid GraphQL document string.
+ *
+ * @param str - The input to validate as a GraphQL document
+ * @returns A boolean indicating whether the input is a valid GraphQL document string
+ *
+ * @remarks
+ * This function performs several validation checks:
+ * - Ensures the input is a string
+ * - Filters out strings with invalid document extensions
+ * - Excludes URLs
+ * - Attempts to parse the string as a GraphQL document
+ *
+ * @throws {Error} If the document fails to parse and is empty except GraphQL comments
+ */
 export function isDocumentString(str) {
     if (typeof str !== 'string') {
         return false;
@@ -19,7 +54,7 @@ export function isDocumentString(str) {
     // this why checking the extension is fast enough
     // and prevent from parsing the string in order to find out
     // if the string is a SDL
-    if (invalidDocRegex.test(str) || isURL(str)) {
+    if (invalidDocRegex.test(str) || isUrl(str)) {
         return false;
     }
     try {
@@ -35,9 +70,9 @@ export function isDocumentString(str) {
     }
     return false;
 }
-const invalidPathRegex = /[‘“!%^<>`\n]/;
+const invalidPathRegex = /[‘“!^<>`\n]/;
 /**
- * Checkes whether the `str` contains any path illegal characters.
+ * Checks whether the `str` contains any path illegal characters.
  *
  * A string may sometimes look like a path but is not (like an SDL of a simple
  * GraphQL schema). To make sure we don't yield false-positives in such cases,

package/esm/index.js

@@ -28,8 +28,8 @@ export * from './getResponseKeyFromInfo.js';
 export * from './fields.js';
 export * from './renameType.js';
 export * from './transformInputValue.js';
-export * from './mapAsyncIterator.js';
 export * from './updateArgument.js';
+export * from './astFromType.js';
 export * from './implementsAbstractType.js';
 export * from './errors.js';
 export * from './observableToAsyncIterable.js';
@@ -55,7 +55,6 @@ export * from './directives.js';
 export * from './mergeIncrementalResult.js';
 export * from './debugTimer.js';
 export * from './getDirectiveExtensions.js';
-export * from './map-maybe-promise.js';
-export * from './fakePromise.js';
-export * from './createDeferred.js';
+export { mapAsyncIterator, mapMaybePromise, fakePromise, createDeferredPromise as createDeferred, } from '@whatwg-node/promise-helpers';
 export * from './registerAbortSignalListener.js';
+export * from './getDirectiveValues.js';

package/esm/jsutils.js

@@ -1,17 +1,15 @@
-import { mapMaybePromise } from './map-maybe-promise.js';
+import { handleMaybePromise, isPromise } from '@whatwg-node/promise-helpers';
 export function isIterableObject(value) {
     return value != null && typeof value === 'object' && Symbol.iterator in value;
 }
 export function isObjectLike(value) {
     return typeof value === 'object' && value !== null;
 }
-export function isPromise(value) {
-    return value?.then != null;
-}
+export { isPromise };
 export function promiseReduce(values, callbackFn, initialValue) {
     let accumulator = initialValue;
     for (const value of values) {
-        accumulator = mapMaybePromise(accumulator, resolved => callbackFn(resolved, value));
+        accumulator = handleMaybePromise(() => accumulator, resolved => callbackFn(resolved, value));
     }
     return accumulator;
 }

package/esm/mapSchema.js

@@ -17,10 +17,11 @@ export function mapSchema(schema, schemaMapper = {}) {
         directives,
     });
 }
+const builtinTypes = ['String', 'ID', 'Int', 'Float', 'Boolean'];
 function mapTypes(originalTypeMap, schema, schemaMapper, testFn = () => true) {
     const newTypeMap = {};
     for (const typeName in originalTypeMap) {
-        if (!typeName.startsWith('__')) {
+        if (!typeName.startsWith('__') && !builtinTypes.includes(typeName)) {
             const originalType = originalTypeMap[typeName];
             if (originalType == null || !testFn(originalType)) {
                 newTypeMap[typeName] = originalType;

package/esm/mergeDeep.js

@@ -1,5 +1,11 @@
 import { isSome } from './helpers.js';
-export function mergeDeep(sources, respectPrototype = false, respectArrays = false, respectArrayLength = false) {
+export function mergeDeep(sources, respectPrototype = false, respectArrays = false, respectArrayLength = false, respectNonEnumerableSymbols = false) {
+    if (sources.length === 0) {
+        return;
+    }
+    if (sources.length === 1) {
+        return sources[0];
+    }
     let expectedLength;
     let allArrays = true;
     const areArraysInTheSameLength = sources.every(source => {
@@ -18,7 +24,7 @@ export function mergeDeep(sources, respectPrototype = false, respectArrays = fal
         return false;
     });
     if (respectArrayLength && areArraysInTheSameLength) {
-        return new Array(expectedLength).fill(null).map((_, index) => mergeDeep(sources.map(source => source[index]), respectPrototype, respectArrays, respectArrayLength));
+        return new Array(expectedLength).fill(null).map((_, index) => mergeDeep(sources.map(source => source[index]), respectPrototype, respectArrays, respectArrayLength, respectNonEnumerableSymbols));
     }
     if (allArrays) {
         return sources.flat(1);
@@ -27,15 +33,21 @@ export function mergeDeep(sources, respectPrototype = false, respectArrays = fal
     let firstObjectSource;
     if (respectPrototype) {
         firstObjectSource = sources.find(source => isObject(source));
-        if (output == null) {
-            output = {};
-        }
         if (firstObjectSource) {
+            if (output == null) {
+                output = {};
+            }
             Object.setPrototypeOf(output, Object.create(Object.getPrototypeOf(firstObjectSource)));
         }
     }
     for (const source of sources) {
+        if (source === undefined) {
+            continue;
+        }
         if (isObject(source)) {
+            if (output == null) {
+                output = {};
+            }
             if (firstObjectSource) {
                 const outputPrototype = Object.getPrototypeOf(output);
                 const sourcePrototype = Object.getPrototypeOf(source);
@@ -49,16 +61,30 @@ export function mergeDeep(sources, respectPrototype = false, respectArrays = fal
                 }
             }
             for (const key in source) {
-                if (output == null) {
-                    output = {};
+                // never let a source key reach the prototype chain
+                if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                    continue;
                 }
-                if (key in output) {
-                    output[key] = mergeDeep([output[key], source[key]], respectPrototype, respectArrays, respectArrayLength);
+                // An own key present with value `undefined` is an explicit override and must win,
+                // distinct from the key being altogether absent from `source`. Assigning directly
+                // (rather than recursing through mergeDeep) avoids the top-level `source === undefined`
+                // skip above, which would otherwise silently discard this override and keep the prior
+                // value.
+                if (Object.prototype.hasOwnProperty.call(output, key) && source[key] !== undefined) {
+                    output[key] = mergeDeep([output[key], source[key]], respectPrototype, respectArrays, respectArrayLength, respectNonEnumerableSymbols);
                 }
                 else {
                     output[key] = source[key];
                 }
             }
+            if (respectNonEnumerableSymbols && output != null) {
+                for (const sym of Object.getOwnPropertySymbols(source)) {
+                    const descriptor = Object.getOwnPropertyDescriptor(source, sym);
+                    if (!descriptor.enumerable) {
+                        Object.defineProperty(output, sym, descriptor);
+                    }
+                }
+            }
         }
         else if (Array.isArray(source)) {
             if (!Array.isArray(output)) {

package/esm/mergeIncrementalResult.js

@@ -1,22 +1,22 @@
-import { dset } from 'dset/merge';
+import { mergeDeep } from './mergeDeep.js';
 export function mergeIncrementalResult({ incrementalResult, executionResult, }) {
     const path = ['data', ...(incrementalResult.path ?? [])];
     if (incrementalResult.items) {
         for (const item of incrementalResult.items) {
-            dset(executionResult, path, item);
+            setObjectKeyPath(executionResult, path, item);
             // Increment the last path segment (the array index) to merge the next item at the next index
             path[path.length - 1]++;
         }
     }
     if (incrementalResult.data) {
-        dset(executionResult, path, incrementalResult.data);
+        setObjectKeyPath(executionResult, path, incrementalResult.data);
     }
     if (incrementalResult.errors) {
         executionResult.errors = executionResult.errors || [];
         executionResult.errors.push(...incrementalResult.errors);
     }
     if (incrementalResult.extensions) {
-        dset(executionResult, 'extensions', incrementalResult.extensions);
+        setObjectKeyPath(executionResult, ['extensions'], incrementalResult.extensions);
     }
     if (incrementalResult.incremental) {
         incrementalResult.incremental.forEach(incrementalSubResult => {
@@ -27,3 +27,24 @@ export function mergeIncrementalResult({ incrementalResult, executionResult, })
         });
     }
 }
+function setObjectKeyPath(obj, keyPath, value) {
+    let current = obj;
+    let i;
+    for (i = 0; i < keyPath.length - 1; i++) {
+        const key = keyPath[i];
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return;
+        }
+        if (current[key] == null) {
+            // Determine if the next key is a number to create an array, otherwise create an object
+            current[key] = typeof keyPath[i + 1] === 'number' ? [] : {};
+        }
+        current = current[key];
+    }
+    const finalKey = keyPath[i];
+    if (finalKey === '__proto__' || finalKey === 'constructor' || finalKey === 'prototype') {
+        return;
+    }
+    const existingValue = current[finalKey];
+    current[finalKey] = existingValue != null ? mergeDeep([existingValue, value]) : value;
+}

package/esm/observableToAsyncIterable.js

@@ -1,8 +1,20 @@
-import { fakePromise } from './fakePromise.js';
+import { fakePromise, fakeRejectPromise } from '@whatwg-node/promise-helpers';
 export function observableToAsyncIterable(observable) {
     const pullQueue = [];
     const pushQueue = [];
     let listening = true;
+    const subscriptionRef = {};
+    const emptyQueue = () => {
+        if (listening) {
+            listening = false;
+            subscriptionRef.current?.unsubscribe();
+            for (const resolve of pullQueue) {
+                resolve({ value: undefined, done: true });
+            }
+            pullQueue.length = 0;
+            pushQueue.length = 0;
+        }
+    };
     const pushValue = (value) => {
         if (pullQueue.length !== 0) {
             // It is safe to use the ! operator here as we check the length.
@@ -24,23 +36,29 @@ export function observableToAsyncIterable(observable) {
     const pushDone = () => {
         if (pullQueue.length !== 0) {
             // It is safe to use the ! operator here as we check the length.
-            pullQueue.shift()({ done: true });
+            pullQueue.shift()({ value: undefined, done: true });
+            // Release queues/subscription after signaling done to the pending consumer.
+            emptyQueue();
         }
         else {
-            pushQueue.push({ done: true });
+            pushQueue.push({ value: undefined, done: true });
         }
     };
     const pullValue = () => new Promise(resolve => {
         if (pushQueue.length !== 0) {
             const element = pushQueue.shift();
             // either {value: {errors: [...]}} or {value: ...}
+            if (element.done) {
+                // Release references before delivering the done signal.
+                emptyQueue();
+            }
             resolve(element);
         }
         else {
             pullQueue.push(resolve);
         }
     });
-    const subscription = observable.subscribe({
+    subscriptionRef.current = observable.subscribe({
         next(value) {
             return pushValue(value);
         },
@@ -51,17 +69,11 @@ export function observableToAsyncIterable(observable) {
             return pushDone();
         },
     });
-    const emptyQueue = () => {
-        if (listening) {
-            listening = false;
-            subscription.unsubscribe();
-            for (const resolve of pullQueue) {
-                resolve({ value: undefined, done: true });
-            }
-            pullQueue.length = 0;
-            pushQueue.length = 0;
-        }
-    };
+    // complete() may run synchronously inside subscribe() before it returns;
+    // unsubscribe the returned subscription in that case.
+    if (!listening) {
+        subscriptionRef.current.unsubscribe();
+    }
     return {
         next() {
             // return is a defined method, so it is safe to call it.
@@ -73,7 +85,7 @@ export function observableToAsyncIterable(observable) {
         },
         throw(error) {
             emptyQueue();
-            return Promise.reject(error);
+            return fakeRejectPromise(error);
         },
         [Symbol.asyncIterator]() {
             return this;

package/esm/print-schema-with-directives.js

@@ -1,7 +1,8 @@
-import { GraphQLDeprecatedDirective, isEnumType, isInputObjectType, isInterfaceType, isIntrospectionType, isObjectType, isScalarType, isSpecifiedDirective, isSpecifiedScalarType, isUnionType, Kind, print, } from 'graphql';
+import { GraphQLDeprecatedDirective, isEnumType, isInputObjectType, isInterfaceType, isIntrospectionType, isObjectType, isScalarType, isSpecifiedDirective, isSpecifiedScalarType, isUnionType, Kind, print, specifiedDirectives, } from 'graphql';
 import { astFromType } from './astFromType.js';
 import { astFromValue } from './astFromValue.js';
 import { astFromValueUntyped } from './astFromValueUntyped.js';
+import { defaultValueAstFromType } from './defaultValueAstFromType.js';
 import { getDescriptionNode } from './descriptionFromObject.js';
 import { getDirectivesInExtensions, } from './get-directives.js';
 import { isSome } from './helpers.js';
@@ -96,6 +97,10 @@ export function astFromSchema(schema, pathToDirectivesInExtensions) {
                 });
             }
         }
+        else {
+            // Drop operation types that no longer exist on the schema (e.g. after pruneSchema).
+            operationTypeMap.set(operationTypeNode, undefined);
+        }
     }
     const operationTypes = [...operationTypeMap.values()].filter(isSome);
     const directives = getDirectiveNodes(schema, schema, pathToDirectivesInExtensions);
@@ -103,7 +108,7 @@ export function astFromSchema(schema, pathToDirectivesInExtensions) {
         return null;
     }
     const schemaNode = {
-        kind: operationTypes != null ? Kind.SCHEMA_DEFINITION : Kind.SCHEMA_EXTENSION,
+        kind: operationTypes.length ? Kind.SCHEMA_DEFINITION : Kind.SCHEMA_EXTENSION,
         operationTypes,
         // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
         directives: directives,
@@ -131,7 +136,7 @@ export function astFromDirective(directive, schema, pathToDirectivesInExtensions
     };
 }
 export function getDirectiveNodes(entity, schema, pathToDirectivesInExtensions) {
-    let directiveNodesBesidesDeprecatedAndSpecifiedBy = [];
+    let directiveNodesBesidesNativeDirectives = [];
     const directivesInExtensions = getDirectivesInExtensions(entity, pathToDirectivesInExtensions);
     let directives;
     if (directivesInExtensions != null) {
@@ -139,14 +144,12 @@ export function getDirectiveNodes(entity, schema, pathToDirectivesInExtensions)
     }
     let deprecatedDirectiveNode = null;
     let specifiedByDirectiveNode = null;
+    let oneOfDirectiveNode = null;
     if (directives != null) {
-        directiveNodesBesidesDeprecatedAndSpecifiedBy = directives.filter(directive => directive.name.value !== 'deprecated' && directive.name.value !== 'specifiedBy');
-        if (entity.deprecationReason != null) {
-            deprecatedDirectiveNode = directives.filter(directive => directive.name.value === 'deprecated')?.[0];
-        }
-        if (entity.specifiedByUrl != null || entity.specifiedByURL != null) {
-            specifiedByDirectiveNode = directives.filter(directive => directive.name.value === 'specifiedBy')?.[0];
-        }
+        directiveNodesBesidesNativeDirectives = directives.filter(directive => specifiedDirectives.every(specifiedDirective => specifiedDirective.name !== directive.name.value));
+        deprecatedDirectiveNode = directives.find(directive => directive.name.value === 'deprecated');
+        specifiedByDirectiveNode = directives.find(directive => directive.name.value === 'specifiedBy');
+        oneOfDirectiveNode = directives.find(directive => directive.name.value === 'oneOf');
     }
     if (entity.deprecationReason != null && deprecatedDirectiveNode == null) {
         deprecatedDirectiveNode = makeDeprecatedDirective(entity.deprecationReason);
@@ -159,13 +162,19 @@ export function getDirectiveNodes(entity, schema, pathToDirectivesInExtensions)
         };
         specifiedByDirectiveNode = makeDirectiveNode('specifiedBy', specifiedByArgs);
     }
+    if (entity.isOneOf && oneOfDirectiveNode == null) {
+        oneOfDirectiveNode = makeDirectiveNode('oneOf');
+    }
     if (deprecatedDirectiveNode != null) {
-        directiveNodesBesidesDeprecatedAndSpecifiedBy.push(deprecatedDirectiveNode);
+        directiveNodesBesidesNativeDirectives.push(deprecatedDirectiveNode);
     }
     if (specifiedByDirectiveNode != null) {
-        directiveNodesBesidesDeprecatedAndSpecifiedBy.push(specifiedByDirectiveNode);
+        directiveNodesBesidesNativeDirectives.push(specifiedByDirectiveNode);
+    }
+    if (oneOfDirectiveNode != null) {
+        directiveNodesBesidesNativeDirectives.push(oneOfDirectiveNode);
     }
-    return directiveNodesBesidesDeprecatedAndSpecifiedBy;
+    return directiveNodesBesidesNativeDirectives;
 }
 export function astFromArg(arg, schema, pathToDirectivesInExtensions) {
     return {
@@ -176,10 +185,7 @@ export function astFromArg(arg, schema, pathToDirectivesInExtensions) {
             value: arg.name,
         },
         type: astFromType(arg.type),
-        // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
-        defaultValue: arg.defaultValue !== undefined
-            ? (astFromValue(arg.defaultValue, arg.type) ?? undefined)
-            : undefined,
+        defaultValue: defaultValueAstFromType(arg),
         directives: getDirectiveNodes(arg, schema, pathToDirectivesInExtensions),
     };
 }
@@ -299,7 +305,7 @@ export function astFromInputField(field, schema, pathToDirectivesInExtensions) {
         type: astFromType(field.type),
         // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
         directives: getDirectiveNodes(field, schema, pathToDirectivesInExtensions),
-        defaultValue: astFromValue(field.defaultValue, field.type) ?? undefined,
+        defaultValue: defaultValueAstFromType(field),
     };
 }
 export function astFromEnumValue(value, schema, pathToDirectivesInExtensions) {

package/esm/registerAbortSignalListener.js

@@ -1,3 +1,4 @@
+import { fakeRejectPromise } from '@whatwg-node/promise-helpers';
 import { memoize1 } from './memoize.js';
 // AbortSignal handler cache to avoid the "possible EventEmitter memory leak detected"
 // on Node.js
@@ -25,8 +26,11 @@ export function registerAbortSignalListener(signal, listener) {
     getListenersOfAbortSignal(signal).add(listener);
 }
 export const getAbortPromise = memoize1(function getAbortPromise(signal) {
+    // If the signal is already aborted, return a rejected promise
+    if (signal.aborted) {
+        return fakeRejectPromise(signal.reason);
+    }
     return new Promise((_resolve, reject) => {
-        // If the signal is already aborted, return a rejected promise
         if (signal.aborted) {
             reject(signal.reason);
             return;

package/esm/stub.js

@@ -24,6 +24,7 @@ export function createStub(node, type) {
         case Kind.LIST_TYPE:
             return new GraphQLList(createStub(node.type, type));
         case Kind.NON_NULL_TYPE:
+            // FIXME: graphql@17 type issue
             return new GraphQLNonNull(createStub(node.type, type));
         default:
             if (type === 'output') {

package/esm/updateArgument.js

@@ -42,7 +42,8 @@ export function createVariableNameGenerator(variableDefinitionMap) {
     return (argName) => {
         let varName;
         do {
-            varName = `_v${(varCounter++).toString()}_${argName}`;
+            varName = varCounter === 0 ? argName : `_v${varCounter.toString()}_${argName}`;
+            varCounter++;
         } while (varName in variableDefinitionMap);
         return varName;
     };

package/esm/visitResult.js

@@ -29,7 +29,7 @@ export function visitResult(result, request, schema, resultVisitorMap, errorVisi
         }
         return acc;
     }, {});
-    const variableValues = request.variables || {};
+    const variableValues = normalizeVariableValues(request.variables);
     const errorInfo = {
         segmentInfoMap: new Map(),
         unpathedErrors: new Set(),
@@ -46,6 +46,12 @@ export function visitResult(result, request, schema, resultVisitorMap, errorVisi
     }
     return result;
 }
+function normalizeVariableValues(variables) {
+    return {
+        coerced: variables ?? {},
+        sources: {},
+    };
+}
 function visitErrorsByType(errors, errorVisitorMap, errorInfo) {
     const segmentInfoMap = errorInfo.segmentInfoMap;
     const unpathedErrors = errorInfo.unpathedErrors;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/utils",
-  "version": "10.7.2",
+  "version": "12.0.1",
   "description": "Common package containing utils and types for GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
@@ -8,13 +8,13 @@
   },
   "dependencies": {
     "@graphql-typed-document-node/core": "^3.1.1",
+    "@whatwg-node/promise-helpers": "^1.0.0",
     "cross-inspect": "1.0.1",
-    "dset": "^3.1.4",
     "tslib": "^2.4.0"
   },
   "repository": {
     "type": "git",
-    "url": "ardatan/graphql-tools",
+    "url": "git+https://github.com/ardatan/graphql-tools.git",
     "directory": "packages/utils"
   },
   "author": "Dotan Simha <dotansimha@gmail.com>",

package/typings/Interfaces.d.cts

@@ -20,6 +20,37 @@ export interface ExecutionResult<TData = any, TExtensions = any> {
 }
 export interface GraphQLResolveInfo extends OrigGraphQLResolveInfo {
     signal?: AbortSignal;
+    /** Returns the AbortSignal supplied for this execution, if any. */
+    readonly getAbortSignal: () => AbortSignal | undefined;
+    /** Returns helper functions for tracking asynchronous resolver work. */
+    readonly getAsyncHelpers: () => GraphQLResolveInfoHelpers;
+}
+export interface GraphQLResolveInfoHelpers {
+    /**
+     * Promise.all wrapper that allows rejected branches to be tracked
+     * as execution async work.
+     *
+     * Intended use: return or await this promise from resolver work.
+     * Un-awaited async side effects are an anti-pattern:
+     *
+     *   const { promiseAll } = info.getAsyncHelpers();
+     *   promiseAll([someAsyncWork(), someOtherAsyncWork()]).catch(() => undefined);
+     *
+     * In that anti-pattern, tracking starts only after rejection (on a
+     * later microtask), so this work is not guaranteed to delay
+     * `hooks.asyncWorkFinished`.
+     *
+     * Use `track(...)` for un-awaited async side effects:
+     *
+     *   const { track } = info.getAsyncHelpers();
+     *   track([
+     *     someAsyncWork().catch(() => undefined),
+     *     someOtherAsyncWork().catch(() => undefined)
+     *   ]);
+     */
+    readonly promiseAll: <T>(values: ReadonlyArray<PromiseLike<T> | T>) => Promise<Array<T>>;
+    /** Tracks asynchronous work that should delay execution completion hooks. */
+    readonly track: (maybePromises: ReadonlyArray<unknown>) => void;
 }
 export interface ExecutionRequest<TVariables extends Record<string, any> = any, TContext = any, TRootValue = any, TExtensions = Record<string, any>, TReturn = any> {
     document: TypedDocumentNode<TReturn, TVariables>;
@@ -29,8 +60,16 @@ export interface ExecutionRequest<TVariables extends Record<string, any> = any,
     extensions?: TExtensions;
     rootValue?: TRootValue;
     context?: TContext;
+    subgraphName?: string;
     info?: GraphQLResolveInfo;
     signal?: AbortSignal;
+    /**
+     * Enable/Disable the addition of field schema coordinate in GraphQL Errors extension
+     *
+     * Note: Schema Coordinate are exposed using Symbol.for('schemaCoordinate') so that it's not
+     *       serialized. Exposing schema coordinate can ease the discovery of private schemas.
+     */
+    schemaCoordinateInErrors?: boolean;
 }
 export interface GraphQLParseOptions {
     noLocation?: boolean;

package/typings/Interfaces.d.ts

@@ -20,6 +20,37 @@ export interface ExecutionResult<TData = any, TExtensions = any> {
 }
 export interface GraphQLResolveInfo extends OrigGraphQLResolveInfo {
     signal?: AbortSignal;
+    /** Returns the AbortSignal supplied for this execution, if any. */
+    readonly getAbortSignal: () => AbortSignal | undefined;
+    /** Returns helper functions for tracking asynchronous resolver work. */
+    readonly getAsyncHelpers: () => GraphQLResolveInfoHelpers;
+}
+export interface GraphQLResolveInfoHelpers {
+    /**
+     * Promise.all wrapper that allows rejected branches to be tracked
+     * as execution async work.
+     *
+     * Intended use: return or await this promise from resolver work.
+     * Un-awaited async side effects are an anti-pattern:
+     *
+     *   const { promiseAll } = info.getAsyncHelpers();
+     *   promiseAll([someAsyncWork(), someOtherAsyncWork()]).catch(() => undefined);
+     *
+     * In that anti-pattern, tracking starts only after rejection (on a
+     * later microtask), so this work is not guaranteed to delay
+     * `hooks.asyncWorkFinished`.
+     *
+     * Use `track(...)` for un-awaited async side effects:
+     *
+     *   const { track } = info.getAsyncHelpers();
+     *   track([
+     *     someAsyncWork().catch(() => undefined),
+     *     someOtherAsyncWork().catch(() => undefined)
+     *   ]);
+     */
+    readonly promiseAll: <T>(values: ReadonlyArray<PromiseLike<T> | T>) => Promise<Array<T>>;
+    /** Tracks asynchronous work that should delay execution completion hooks. */
+    readonly track: (maybePromises: ReadonlyArray<unknown>) => void;
 }
 export interface ExecutionRequest<TVariables extends Record<string, any> = any, TContext = any, TRootValue = any, TExtensions = Record<string, any>, TReturn = any> {
     document: TypedDocumentNode<TReturn, TVariables>;
@@ -29,8 +60,16 @@ export interface ExecutionRequest<TVariables extends Record<string, any> = any,
     extensions?: TExtensions;
     rootValue?: TRootValue;
     context?: TContext;
+    subgraphName?: string;
     info?: GraphQLResolveInfo;
     signal?: AbortSignal;
+    /**
+     * Enable/Disable the addition of field schema coordinate in GraphQL Errors extension
+     *
+     * Note: Schema Coordinate are exposed using Symbol.for('schemaCoordinate') so that it's not
+     *       serialized. Exposing schema coordinate can ease the discovery of private schemas.
+     */
+    schemaCoordinateInErrors?: boolean;
 }
 export interface GraphQLParseOptions {
     noLocation?: boolean;