@graphql-tools/utils 8.7.0 → 8.8.0-alpha-b76ec274.0

package/esm/inspect.js

@@ -0,0 +1,103 @@
+// Taken from graphql-js
+// https://github.com/graphql/graphql-js/blob/main/src/jsutils/inspect.ts
+import { GraphQLError } from 'graphql';
+import { isAggregateError } from './AggregateError.js';
+const MAX_RECURSIVE_DEPTH = 3;
+/**
+ * Used to print values in error messages.
+ */
+export function inspect(value) {
+    return formatValue(value, []);
+}
+function formatValue(value, seenValues) {
+    switch (typeof value) {
+        case 'string':
+            return JSON.stringify(value);
+        case 'function':
+            return value.name ? `[function ${value.name}]` : '[function]';
+        case 'object':
+            return formatObjectValue(value, seenValues);
+        default:
+            return String(value);
+    }
+}
+function formatError(value) {
+    if (value instanceof GraphQLError) {
+        return value.toString();
+    }
+    return `${value.name}: ${value.message};\n ${value.stack}`;
+}
+function formatObjectValue(value, previouslySeenValues) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value instanceof Error) {
+        if (isAggregateError(value)) {
+            return formatError(value) + '\n' + formatArray(value.errors, previouslySeenValues);
+        }
+        return formatError(value);
+    }
+    if (previouslySeenValues.includes(value)) {
+        return '[Circular]';
+    }
+    const seenValues = [...previouslySeenValues, value];
+    if (isJSONable(value)) {
+        const jsonValue = value.toJSON();
+        // check for infinite recursion
+        if (jsonValue !== value) {
+            return typeof jsonValue === 'string' ? jsonValue : formatValue(jsonValue, seenValues);
+        }
+    }
+    else if (Array.isArray(value)) {
+        return formatArray(value, seenValues);
+    }
+    return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+    return typeof value.toJSON === 'function';
+}
+function formatObject(object, seenValues) {
+    const entries = Object.entries(object);
+    if (entries.length === 0) {
+        return '{}';
+    }
+    if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+        return '[' + getObjectTag(object) + ']';
+    }
+    const properties = entries.map(([key, value]) => key + ': ' + formatValue(value, seenValues));
+    return '{ ' + properties.join(', ') + ' }';
+}
+function formatArray(array, seenValues) {
+    if (array.length === 0) {
+        return '[]';
+    }
+    if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+        return '[Array]';
+    }
+    const len = array.length;
+    const remaining = array.length;
+    const items = [];
+    for (let i = 0; i < len; ++i) {
+        items.push(formatValue(array[i], seenValues));
+    }
+    if (remaining === 1) {
+        items.push('... 1 more item');
+    }
+    else if (remaining > 1) {
+        items.push(`... ${remaining} more items`);
+    }
+    return '[' + items.join(', ') + ']';
+}
+function getObjectTag(object) {
+    const tag = Object.prototype.toString
+        .call(object)
+        .replace(/^\[object /, '')
+        .replace(/]$/, '');
+    if (tag === 'Object' && typeof object.constructor === 'function') {
+        const name = object.constructor.name;
+        if (typeof name === 'string' && name !== '') {
+            return name;
+        }
+    }
+    return tag;
+}

package/esm/isAsyncIterable.js

@@ -0,0 +1,6 @@
+export function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}

package/esm/isDocumentNode.js

@@ -0,0 +1,4 @@
+import { Kind } from 'graphql';
+export function isDocumentNode(object) {
+    return object && typeof object === 'object' && 'kind' in object && object.kind === Kind.DOCUMENT;
+}

package/esm/loaders.js

@@ -0,0 +1 @@
+export {};

package/esm/mapAsyncIterator.js

@@ -0,0 +1,49 @@
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+export function mapAsyncIterator(iterator, callback, rejectCallback) {
+    let $return;
+    let abruptClose;
+    if (typeof iterator.return === 'function') {
+        $return = iterator.return;
+        abruptClose = (error) => {
+            const rethrow = () => Promise.reject(error);
+            return $return.call(iterator).then(rethrow, rethrow);
+        };
+    }
+    function mapResult(result) {
+        return result.done ? result : asyncMapValue(result.value, callback).then(iteratorResult, abruptClose);
+    }
+    let mapReject;
+    if (rejectCallback) {
+        // Capture rejectCallback to ensure it cannot be null.
+        const reject = rejectCallback;
+        mapReject = (error) => asyncMapValue(error, reject).then(iteratorResult, abruptClose);
+    }
+    return {
+        next() {
+            return iterator.next().then(mapResult, mapReject);
+        },
+        return() {
+            return $return
+                ? $return.call(iterator).then(mapResult, mapReject)
+                : Promise.resolve({ value: undefined, done: true });
+        },
+        throw(error) {
+            if (typeof iterator.throw === 'function') {
+                return iterator.throw(error).then(mapResult, mapReject);
+            }
+            return Promise.reject(error).catch(abruptClose);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+function asyncMapValue(value, callback) {
+    return new Promise(resolve => resolve(callback(value)));
+}
+function iteratorResult(value) {
+    return { value, done: false };
+}

package/esm/mapSchema.js

@@ -0,0 +1,465 @@
+import { GraphQLObjectType, GraphQLSchema, isInterfaceType, isEnumType, isObjectType, isScalarType, isUnionType, isInputObjectType, GraphQLInputObjectType, GraphQLInterfaceType, isLeafType, isListType, isNonNullType, isNamedType, GraphQLList, GraphQLNonNull, GraphQLEnumType, Kind, } from 'graphql';
+import { getObjectTypeFromTypeMap } from './getObjectTypeFromTypeMap.js';
+import { MapperKind, } from './Interfaces.js';
+import { rewireTypes } from './rewire.js';
+import { serializeInputValue, parseInputValue } from './transformInputValue.js';
+export function mapSchema(schema, schemaMapper = {}) {
+    const newTypeMap = mapArguments(mapFields(mapTypes(mapDefaultValues(mapEnumValues(mapTypes(mapDefaultValues(schema.getTypeMap(), schema, serializeInputValue), schema, schemaMapper, type => isLeafType(type)), schema, schemaMapper), schema, parseInputValue), schema, schemaMapper, type => !isLeafType(type)), schema, schemaMapper), schema, schemaMapper);
+    const originalDirectives = schema.getDirectives();
+    const newDirectives = mapDirectives(originalDirectives, schema, schemaMapper);
+    const { typeMap, directives } = rewireTypes(newTypeMap, newDirectives);
+    return new GraphQLSchema({
+        ...schema.toConfig(),
+        query: getObjectTypeFromTypeMap(typeMap, getObjectTypeFromTypeMap(newTypeMap, schema.getQueryType())),
+        mutation: getObjectTypeFromTypeMap(typeMap, getObjectTypeFromTypeMap(newTypeMap, schema.getMutationType())),
+        subscription: getObjectTypeFromTypeMap(typeMap, getObjectTypeFromTypeMap(newTypeMap, schema.getSubscriptionType())),
+        types: Object.values(typeMap),
+        directives,
+    });
+}
+function mapTypes(originalTypeMap, schema, schemaMapper, testFn = () => true) {
+    const newTypeMap = {};
+    for (const typeName in originalTypeMap) {
+        if (!typeName.startsWith('__')) {
+            const originalType = originalTypeMap[typeName];
+            if (originalType == null || !testFn(originalType)) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            const typeMapper = getTypeMapper(schema, schemaMapper, typeName);
+            if (typeMapper == null) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            const maybeNewType = typeMapper(originalType, schema);
+            if (maybeNewType === undefined) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            newTypeMap[typeName] = maybeNewType;
+        }
+    }
+    return newTypeMap;
+}
+function mapEnumValues(originalTypeMap, schema, schemaMapper) {
+    const enumValueMapper = getEnumValueMapper(schemaMapper);
+    if (!enumValueMapper) {
+        return originalTypeMap;
+    }
+    return mapTypes(originalTypeMap, schema, {
+        [MapperKind.ENUM_TYPE]: type => {
+            const config = type.toConfig();
+            const originalEnumValueConfigMap = config.values;
+            const newEnumValueConfigMap = {};
+            for (const externalValue in originalEnumValueConfigMap) {
+                const originalEnumValueConfig = originalEnumValueConfigMap[externalValue];
+                const mappedEnumValue = enumValueMapper(originalEnumValueConfig, type.name, schema, externalValue);
+                if (mappedEnumValue === undefined) {
+                    newEnumValueConfigMap[externalValue] = originalEnumValueConfig;
+                }
+                else if (Array.isArray(mappedEnumValue)) {
+                    const [newExternalValue, newEnumValueConfig] = mappedEnumValue;
+                    newEnumValueConfigMap[newExternalValue] =
+                        newEnumValueConfig === undefined ? originalEnumValueConfig : newEnumValueConfig;
+                }
+                else if (mappedEnumValue !== null) {
+                    newEnumValueConfigMap[externalValue] = mappedEnumValue;
+                }
+            }
+            return correctASTNodes(new GraphQLEnumType({
+                ...config,
+                values: newEnumValueConfigMap,
+            }));
+        },
+    }, type => isEnumType(type));
+}
+function mapDefaultValues(originalTypeMap, schema, fn) {
+    const newTypeMap = mapArguments(originalTypeMap, schema, {
+        [MapperKind.ARGUMENT]: argumentConfig => {
+            if (argumentConfig.defaultValue === undefined) {
+                return argumentConfig;
+            }
+            const maybeNewType = getNewType(originalTypeMap, argumentConfig.type);
+            if (maybeNewType != null) {
+                return {
+                    ...argumentConfig,
+                    defaultValue: fn(maybeNewType, argumentConfig.defaultValue),
+                };
+            }
+        },
+    });
+    return mapFields(newTypeMap, schema, {
+        [MapperKind.INPUT_OBJECT_FIELD]: inputFieldConfig => {
+            if (inputFieldConfig.defaultValue === undefined) {
+                return inputFieldConfig;
+            }
+            const maybeNewType = getNewType(newTypeMap, inputFieldConfig.type);
+            if (maybeNewType != null) {
+                return {
+                    ...inputFieldConfig,
+                    defaultValue: fn(maybeNewType, inputFieldConfig.defaultValue),
+                };
+            }
+        },
+    });
+}
+function getNewType(newTypeMap, type) {
+    if (isListType(type)) {
+        const newType = getNewType(newTypeMap, type.ofType);
+        return newType != null ? new GraphQLList(newType) : null;
+    }
+    else if (isNonNullType(type)) {
+        const newType = getNewType(newTypeMap, type.ofType);
+        return newType != null ? new GraphQLNonNull(newType) : null;
+    }
+    else if (isNamedType(type)) {
+        const newType = newTypeMap[type.name];
+        return newType != null ? newType : null;
+    }
+    return null;
+}
+function mapFields(originalTypeMap, schema, schemaMapper) {
+    const newTypeMap = {};
+    for (const typeName in originalTypeMap) {
+        if (!typeName.startsWith('__')) {
+            const originalType = originalTypeMap[typeName];
+            if (!isObjectType(originalType) && !isInterfaceType(originalType) && !isInputObjectType(originalType)) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            const fieldMapper = getFieldMapper(schema, schemaMapper, typeName);
+            if (fieldMapper == null) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            const config = originalType.toConfig();
+            const originalFieldConfigMap = config.fields;
+            const newFieldConfigMap = {};
+            for (const fieldName in originalFieldConfigMap) {
+                const originalFieldConfig = originalFieldConfigMap[fieldName];
+                const mappedField = fieldMapper(originalFieldConfig, fieldName, typeName, schema);
+                if (mappedField === undefined) {
+                    newFieldConfigMap[fieldName] = originalFieldConfig;
+                }
+                else if (Array.isArray(mappedField)) {
+                    const [newFieldName, newFieldConfig] = mappedField;
+                    if (newFieldConfig.astNode != null) {
+                        newFieldConfig.astNode = {
+                            ...newFieldConfig.astNode,
+                            name: {
+                                ...newFieldConfig.astNode.name,
+                                value: newFieldName,
+                            },
+                        };
+                    }
+                    newFieldConfigMap[newFieldName] = newFieldConfig === undefined ? originalFieldConfig : newFieldConfig;
+                }
+                else if (mappedField !== null) {
+                    newFieldConfigMap[fieldName] = mappedField;
+                }
+            }
+            if (isObjectType(originalType)) {
+                newTypeMap[typeName] = correctASTNodes(new GraphQLObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                }));
+            }
+            else if (isInterfaceType(originalType)) {
+                newTypeMap[typeName] = correctASTNodes(new GraphQLInterfaceType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                }));
+            }
+            else {
+                newTypeMap[typeName] = correctASTNodes(new GraphQLInputObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                }));
+            }
+        }
+    }
+    return newTypeMap;
+}
+function mapArguments(originalTypeMap, schema, schemaMapper) {
+    const newTypeMap = {};
+    for (const typeName in originalTypeMap) {
+        if (!typeName.startsWith('__')) {
+            const originalType = originalTypeMap[typeName];
+            if (!isObjectType(originalType) && !isInterfaceType(originalType)) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            const argumentMapper = getArgumentMapper(schemaMapper);
+            if (argumentMapper == null) {
+                newTypeMap[typeName] = originalType;
+                continue;
+            }
+            const config = originalType.toConfig();
+            const originalFieldConfigMap = config.fields;
+            const newFieldConfigMap = {};
+            for (const fieldName in originalFieldConfigMap) {
+                const originalFieldConfig = originalFieldConfigMap[fieldName];
+                const originalArgumentConfigMap = originalFieldConfig.args;
+                if (originalArgumentConfigMap == null) {
+                    newFieldConfigMap[fieldName] = originalFieldConfig;
+                    continue;
+                }
+                const argumentNames = Object.keys(originalArgumentConfigMap);
+                if (!argumentNames.length) {
+                    newFieldConfigMap[fieldName] = originalFieldConfig;
+                    continue;
+                }
+                const newArgumentConfigMap = {};
+                for (const argumentName of argumentNames) {
+                    const originalArgumentConfig = originalArgumentConfigMap[argumentName];
+                    const mappedArgument = argumentMapper(originalArgumentConfig, fieldName, typeName, schema);
+                    if (mappedArgument === undefined) {
+                        newArgumentConfigMap[argumentName] = originalArgumentConfig;
+                    }
+                    else if (Array.isArray(mappedArgument)) {
+                        const [newArgumentName, newArgumentConfig] = mappedArgument;
+                        newArgumentConfigMap[newArgumentName] = newArgumentConfig;
+                    }
+                    else if (mappedArgument !== null) {
+                        newArgumentConfigMap[argumentName] = mappedArgument;
+                    }
+                }
+                newFieldConfigMap[fieldName] = {
+                    ...originalFieldConfig,
+                    args: newArgumentConfigMap,
+                };
+            }
+            if (isObjectType(originalType)) {
+                newTypeMap[typeName] = new GraphQLObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                });
+            }
+            else if (isInterfaceType(originalType)) {
+                newTypeMap[typeName] = new GraphQLInterfaceType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                });
+            }
+            else {
+                newTypeMap[typeName] = new GraphQLInputObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                });
+            }
+        }
+    }
+    return newTypeMap;
+}
+function mapDirectives(originalDirectives, schema, schemaMapper) {
+    const directiveMapper = getDirectiveMapper(schemaMapper);
+    if (directiveMapper == null) {
+        return originalDirectives.slice();
+    }
+    const newDirectives = [];
+    for (const directive of originalDirectives) {
+        const mappedDirective = directiveMapper(directive, schema);
+        if (mappedDirective === undefined) {
+            newDirectives.push(directive);
+        }
+        else if (mappedDirective !== null) {
+            newDirectives.push(mappedDirective);
+        }
+    }
+    return newDirectives;
+}
+function getTypeSpecifiers(schema, typeName) {
+    var _a, _b, _c;
+    const type = schema.getType(typeName);
+    const specifiers = [MapperKind.TYPE];
+    if (isObjectType(type)) {
+        specifiers.push(MapperKind.COMPOSITE_TYPE, MapperKind.OBJECT_TYPE);
+        if (typeName === ((_a = schema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name)) {
+            specifiers.push(MapperKind.ROOT_OBJECT, MapperKind.QUERY);
+        }
+        else if (typeName === ((_b = schema.getMutationType()) === null || _b === void 0 ? void 0 : _b.name)) {
+            specifiers.push(MapperKind.ROOT_OBJECT, MapperKind.MUTATION);
+        }
+        else if (typeName === ((_c = schema.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name)) {
+            specifiers.push(MapperKind.ROOT_OBJECT, MapperKind.SUBSCRIPTION);
+        }
+    }
+    else if (isInputObjectType(type)) {
+        specifiers.push(MapperKind.INPUT_OBJECT_TYPE);
+    }
+    else if (isInterfaceType(type)) {
+        specifiers.push(MapperKind.COMPOSITE_TYPE, MapperKind.ABSTRACT_TYPE, MapperKind.INTERFACE_TYPE);
+    }
+    else if (isUnionType(type)) {
+        specifiers.push(MapperKind.COMPOSITE_TYPE, MapperKind.ABSTRACT_TYPE, MapperKind.UNION_TYPE);
+    }
+    else if (isEnumType(type)) {
+        specifiers.push(MapperKind.ENUM_TYPE);
+    }
+    else if (isScalarType(type)) {
+        specifiers.push(MapperKind.SCALAR_TYPE);
+    }
+    return specifiers;
+}
+function getTypeMapper(schema, schemaMapper, typeName) {
+    const specifiers = getTypeSpecifiers(schema, typeName);
+    let typeMapper;
+    const stack = [...specifiers];
+    while (!typeMapper && stack.length > 0) {
+        // It is safe to use the ! operator here as we check the length.
+        const next = stack.pop();
+        typeMapper = schemaMapper[next];
+    }
+    return typeMapper != null ? typeMapper : null;
+}
+function getFieldSpecifiers(schema, typeName) {
+    var _a, _b, _c;
+    const type = schema.getType(typeName);
+    const specifiers = [MapperKind.FIELD];
+    if (isObjectType(type)) {
+        specifiers.push(MapperKind.COMPOSITE_FIELD, MapperKind.OBJECT_FIELD);
+        if (typeName === ((_a = schema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name)) {
+            specifiers.push(MapperKind.ROOT_FIELD, MapperKind.QUERY_ROOT_FIELD);
+        }
+        else if (typeName === ((_b = schema.getMutationType()) === null || _b === void 0 ? void 0 : _b.name)) {
+            specifiers.push(MapperKind.ROOT_FIELD, MapperKind.MUTATION_ROOT_FIELD);
+        }
+        else if (typeName === ((_c = schema.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name)) {
+            specifiers.push(MapperKind.ROOT_FIELD, MapperKind.SUBSCRIPTION_ROOT_FIELD);
+        }
+    }
+    else if (isInterfaceType(type)) {
+        specifiers.push(MapperKind.COMPOSITE_FIELD, MapperKind.INTERFACE_FIELD);
+    }
+    else if (isInputObjectType(type)) {
+        specifiers.push(MapperKind.INPUT_OBJECT_FIELD);
+    }
+    return specifiers;
+}
+function getFieldMapper(schema, schemaMapper, typeName) {
+    const specifiers = getFieldSpecifiers(schema, typeName);
+    let fieldMapper;
+    const stack = [...specifiers];
+    while (!fieldMapper && stack.length > 0) {
+        // It is safe to use the ! operator here as we check the length.
+        const next = stack.pop();
+        // TODO: fix this as unknown cast
+        fieldMapper = schemaMapper[next];
+    }
+    return fieldMapper !== null && fieldMapper !== void 0 ? fieldMapper : null;
+}
+function getArgumentMapper(schemaMapper) {
+    const argumentMapper = schemaMapper[MapperKind.ARGUMENT];
+    return argumentMapper != null ? argumentMapper : null;
+}
+function getDirectiveMapper(schemaMapper) {
+    const directiveMapper = schemaMapper[MapperKind.DIRECTIVE];
+    return directiveMapper != null ? directiveMapper : null;
+}
+function getEnumValueMapper(schemaMapper) {
+    const enumValueMapper = schemaMapper[MapperKind.ENUM_VALUE];
+    return enumValueMapper != null ? enumValueMapper : null;
+}
+export function correctASTNodes(type) {
+    if (isObjectType(type)) {
+        const config = type.toConfig();
+        if (config.astNode != null) {
+            const fields = [];
+            for (const fieldName in config.fields) {
+                const fieldConfig = config.fields[fieldName];
+                if (fieldConfig.astNode != null) {
+                    fields.push(fieldConfig.astNode);
+                }
+            }
+            config.astNode = {
+                ...config.astNode,
+                kind: Kind.OBJECT_TYPE_DEFINITION,
+                fields,
+            };
+        }
+        if (config.extensionASTNodes != null) {
+            config.extensionASTNodes = config.extensionASTNodes.map(node => ({
+                ...node,
+                kind: Kind.OBJECT_TYPE_EXTENSION,
+                fields: undefined,
+            }));
+        }
+        return new GraphQLObjectType(config);
+    }
+    else if (isInterfaceType(type)) {
+        const config = type.toConfig();
+        if (config.astNode != null) {
+            const fields = [];
+            for (const fieldName in config.fields) {
+                const fieldConfig = config.fields[fieldName];
+                if (fieldConfig.astNode != null) {
+                    fields.push(fieldConfig.astNode);
+                }
+            }
+            config.astNode = {
+                ...config.astNode,
+                kind: Kind.INTERFACE_TYPE_DEFINITION,
+                fields,
+            };
+        }
+        if (config.extensionASTNodes != null) {
+            config.extensionASTNodes = config.extensionASTNodes.map(node => ({
+                ...node,
+                kind: Kind.INTERFACE_TYPE_EXTENSION,
+                fields: undefined,
+            }));
+        }
+        return new GraphQLInterfaceType(config);
+    }
+    else if (isInputObjectType(type)) {
+        const config = type.toConfig();
+        if (config.astNode != null) {
+            const fields = [];
+            for (const fieldName in config.fields) {
+                const fieldConfig = config.fields[fieldName];
+                if (fieldConfig.astNode != null) {
+                    fields.push(fieldConfig.astNode);
+                }
+            }
+            config.astNode = {
+                ...config.astNode,
+                kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+                fields,
+            };
+        }
+        if (config.extensionASTNodes != null) {
+            config.extensionASTNodes = config.extensionASTNodes.map(node => ({
+                ...node,
+                kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
+                fields: undefined,
+            }));
+        }
+        return new GraphQLInputObjectType(config);
+    }
+    else if (isEnumType(type)) {
+        const config = type.toConfig();
+        if (config.astNode != null) {
+            const values = [];
+            for (const enumKey in config.values) {
+                const enumValueConfig = config.values[enumKey];
+                if (enumValueConfig.astNode != null) {
+                    values.push(enumValueConfig.astNode);
+                }
+            }
+            config.astNode = {
+                ...config.astNode,
+                values,
+            };
+        }
+        if (config.extensionASTNodes != null) {
+            config.extensionASTNodes = config.extensionASTNodes.map(node => ({
+                ...node,
+                values: undefined,
+            }));
+        }
+        return new GraphQLEnumType(config);
+    }
+    else {
+        return type;
+    }
+}