@graphql-tools/utils 10.7.2 → 12.0.1

package/cjs/observableToAsyncIterable.js

@@ -1,11 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.observableToAsyncIterable = observableToAsyncIterable;
-const fakePromise_js_1 = require("./fakePromise.js");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 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.
@@ -27,23 +39,29 @@ 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);
         },
@@ -54,17 +72,11 @@ 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.
@@ -72,11 +84,11 @@ function observableToAsyncIterable(observable) {
         },
         return() {
             emptyQueue();
-            return (0, fakePromise_js_1.fakePromise)({ value: undefined, done: true });
+            return (0, promise_helpers_1.fakePromise)({ value: undefined, done: true });
         },
         throw(error) {
             emptyQueue();
-            return Promise.reject(error);
+            return (0, promise_helpers_1.fakeRejectPromise)(error);
         },
         [Symbol.asyncIterator]() {
             return this;

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

@@ -22,6 +22,7 @@ const graphql_1 = require("graphql");
 const astFromType_js_1 = require("./astFromType.js");
 const astFromValue_js_1 = require("./astFromValue.js");
 const astFromValueUntyped_js_1 = require("./astFromValueUntyped.js");
+const defaultValueAstFromType_js_1 = require("./defaultValueAstFromType.js");
 const descriptionFromObject_js_1 = require("./descriptionFromObject.js");
 const get_directives_js_1 = require("./get-directives.js");
 const helpers_js_1 = require("./helpers.js");
@@ -116,6 +117,10 @@ 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(helpers_js_1.isSome);
     const directives = getDirectiveNodes(schema, schema, pathToDirectivesInExtensions);
@@ -123,7 +128,7 @@ function astFromSchema(schema, pathToDirectivesInExtensions) {
         return null;
     }
     const schemaNode = {
-        kind: operationTypes != null ? graphql_1.Kind.SCHEMA_DEFINITION : graphql_1.Kind.SCHEMA_EXTENSION,
+        kind: operationTypes.length ? graphql_1.Kind.SCHEMA_DEFINITION : graphql_1.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,
@@ -151,7 +156,7 @@ function astFromDirective(directive, schema, pathToDirectivesInExtensions) {
     };
 }
 function getDirectiveNodes(entity, schema, pathToDirectivesInExtensions) {
-    let directiveNodesBesidesDeprecatedAndSpecifiedBy = [];
+    let directiveNodesBesidesNativeDirectives = [];
     const directivesInExtensions = (0, get_directives_js_1.getDirectivesInExtensions)(entity, pathToDirectivesInExtensions);
     let directives;
     if (directivesInExtensions != null) {
@@ -159,14 +164,12 @@ 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 => graphql_1.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);
@@ -179,13 +182,19 @@ 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;
 }
 function astFromArg(arg, schema, pathToDirectivesInExtensions) {
     return {
@@ -196,10 +205,7 @@ function astFromArg(arg, schema, pathToDirectivesInExtensions) {
             value: arg.name,
         },
         type: (0, astFromType_js_1.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
-            ? ((0, astFromValue_js_1.astFromValue)(arg.defaultValue, arg.type) ?? undefined)
-            : undefined,
+        defaultValue: (0, defaultValueAstFromType_js_1.defaultValueAstFromType)(arg),
         directives: getDirectiveNodes(arg, schema, pathToDirectivesInExtensions),
     };
 }
@@ -319,7 +325,7 @@ function astFromInputField(field, schema, pathToDirectivesInExtensions) {
         type: (0, astFromType_js_1.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: (0, astFromValue_js_1.astFromValue)(field.defaultValue, field.type) ?? undefined,
+        defaultValue: (0, defaultValueAstFromType_js_1.defaultValueAstFromType)(field),
     };
 }
 function astFromEnumValue(value, schema, pathToDirectivesInExtensions) {

package/cjs/registerAbortSignalListener.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAbortPromise = void 0;
 exports.registerAbortSignalListener = registerAbortSignalListener;
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 const memoize_js_1 = require("./memoize.js");
 // AbortSignal handler cache to avoid the "possible EventEmitter memory leak detected"
 // on Node.js
@@ -29,8 +30,11 @@ function registerAbortSignalListener(signal, listener) {
     getListenersOfAbortSignal(signal).add(listener);
 }
 exports.getAbortPromise = (0, memoize_js_1.memoize1)(function getAbortPromise(signal) {
+    // If the signal is already aborted, return a rejected promise
+    if (signal.aborted) {
+        return (0, promise_helpers_1.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/cjs/stub.js

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

package/cjs/updateArgument.js

@@ -46,7 +46,8 @@ 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/cjs/visitResult.js

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

package/esm/astFromValue.js

@@ -1,4 +1,3 @@
-import { inspect } from 'cross-inspect';
 import { isEnumType, isInputObjectType, isLeafType, isListType, isNonNullType, Kind, } from 'graphql';
 import { astFromValueUntyped } from './astFromValueUntyped.js';
 import { isIterableObject, isObjectLike } from './jsutils.js';
@@ -78,24 +77,32 @@ export function astFromValue(value, type) {
     if (isLeafType(type)) {
         // Since value is an internally represented value, it must be serialized
         // to an externally represented value before converting into an AST.
-        const serialized = type.serialize(value);
-        if (serialized == null) {
-            return null;
-        }
         if (isEnumType(type)) {
-            return { kind: Kind.ENUM, value: serialized };
+            const values = type.getValues();
+            for (const enumValue of values) {
+                if (enumValue.value === value) {
+                    value = enumValue.name;
+                    break;
+                }
+                if (enumValue.name === value) {
+                    value = enumValue.name;
+                    break;
+                }
+            }
+            return { kind: Kind.ENUM, value: value };
+        }
+        else {
+            value = type.serialize(value);
+        }
+        if (value == null) {
+            return null;
         }
         // ID types can use Int literals.
-        if (type.name === 'ID' &&
-            typeof serialized === 'string' &&
-            integerStringRegExp.test(serialized)) {
-            return { kind: Kind.INT, value: serialized };
+        if (type.name === 'ID' && typeof value === 'string' && integerStringRegExp.test(value)) {
+            return { kind: Kind.INT, value };
         }
-        return astFromValueUntyped(serialized);
     }
-    /* c8 ignore next 3 */
-    // Not reachable, all possible types have been considered.
-    console.assert(false, 'Unexpected input type: ' + inspect(type));
+    return astFromValueUntyped(value);
 }
 /**
  * IntValue:

package/esm/build-operation-for-field.js

@@ -1,4 +1,6 @@
 import { getNamedType, isEnumType, isInterfaceType, isListType, isNonNullType, isObjectType, isScalarType, isUnionType, Kind, } from 'graphql';
+import { astFromValueUntyped } from './astFromValueUntyped.js';
+import { defaultValueAstFromType } from './defaultValueAstFromType.js';
 import { getDefinedRootType, getRootTypeNames } from './rootTypes.js';
 let operationVariables = [];
 let fieldTypeMap = new Map();
@@ -238,6 +240,13 @@ function resolveVariable(arg, name) {
             },
         };
     }
+    let defaultValue;
+    try {
+        defaultValue = defaultValueAstFromType(arg);
+    }
+    catch (e) {
+        defaultValue = astFromValueUntyped(arg.defaultValue) ?? undefined;
+    }
     return {
         kind: Kind.VARIABLE_DEFINITION,
         variable: {
@@ -248,6 +257,7 @@ function resolveVariable(arg, name) {
             },
         },
         type: resolveVariableType(arg.type),
+        defaultValue,
     };
 }
 function getArgumentName(name, path) {
@@ -296,9 +306,9 @@ function resolveField({ type, field, models, firstCall, path, ancestors, ignore,
     if (fieldTypeMap.has(fieldPathStr) && fieldTypeMap.get(fieldPathStr) !== field.type.toString()) {
         fieldName += field.type
             .toString()
-            .replace('!', 'NonNull')
-            .replace('[', 'List')
-            .replace(']', '');
+            .replace(/!/g, 'NonNull')
+            .replace(/\[/g, 'List')
+            .replace(/\]/g, '');
     }
     fieldTypeMap.set(fieldPathStr, field.type.toString());
     if (!isScalarType(namedType) && !isEnumType(namedType)) {

package/esm/collectFields.js

@@ -1,6 +1,7 @@
-import { getDirectiveValues, GraphQLIncludeDirective, GraphQLSkipDirective, isAbstractType, Kind, typeFromAST, } from 'graphql';
+import { GraphQLIncludeDirective, GraphQLSkipDirective, isAbstractType, Kind, typeFromAST, } from 'graphql';
 import { AccumulatorMap } from './AccumulatorMap.js';
 import { GraphQLDeferDirective } from './directives.js';
+import { getDirectiveValues } from './getDirectiveValues.js';
 import { memoize5 } from './memoize.js';
 function collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, patches, visitedFragmentNames) {
     for (const selection of selectionSet.selections) {

package/esm/comments.js

@@ -115,7 +115,7 @@ function wrap(start, maybeString, end) {
  * a single-line, adding a leading blank line would strip that whitespace.
  */
 function printBlockString(value, isDescription = false) {
-    const escaped = value.replace(/"""/g, '\\"""');
+    const escaped = value.replace(/\\/g, '\\\\').replace(/"""/g, '\\"""');
     return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1
         ? `"""${escaped.replace(/"$/, '"\n')}"""`
         : `"""\n${isDescription ? escaped : indent(escaped)}\n"""`;

package/esm/defaultValueAstFromType.js

@@ -0,0 +1,28 @@
+import { valueFromASTUntyped, } from 'graphql';
+import { astFromValue } from './astFromValue.js';
+import { astFromValueUntyped } from './astFromValueUntyped.js';
+/**
+ * `defaultValueAstFromType` extracts default value from `GraphQLArgument` or `GraphQLInputField`, if available
+ * This is compatible with all `graphql` versions
+ *
+ * The return type is `ConstValueNode` in graphql@16+,
+ * but it is not available in graphql@15 so `ValueNode` is used as return type here and `as any` is often required at callsites for backwards compatibility,
+ */
+export const defaultValueAstFromType = (arg) => {
+    // graphql >= v17 has `default` instead of `defaultValue`
+    // So for backward compatibility with v16, we are using `arg.default as any`, otherwise, TypeScript report type error
+    if ('default' in arg) {
+        if (!arg.default) {
+            return undefined;
+        }
+        if ('value' in arg.default) {
+            return astFromValueUntyped(arg.default.value) ?? undefined;
+        }
+        const value = valueFromASTUntyped(arg.default.literal);
+        return astFromValue(value, arg.type) ?? undefined;
+    }
+    // graphql < v17 has `defaultValue` instead of `default`
+    return arg.defaultValue !== undefined
+        ? (astFromValue(arg.defaultValue, arg.type) ?? undefined)
+        : undefined;
+};

package/esm/descriptionFromObject.js

@@ -1,15 +1,17 @@
 import { Kind } from 'graphql';
 export function getDescriptionNode(obj) {
-    if (obj.astNode?.description) {
+    // Prefer the runtime `description` over a stale `astNode` description.
+    // Schema transforms (e.g. mapSchema) update config descriptions without rewriting astNode (#5508).
+    if (typeof obj.description === 'string') {
         return {
-            ...obj.astNode.description,
+            kind: Kind.STRING,
+            value: obj.description,
             block: true,
         };
     }
-    if (obj.description) {
+    if (obj.astNode?.description) {
         return {
-            kind: Kind.STRING,
-            value: obj.description,
+            ...obj.astNode.description,
             block: true,
         };
     }

package/esm/errors.js

@@ -1,4 +1,4 @@
-import { GraphQLError, versionInfo } from 'graphql';
+import { locatedError as _locatedError, GraphQLError, versionInfo } from 'graphql';
 const possibleGraphQLErrorProperties = [
     'message',
     'locations',
@@ -10,8 +10,9 @@ const possibleGraphQLErrorProperties = [
     'name',
     'stack',
     'extensions',
+    'coordinate',
 ];
-function isGraphQLErrorLike(error) {
+export function isGraphQLErrorLike(error) {
     return (error != null &&
         typeof error === 'object' &&
         Object.keys(error).every(key => possibleGraphQLErrorProperties.includes(key)));
@@ -22,12 +23,33 @@ export function createGraphQLError(message, options) {
         isGraphQLErrorLike(options.originalError)) {
         options.originalError = createGraphQLError(options.originalError.message, options.originalError);
     }
-    if (versionInfo.major >= 17) {
-        return new GraphQLError(message, options);
+    // To avoid type error on graphql <16, we have to use an any type here
+    const Constructor = GraphQLError;
+    const error = versionInfo.major >= 16
+        ? new Constructor(message, options)
+        : new Constructor(message, options?.nodes, options?.source, options?.positions, options?.path, options?.originalError, options?.extensions);
+    if (options?.coordinate && error.coordinate == null) {
+        Object.defineProperties(error, {
+            coordinate: { value: options.coordinate, enumerable: true, configurable: true },
+        });
     }
-    return new GraphQLError(message, options?.nodes, options?.source, options?.positions, options?.path, options?.originalError, options?.extensions);
+    return error;
 }
-export function relocatedError(originalError, path) {
+export function getSchemaCoordinate(error) {
+    return error.coordinate;
+}
+export function locatedError(rawError, nodes, path, info) {
+    const error = _locatedError(rawError, nodes, path);
+    // `graphql` locatedError is only changing path and nodes if it is not already defined
+    if (!error.coordinate && info && error.coordinate == null) {
+        const coordinate = `${info.parentType.name}.${info.fieldName}`;
+        Object.defineProperties(error, {
+            coordinate: { value: coordinate, enumerable: true, configurable: true },
+        });
+    }
+    return error;
+}
+export function relocatedError(originalError, path, info) {
     return createGraphQLError(originalError.message, {
         nodes: originalError.nodes,
         source: originalError.source,
@@ -35,5 +57,6 @@ export function relocatedError(originalError, path) {
         path: path == null ? originalError.path : path,
         originalError,
         extensions: originalError.extensions,
+        coordinate: info ? `${info.parentType.name}.${info.fieldName}` : undefined,
     });
 }

package/esm/getArgumentValues.js

@@ -1,5 +1,5 @@
 import { inspect } from 'cross-inspect';
-import { isNonNullType, Kind, print, valueFromAST, } from 'graphql';
+import { isNonNullType, Kind, print, valueFromAST, valueFromASTUntyped, } from 'graphql';
 import { createGraphQLError } from './errors.js';
 import { hasOwnProperty } from './jsutils.js';
 /**
@@ -17,14 +17,22 @@ export function getArgumentValues(def, node, variableValues = {}) {
         ...prev,
         [arg.name.value]: arg,
     }), {});
-    for (const { name, type: argType, defaultValue } of def.args) {
-        const argumentNode = argNodeMap[name];
+    for (const arg of def.args) {
+        const argumentNode = argNodeMap[arg.name];
         if (!argumentNode) {
-            if (defaultValue !== undefined) {
-                coercedValues[name] = defaultValue;
+            if ('default' in arg && arg.default) {
+                // graphql v17
+                coercedValues[arg.name] =
+                    'value' in arg.default
+                        ? arg.default.value
+                        : valueFromASTUntyped(arg.default.literal);
             }
-            else if (isNonNullType(argType)) {
-                throw createGraphQLError(`Argument "${name}" of required type "${inspect(argType)}" ` + 'was not provided.', {
+            else if (arg.defaultValue !== undefined) {
+                // graphql < v17
+                coercedValues[arg.name] = arg.defaultValue;
+            }
+            else if (isNonNullType(arg.type)) {
+                throw createGraphQLError(`Argument "${arg.name}" of required type "${inspect(arg.type)}" ` + 'was not provided.', {
                     nodes: [node],
                 });
             }
@@ -35,11 +43,11 @@ export function getArgumentValues(def, node, variableValues = {}) {
         if (valueNode.kind === Kind.VARIABLE) {
             const variableName = valueNode.name.value;
             if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
-                if (defaultValue !== undefined) {
-                    coercedValues[name] = defaultValue;
+                if (arg.defaultValue !== undefined) {
+                    coercedValues[arg.name] = arg.defaultValue;
                 }
-                else if (isNonNullType(argType)) {
-                    throw createGraphQLError(`Argument "${name}" of required type "${inspect(argType)}" ` +
+                else if (isNonNullType(arg.type)) {
+                    throw createGraphQLError(`Argument "${arg.name}" of required type "${inspect(arg.type)}" ` +
                         `was provided the variable "$${variableName}" which was not provided a runtime value.`, {
                         nodes: [valueNode],
                     });
@@ -48,21 +56,21 @@ export function getArgumentValues(def, node, variableValues = {}) {
             }
             isNull = variableValues[variableName] == null;
         }
-        if (isNull && isNonNullType(argType)) {
-            throw createGraphQLError(`Argument "${name}" of non-null type "${inspect(argType)}" ` + 'must not be null.', {
+        if (isNull && isNonNullType(arg.type)) {
+            throw createGraphQLError(`Argument "${arg.name}" of non-null type "${inspect(arg.type)}" ` + 'must not be null.', {
                 nodes: [valueNode],
             });
         }
-        const coercedValue = valueFromAST(valueNode, argType, variableValues);
+        const coercedValue = valueFromAST(valueNode, arg.type, variableValues);
         if (coercedValue === undefined) {
             // Note: ValuesOfCorrectTypeRule validation should catch this before
             // execution. This is a runtime check to ensure execution does not
             // continue with an invalid argument value.
-            throw createGraphQLError(`Argument "${name}" has invalid value ${print(valueNode)}.`, {
+            throw createGraphQLError(`Argument "${arg.name}" has invalid value ${print(valueNode)}.`, {
                 nodes: [valueNode],
             });
         }
-        coercedValues[name] = coercedValue;
+        coercedValues[arg.name] = coercedValue;
     }
     return coercedValues;
 }

package/esm/getDirectiveValues.js

@@ -0,0 +1,12 @@
+import { getDirectiveValues as getDirectiveValuesOrig, versionInfo, } from 'graphql';
+/**
+ * GraphQL v17's getDirectiveValues function accepts `VariableValues`
+ * while older versions accept `Record<string, any>`. This function wraps the original
+ * getDirectiveValues function to provide compatibility across versions.
+ */
+export function getDirectiveValues(directiveDef, node, variableValues) {
+    if (versionInfo.major >= 17) {
+        return getDirectiveValuesOrig(directiveDef, node, variableValues);
+    }
+    return getDirectiveValuesOrig(directiveDef, node, variableValues?.coerced);
+}

package/esm/heal.js

@@ -154,7 +154,10 @@ export function healTypes(originalTypeMap, directives) {
         }
         else if (isNonNullType(type)) {
             const healedType = healType(type.ofType);
-            return healedType != null ? new GraphQLNonNull(healedType) : null;
+            return healedType != null
+                ? // FIXME: `healedType` needs `as any` as graphql@17 changes the type for `GraphQLType`
+                    new GraphQLNonNull(healedType)
+                : null;
         }
         else if (isNamedType(type)) {
             // If a type annotation on a field or an argument or a union member is