@graphql-tools/utils 10.7.2 → 12.0.1

package/cjs/astFromValue.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.astFromValue = astFromValue;
-const cross_inspect_1 = require("cross-inspect");
 const graphql_1 = require("graphql");
 const astFromValueUntyped_js_1 = require("./astFromValueUntyped.js");
 const jsutils_js_1 = require("./jsutils.js");
@@ -81,24 +80,32 @@ function astFromValue(value, type) {
     if ((0, graphql_1.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 ((0, graphql_1.isEnumType)(type)) {
-            return { kind: graphql_1.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: graphql_1.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: graphql_1.Kind.INT, value: serialized };
+        if (type.name === 'ID' && typeof value === 'string' && integerStringRegExp.test(value)) {
+            return { kind: graphql_1.Kind.INT, value };
         }
-        return (0, astFromValueUntyped_js_1.astFromValueUntyped)(serialized);
     }
-    /* c8 ignore next 3 */
-    // Not reachable, all possible types have been considered.
-    console.assert(false, 'Unexpected input type: ' + (0, cross_inspect_1.inspect)(type));
+    return (0, astFromValueUntyped_js_1.astFromValueUntyped)(value);
 }
 /**
  * IntValue:

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildOperationNodeForField = buildOperationNodeForField;
 const graphql_1 = require("graphql");
+const astFromValueUntyped_js_1 = require("./astFromValueUntyped.js");
+const defaultValueAstFromType_js_1 = require("./defaultValueAstFromType.js");
 const rootTypes_js_1 = require("./rootTypes.js");
 let operationVariables = [];
 let fieldTypeMap = new Map();
@@ -241,6 +243,13 @@ function resolveVariable(arg, name) {
             },
         };
     }
+    let defaultValue;
+    try {
+        defaultValue = (0, defaultValueAstFromType_js_1.defaultValueAstFromType)(arg);
+    }
+    catch (e) {
+        defaultValue = (0, astFromValueUntyped_js_1.astFromValueUntyped)(arg.defaultValue) ?? undefined;
+    }
     return {
         kind: graphql_1.Kind.VARIABLE_DEFINITION,
         variable: {
@@ -251,6 +260,7 @@ function resolveVariable(arg, name) {
             },
         },
         type: resolveVariableType(arg.type),
+        defaultValue,
     };
 }
 function getArgumentName(name, path) {
@@ -299,9 +309,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 (!(0, graphql_1.isScalarType)(namedType) && !(0, graphql_1.isEnumType)(namedType)) {

package/cjs/collectFields.js

@@ -9,6 +9,7 @@ exports.getDeferValues = getDeferValues;
 const graphql_1 = require("graphql");
 const AccumulatorMap_js_1 = require("./AccumulatorMap.js");
 const directives_js_1 = require("./directives.js");
+const getDirectiveValues_js_1 = require("./getDirectiveValues.js");
 const memoize_js_1 = require("./memoize.js");
 function collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, patches, visitedFragmentNames) {
     for (const selection of selectionSet.selections) {
@@ -90,11 +91,11 @@ function collectFields(schema, fragments, variableValues, runtimeType, selection
  * directives, where `@skip` has higher precedence than `@include`.
  */
 function shouldIncludeNode(variableValues, node) {
-    const skip = (0, graphql_1.getDirectiveValues)(graphql_1.GraphQLSkipDirective, node, variableValues);
+    const skip = (0, getDirectiveValues_js_1.getDirectiveValues)(graphql_1.GraphQLSkipDirective, node, variableValues);
     if (skip?.['if'] === true) {
         return false;
     }
-    const include = (0, graphql_1.getDirectiveValues)(graphql_1.GraphQLIncludeDirective, node, variableValues);
+    const include = (0, getDirectiveValues_js_1.getDirectiveValues)(graphql_1.GraphQLIncludeDirective, node, variableValues);
     if (include?.['if'] === false) {
         return false;
     }
@@ -130,7 +131,7 @@ function getFieldEntryKey(node) {
  * not disabled by the "if" argument.
  */
 function getDeferValues(variableValues, node) {
-    const defer = (0, graphql_1.getDirectiveValues)(directives_js_1.GraphQLDeferDirective, node, variableValues);
+    const defer = (0, getDirectiveValues_js_1.getDirectiveValues)(directives_js_1.GraphQLDeferDirective, node, variableValues);
     if (!defer) {
         return;
     }

package/cjs/comments.js

@@ -127,7 +127,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/cjs/defaultValueAstFromType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultValueAstFromType = void 0;
+const graphql_1 = require("graphql");
+const astFromValue_js_1 = require("./astFromValue.js");
+const astFromValueUntyped_js_1 = require("./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,
+ */
+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 (0, astFromValueUntyped_js_1.astFromValueUntyped)(arg.default.value) ?? undefined;
+        }
+        const value = (0, graphql_1.valueFromASTUntyped)(arg.default.literal);
+        return (0, astFromValue_js_1.astFromValue)(value, arg.type) ?? undefined;
+    }
+    // graphql < v17 has `defaultValue` instead of `default`
+    return arg.defaultValue !== undefined
+        ? ((0, astFromValue_js_1.astFromValue)(arg.defaultValue, arg.type) ?? undefined)
+        : undefined;
+};
+exports.defaultValueAstFromType = defaultValueAstFromType;

package/cjs/descriptionFromObject.js

@@ -3,16 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDescriptionNode = getDescriptionNode;
 const graphql_1 = require("graphql");
 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: graphql_1.Kind.STRING,
+            value: obj.description,
             block: true,
         };
     }
-    if (obj.description) {
+    if (obj.astNode?.description) {
         return {
-            kind: graphql_1.Kind.STRING,
-            value: obj.description,
+            ...obj.astNode.description,
             block: true,
         };
     }

package/cjs/errors.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGraphQLErrorLike = isGraphQLErrorLike;
 exports.createGraphQLError = createGraphQLError;
+exports.getSchemaCoordinate = getSchemaCoordinate;
+exports.locatedError = locatedError;
 exports.relocatedError = relocatedError;
 const graphql_1 = require("graphql");
 const possibleGraphQLErrorProperties = [
@@ -14,6 +17,7 @@ const possibleGraphQLErrorProperties = [
     'name',
     'stack',
     'extensions',
+    'coordinate',
 ];
 function isGraphQLErrorLike(error) {
     return (error != null &&
@@ -26,12 +30,33 @@ function createGraphQLError(message, options) {
         isGraphQLErrorLike(options.originalError)) {
         options.originalError = createGraphQLError(options.originalError.message, options.originalError);
     }
-    if (graphql_1.versionInfo.major >= 17) {
-        return new graphql_1.GraphQLError(message, options);
+    // To avoid type error on graphql <16, we have to use an any type here
+    const Constructor = graphql_1.GraphQLError;
+    const error = graphql_1.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 graphql_1.GraphQLError(message, options?.nodes, options?.source, options?.positions, options?.path, options?.originalError, options?.extensions);
+    return error;
 }
-function relocatedError(originalError, path) {
+function getSchemaCoordinate(error) {
+    return error.coordinate;
+}
+function locatedError(rawError, nodes, path, info) {
+    const error = (0, graphql_1.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;
+}
+function relocatedError(originalError, path, info) {
     return createGraphQLError(originalError.message, {
         nodes: originalError.nodes,
         source: originalError.source,
@@ -39,5 +64,6 @@ function relocatedError(originalError, path) {
         path: path == null ? originalError.path : path,
         originalError,
         extensions: originalError.extensions,
+        coordinate: info ? `${info.parentType.name}.${info.fieldName}` : undefined,
     });
 }

package/cjs/getArgumentValues.js

@@ -20,14 +20,22 @@ 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
+                        : (0, graphql_1.valueFromASTUntyped)(arg.default.literal);
             }
-            else if ((0, graphql_1.isNonNullType)(argType)) {
-                throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" of required type "${(0, cross_inspect_1.inspect)(argType)}" ` + 'was not provided.', {
+            else if (arg.defaultValue !== undefined) {
+                // graphql < v17
+                coercedValues[arg.name] = arg.defaultValue;
+            }
+            else if ((0, graphql_1.isNonNullType)(arg.type)) {
+                throw (0, errors_js_1.createGraphQLError)(`Argument "${arg.name}" of required type "${(0, cross_inspect_1.inspect)(arg.type)}" ` + 'was not provided.', {
                     nodes: [node],
                 });
             }
@@ -38,11 +46,11 @@ function getArgumentValues(def, node, variableValues = {}) {
         if (valueNode.kind === graphql_1.Kind.VARIABLE) {
             const variableName = valueNode.name.value;
             if (variableValues == null || !(0, jsutils_js_1.hasOwnProperty)(variableValues, variableName)) {
-                if (defaultValue !== undefined) {
-                    coercedValues[name] = defaultValue;
+                if (arg.defaultValue !== undefined) {
+                    coercedValues[arg.name] = arg.defaultValue;
                 }
-                else if ((0, graphql_1.isNonNullType)(argType)) {
-                    throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" of required type "${(0, cross_inspect_1.inspect)(argType)}" ` +
+                else if ((0, graphql_1.isNonNullType)(arg.type)) {
+                    throw (0, errors_js_1.createGraphQLError)(`Argument "${arg.name}" of required type "${(0, cross_inspect_1.inspect)(arg.type)}" ` +
                         `was provided the variable "$${variableName}" which was not provided a runtime value.`, {
                         nodes: [valueNode],
                     });
@@ -51,21 +59,21 @@ function getArgumentValues(def, node, variableValues = {}) {
             }
             isNull = variableValues[variableName] == null;
         }
-        if (isNull && (0, graphql_1.isNonNullType)(argType)) {
-            throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" of non-null type "${(0, cross_inspect_1.inspect)(argType)}" ` + 'must not be null.', {
+        if (isNull && (0, graphql_1.isNonNullType)(arg.type)) {
+            throw (0, errors_js_1.createGraphQLError)(`Argument "${arg.name}" of non-null type "${(0, cross_inspect_1.inspect)(arg.type)}" ` + 'must not be null.', {
                 nodes: [valueNode],
             });
         }
-        const coercedValue = (0, graphql_1.valueFromAST)(valueNode, argType, variableValues);
+        const coercedValue = (0, graphql_1.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 (0, errors_js_1.createGraphQLError)(`Argument "${name}" has invalid value ${(0, graphql_1.print)(valueNode)}.`, {
+            throw (0, errors_js_1.createGraphQLError)(`Argument "${arg.name}" has invalid value ${(0, graphql_1.print)(valueNode)}.`, {
                 nodes: [valueNode],
             });
         }
-        coercedValues[name] = coercedValue;
+        coercedValues[arg.name] = coercedValue;
     }
     return coercedValues;
 }

package/cjs/getDirectiveValues.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirectiveValues = getDirectiveValues;
+const graphql_1 = require("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.
+ */
+function getDirectiveValues(directiveDef, node, variableValues) {
+    if (graphql_1.versionInfo.major >= 17) {
+        return (0, graphql_1.getDirectiveValues)(directiveDef, node, variableValues);
+    }
+    return (0, graphql_1.getDirectiveValues)(directiveDef, node, variableValues?.coerced);
+}

package/cjs/heal.js

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

package/cjs/helpers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asArray = void 0;
+exports.isUrl = isUrl;
 exports.isDocumentString = isDocumentString;
 exports.isValidPath = isValidPath;
 exports.compareStrings = compareStrings;
@@ -9,7 +10,27 @@ exports.compareNodes = compareNodes;
 exports.isSome = isSome;
 exports.assertSome = assertSome;
 const graphql_1 = require("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.
+ */
+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;
@@ -21,6 +42,21 @@ function isURL(str) {
 const asArray = (fns) => (Array.isArray(fns) ? fns : fns ? [fns] : []);
 exports.asArray = asArray;
 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
+ */
 function isDocumentString(str) {
     if (typeof str !== 'string') {
         return false;
@@ -30,7 +66,7 @@ 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 {
@@ -46,9 +82,9 @@ 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/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inspect = void 0;
+exports.createDeferred = exports.fakePromise = exports.mapMaybePromise = exports.mapAsyncIterator = exports.inspect = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./loaders.js"), exports);
 tslib_1.__exportStar(require("./helpers.js"), exports);
@@ -32,8 +32,8 @@ tslib_1.__exportStar(require("./getResponseKeyFromInfo.js"), exports);
 tslib_1.__exportStar(require("./fields.js"), exports);
 tslib_1.__exportStar(require("./renameType.js"), exports);
 tslib_1.__exportStar(require("./transformInputValue.js"), exports);
-tslib_1.__exportStar(require("./mapAsyncIterator.js"), exports);
 tslib_1.__exportStar(require("./updateArgument.js"), exports);
+tslib_1.__exportStar(require("./astFromType.js"), exports);
 tslib_1.__exportStar(require("./implementsAbstractType.js"), exports);
 tslib_1.__exportStar(require("./errors.js"), exports);
 tslib_1.__exportStar(require("./observableToAsyncIterable.js"), exports);
@@ -60,7 +60,10 @@ tslib_1.__exportStar(require("./directives.js"), exports);
 tslib_1.__exportStar(require("./mergeIncrementalResult.js"), exports);
 tslib_1.__exportStar(require("./debugTimer.js"), exports);
 tslib_1.__exportStar(require("./getDirectiveExtensions.js"), exports);
-tslib_1.__exportStar(require("./map-maybe-promise.js"), exports);
-tslib_1.__exportStar(require("./fakePromise.js"), exports);
-tslib_1.__exportStar(require("./createDeferred.js"), exports);
+var promise_helpers_1 = require("@whatwg-node/promise-helpers");
+Object.defineProperty(exports, "mapAsyncIterator", { enumerable: true, get: function () { return promise_helpers_1.mapAsyncIterator; } });
+Object.defineProperty(exports, "mapMaybePromise", { enumerable: true, get: function () { return promise_helpers_1.mapMaybePromise; } });
+Object.defineProperty(exports, "fakePromise", { enumerable: true, get: function () { return promise_helpers_1.fakePromise; } });
+Object.defineProperty(exports, "createDeferred", { enumerable: true, get: function () { return promise_helpers_1.createDeferredPromise; } });
 tslib_1.__exportStar(require("./registerAbortSignalListener.js"), exports);
+tslib_1.__exportStar(require("./getDirectiveValues.js"), exports);

package/cjs/jsutils.js

@@ -1,24 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = void 0;
 exports.isIterableObject = isIterableObject;
 exports.isObjectLike = isObjectLike;
-exports.isPromise = isPromise;
 exports.promiseReduce = promiseReduce;
 exports.hasOwnProperty = hasOwnProperty;
-const map_maybe_promise_js_1 = require("./map-maybe-promise.js");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+Object.defineProperty(exports, "isPromise", { enumerable: true, get: function () { return promise_helpers_1.isPromise; } });
 function isIterableObject(value) {
     return value != null && typeof value === 'object' && Symbol.iterator in value;
 }
 function isObjectLike(value) {
     return typeof value === 'object' && value !== null;
 }
-function isPromise(value) {
-    return value?.then != null;
-}
 function promiseReduce(values, callbackFn, initialValue) {
     let accumulator = initialValue;
     for (const value of values) {
-        accumulator = (0, map_maybe_promise_js_1.mapMaybePromise)(accumulator, resolved => callbackFn(resolved, value));
+        accumulator = (0, promise_helpers_1.handleMaybePromise)(() => accumulator, resolved => callbackFn(resolved, value));
     }
     return accumulator;
 }

package/cjs/mapSchema.js

@@ -21,10 +21,11 @@ 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/cjs/mergeDeep.js

@@ -2,7 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeDeep = mergeDeep;
 const helpers_js_1 = require("./helpers.js");
-function mergeDeep(sources, respectPrototype = false, respectArrays = false, respectArrayLength = false) {
+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 => {
@@ -21,7 +27,7 @@ function mergeDeep(sources, respectPrototype = false, respectArrays = false, res
         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);
@@ -30,15 +36,21 @@ function mergeDeep(sources, respectPrototype = false, respectArrays = false, res
     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);
@@ -52,16 +64,30 @@ function mergeDeep(sources, respectPrototype = false, respectArrays = false, res
                 }
             }
             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/cjs/mergeIncrementalResult.js

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeIncrementalResult = mergeIncrementalResult;
-const merge_1 = require("dset/merge");
+const mergeDeep_js_1 = require("./mergeDeep.js");
 function mergeIncrementalResult({ incrementalResult, executionResult, }) {
     const path = ['data', ...(incrementalResult.path ?? [])];
     if (incrementalResult.items) {
         for (const item of incrementalResult.items) {
-            (0, merge_1.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) {
-        (0, merge_1.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) {
-        (0, merge_1.dset)(executionResult, 'extensions', incrementalResult.extensions);
+        setObjectKeyPath(executionResult, ['extensions'], incrementalResult.extensions);
     }
     if (incrementalResult.incremental) {
         incrementalResult.incremental.forEach(incrementalSubResult => {
@@ -30,3 +30,24 @@ 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 ? (0, mergeDeep_js_1.mergeDeep)([existingValue, value]) : value;
+}