@envelop/testing 3.0.0-alpha-15b486f.0 → 3.0.0

package/index.mjs

@@ -1,942 +1,6 @@
-import { GraphQLSchema, Kind, isObjectType, isEnumType, GraphQLEnumType, isListType, GraphQLList, isNonNullType, GraphQLNonNull, isNamedType, isInterfaceType, isInputObjectType, GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType, isSpecifiedDirective, GraphQLDirective, isUnionType, GraphQLUnionType, isScalarType, isSpecifiedScalarType, GraphQLScalarType, isLeafType, GraphQLID, GraphQLBoolean, GraphQLString, GraphQLFloat, GraphQLInt, getNullableType, getOperationAST, GraphQLError, print } from 'graphql';
-import { envelop, useSchema } from '@envelop/core';
-import { isAsyncIterable } from '@envelop/types';
-
-const MAX_LINE_LENGTH = 80;
-let commentsRegistry = {};
-function printComment(comment) {
-    return '\n# ' + comment.replace(/\n/g, '\n# ');
-}
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * NOTE: ==> This file has been modified just to add comments to the printed AST
- * This is a temp measure, we will move to using the original non modified printer.js ASAP.
- */
-/**
- * Given maybeArray, print an empty string if it is null or empty, otherwise
- * print all items together separated by separator if provided
- */
-function join(maybeArray, separator) {
-    return maybeArray ? maybeArray.filter(x => x).join(separator || '') : '';
-}
-function hasMultilineItems(maybeArray) {
-    var _a;
-    return (_a = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some(str => str.includes('\n'))) !== null && _a !== void 0 ? _a : false;
-}
-function addDescription(cb) {
-    return (node, _key, _parent, path, ancestors) => {
-        var _a;
-        const keys = [];
-        const parent = path.reduce((prev, key) => {
-            if (['fields', 'arguments', 'values'].includes(key) && prev.name) {
-                keys.push(prev.name.value);
-            }
-            return prev[key];
-        }, ancestors[0]);
-        const key = [...keys, (_a = parent === null || parent === void 0 ? void 0 : parent.name) === null || _a === void 0 ? void 0 : _a.value].filter(Boolean).join('.');
-        const items = [];
-        if (node.kind.includes('Definition') && commentsRegistry[key]) {
-            items.push(...commentsRegistry[key]);
-        }
-        return join([...items.map(printComment), node.description, cb(node, _key, _parent, path, ancestors)], '\n');
-    };
-}
-function indent(maybeString) {
-    return maybeString && `  ${maybeString.replace(/\n/g, '\n  ')}`;
-}
-/**
- * Given array, print each item on its own line, wrapped in an
- * indented "{ }" block.
- */
-function block(array) {
-    return array && array.length !== 0 ? `{\n${indent(join(array, '\n'))}\n}` : '';
-}
-/**
- * If maybeString is not null or empty, then wrap with start and end, otherwise
- * print an empty string.
- */
-function wrap(start, maybeString, end) {
-    return maybeString ? start + maybeString + (end || '') : '';
-}
-/**
- * Print a block string in the indented block form by adding a leading and
- * trailing blank line. However, if a block string starts with whitespace and is
- * a single-line, adding a leading blank line would strip that whitespace.
- */
-function printBlockString(value, isDescription = false) {
-    const escaped = value.replace(/"""/g, '\\"""');
-    return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1
-        ? `"""${escaped.replace(/"$/, '"\n')}"""`
-        : `"""\n${isDescription ? escaped : indent(escaped)}\n"""`;
-}
-const printDocASTReducer = {
-    Name: { leave: node => node.value },
-    Variable: { leave: node => '$' + node.name },
-    // Document
-    Document: {
-        leave: node => join(node.definitions, '\n\n'),
-    },
-    OperationDefinition: {
-        leave: node => {
-            const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
-            const prefix = join([node.operation, join([node.name, varDefs]), join(node.directives, ' ')], ' ');
-            // the query short form.
-            return prefix + ' ' + node.selectionSet;
-        },
-    },
-    VariableDefinition: {
-        leave: ({ variable, type, defaultValue, directives }) => variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' ')),
-    },
-    SelectionSet: { leave: ({ selections }) => block(selections) },
-    Field: {
-        leave({ alias, name, arguments: args, directives, selectionSet }) {
-            const prefix = wrap('', alias, ': ') + name;
-            let argsLine = prefix + wrap('(', join(args, ', '), ')');
-            if (argsLine.length > MAX_LINE_LENGTH) {
-                argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
-            }
-            return join([argsLine, join(directives, ' '), selectionSet], ' ');
-        },
-    },
-    Argument: { leave: ({ name, value }) => name + ': ' + value },
-    // Fragments
-    FragmentSpread: {
-        leave: ({ name, directives }) => '...' + name + wrap(' ', join(directives, ' ')),
-    },
-    InlineFragment: {
-        leave: ({ typeCondition, directives, selectionSet }) => join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' '),
-    },
-    FragmentDefinition: {
-        leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => 
-        // Note: fragment variable definitions are experimental and may be changed
-        // or removed in the future.
-        `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +
-            `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +
-            selectionSet,
-    },
-    // Value
-    IntValue: { leave: ({ value }) => value },
-    FloatValue: { leave: ({ value }) => value },
-    StringValue: {
-        leave: ({ value, block: isBlockString }) => {
-            if (isBlockString) {
-                return printBlockString(value);
-            }
-            return JSON.stringify(value);
-        },
-    },
-    BooleanValue: { leave: ({ value }) => (value ? 'true' : 'false') },
-    NullValue: { leave: () => 'null' },
-    EnumValue: { leave: ({ value }) => value },
-    ListValue: { leave: ({ values }) => '[' + join(values, ', ') + ']' },
-    ObjectValue: { leave: ({ fields }) => '{' + join(fields, ', ') + '}' },
-    ObjectField: { leave: ({ name, value }) => name + ': ' + value },
-    // Directive
-    Directive: {
-        leave: ({ name, arguments: args }) => '@' + name + wrap('(', join(args, ', '), ')'),
-    },
-    // Type
-    NamedType: { leave: ({ name }) => name },
-    ListType: { leave: ({ type }) => '[' + type + ']' },
-    NonNullType: { leave: ({ type }) => type + '!' },
-    // Type System Definitions
-    SchemaDefinition: {
-        leave: ({ directives, operationTypes }) => join(['schema', join(directives, ' '), block(operationTypes)], ' '),
-    },
-    OperationTypeDefinition: {
-        leave: ({ operation, type }) => operation + ': ' + type,
-    },
-    ScalarTypeDefinition: {
-        leave: ({ name, directives }) => join(['scalar', name, join(directives, ' ')], ' '),
-    },
-    ObjectTypeDefinition: {
-        leave: ({ name, interfaces, directives, fields }) => join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    FieldDefinition: {
-        leave: ({ name, arguments: args, type, directives }) => name +
-            (hasMultilineItems(args)
-                ? wrap('(\n', indent(join(args, '\n')), '\n)')
-                : wrap('(', join(args, ', '), ')')) +
-            ': ' +
-            type +
-            wrap(' ', join(directives, ' ')),
-    },
-    InputValueDefinition: {
-        leave: ({ name, type, defaultValue, directives }) => join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
-    },
-    InterfaceTypeDefinition: {
-        leave: ({ name, interfaces, directives, fields }) => join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    UnionTypeDefinition: {
-        leave: ({ name, directives, types }) => join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
-    },
-    EnumTypeDefinition: {
-        leave: ({ name, directives, values }) => join(['enum', name, join(directives, ' '), block(values)], ' '),
-    },
-    EnumValueDefinition: {
-        leave: ({ name, directives }) => join([name, join(directives, ' ')], ' '),
-    },
-    InputObjectTypeDefinition: {
-        leave: ({ name, directives, fields }) => join(['input', name, join(directives, ' '), block(fields)], ' '),
-    },
-    DirectiveDefinition: {
-        leave: ({ name, arguments: args, repeatable, locations }) => 'directive @' +
-            name +
-            (hasMultilineItems(args)
-                ? wrap('(\n', indent(join(args, '\n')), '\n)')
-                : wrap('(', join(args, ', '), ')')) +
-            (repeatable ? ' repeatable' : '') +
-            ' on ' +
-            join(locations, ' | '),
-    },
-    SchemaExtension: {
-        leave: ({ directives, operationTypes }) => join(['extend schema', join(directives, ' '), block(operationTypes)], ' '),
-    },
-    ScalarTypeExtension: {
-        leave: ({ name, directives }) => join(['extend scalar', name, join(directives, ' ')], ' '),
-    },
-    ObjectTypeExtension: {
-        leave: ({ name, interfaces, directives, fields }) => join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    InterfaceTypeExtension: {
-        leave: ({ name, interfaces, directives, fields }) => join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    UnionTypeExtension: {
-        leave: ({ name, directives, types }) => join(['extend union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
-    },
-    EnumTypeExtension: {
-        leave: ({ name, directives, values }) => join(['extend enum', name, join(directives, ' '), block(values)], ' '),
-    },
-    InputObjectTypeExtension: {
-        leave: ({ name, directives, fields }) => join(['extend input', name, join(directives, ' '), block(fields)], ' '),
-    },
-};
-const printDocASTReducerWithComments = Object.keys(printDocASTReducer).reduce((prev, key) => ({
-    ...prev,
-    [key]: {
-        leave: addDescription(printDocASTReducer[key].leave),
-    },
-}), {});
-
-var MapperKind;
-(function (MapperKind) {
-    MapperKind["TYPE"] = "MapperKind.TYPE";
-    MapperKind["SCALAR_TYPE"] = "MapperKind.SCALAR_TYPE";
-    MapperKind["ENUM_TYPE"] = "MapperKind.ENUM_TYPE";
-    MapperKind["COMPOSITE_TYPE"] = "MapperKind.COMPOSITE_TYPE";
-    MapperKind["OBJECT_TYPE"] = "MapperKind.OBJECT_TYPE";
-    MapperKind["INPUT_OBJECT_TYPE"] = "MapperKind.INPUT_OBJECT_TYPE";
-    MapperKind["ABSTRACT_TYPE"] = "MapperKind.ABSTRACT_TYPE";
-    MapperKind["UNION_TYPE"] = "MapperKind.UNION_TYPE";
-    MapperKind["INTERFACE_TYPE"] = "MapperKind.INTERFACE_TYPE";
-    MapperKind["ROOT_OBJECT"] = "MapperKind.ROOT_OBJECT";
-    MapperKind["QUERY"] = "MapperKind.QUERY";
-    MapperKind["MUTATION"] = "MapperKind.MUTATION";
-    MapperKind["SUBSCRIPTION"] = "MapperKind.SUBSCRIPTION";
-    MapperKind["DIRECTIVE"] = "MapperKind.DIRECTIVE";
-    MapperKind["FIELD"] = "MapperKind.FIELD";
-    MapperKind["COMPOSITE_FIELD"] = "MapperKind.COMPOSITE_FIELD";
-    MapperKind["OBJECT_FIELD"] = "MapperKind.OBJECT_FIELD";
-    MapperKind["ROOT_FIELD"] = "MapperKind.ROOT_FIELD";
-    MapperKind["QUERY_ROOT_FIELD"] = "MapperKind.QUERY_ROOT_FIELD";
-    MapperKind["MUTATION_ROOT_FIELD"] = "MapperKind.MUTATION_ROOT_FIELD";
-    MapperKind["SUBSCRIPTION_ROOT_FIELD"] = "MapperKind.SUBSCRIPTION_ROOT_FIELD";
-    MapperKind["INTERFACE_FIELD"] = "MapperKind.INTERFACE_FIELD";
-    MapperKind["INPUT_OBJECT_FIELD"] = "MapperKind.INPUT_OBJECT_FIELD";
-    MapperKind["ARGUMENT"] = "MapperKind.ARGUMENT";
-    MapperKind["ENUM_VALUE"] = "MapperKind.ENUM_VALUE";
-})(MapperKind || (MapperKind = {}));
-
-function getObjectTypeFromTypeMap(typeMap, type) {
-    if (type) {
-        const maybeObjectType = typeMap[type.name];
-        if (isObjectType(maybeObjectType)) {
-            return maybeObjectType;
-        }
-    }
-}
-function isNamedStub(type) {
-    if ('getFields' in type) {
-        const fields = type.getFields();
-        // eslint-disable-next-line no-unreachable-loop
-        for (const fieldName in fields) {
-            const field = fields[fieldName];
-            return field.name === '_fake';
-        }
-    }
-    return false;
-}
-function getBuiltInForStub(type) {
-    switch (type.name) {
-        case GraphQLInt.name:
-            return GraphQLInt;
-        case GraphQLFloat.name:
-            return GraphQLFloat;
-        case GraphQLString.name:
-            return GraphQLString;
-        case GraphQLBoolean.name:
-            return GraphQLBoolean;
-        case GraphQLID.name:
-            return GraphQLID;
-        default:
-            return type;
-    }
-}
-
-function rewireTypes(originalTypeMap, directives) {
-    const referenceTypeMap = Object.create(null);
-    for (const typeName in originalTypeMap) {
-        referenceTypeMap[typeName] = originalTypeMap[typeName];
-    }
-    const newTypeMap = Object.create(null);
-    for (const typeName in referenceTypeMap) {
-        const namedType = referenceTypeMap[typeName];
-        if (namedType == null || typeName.startsWith('__')) {
-            continue;
-        }
-        const newName = namedType.name;
-        if (newName.startsWith('__')) {
-            continue;
-        }
-        if (newTypeMap[newName] != null) {
-            throw new Error(`Duplicate schema type name ${newName}`);
-        }
-        newTypeMap[newName] = namedType;
-    }
-    for (const typeName in newTypeMap) {
-        newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]);
-    }
-    const newDirectives = directives.map(directive => rewireDirective(directive));
-    return {
-        typeMap: newTypeMap,
-        directives: newDirectives,
-    };
-    function rewireDirective(directive) {
-        if (isSpecifiedDirective(directive)) {
-            return directive;
-        }
-        const directiveConfig = directive.toConfig();
-        directiveConfig.args = rewireArgs(directiveConfig.args);
-        return new GraphQLDirective(directiveConfig);
-    }
-    function rewireArgs(args) {
-        const rewiredArgs = {};
-        for (const argName in args) {
-            const arg = args[argName];
-            const rewiredArgType = rewireType(arg.type);
-            if (rewiredArgType != null) {
-                arg.type = rewiredArgType;
-                rewiredArgs[argName] = arg;
-            }
-        }
-        return rewiredArgs;
-    }
-    function rewireNamedType(type) {
-        if (isObjectType(type)) {
-            const config = type.toConfig();
-            const newConfig = {
-                ...config,
-                fields: () => rewireFields(config.fields),
-                interfaces: () => rewireNamedTypes(config.interfaces),
-            };
-            return new GraphQLObjectType(newConfig);
-        }
-        else if (isInterfaceType(type)) {
-            const config = type.toConfig();
-            const newConfig = {
-                ...config,
-                fields: () => rewireFields(config.fields),
-            };
-            if ('interfaces' in newConfig) {
-                newConfig.interfaces = () => rewireNamedTypes(config.interfaces);
-            }
-            return new GraphQLInterfaceType(newConfig);
-        }
-        else if (isUnionType(type)) {
-            const config = type.toConfig();
-            const newConfig = {
-                ...config,
-                types: () => rewireNamedTypes(config.types),
-            };
-            return new GraphQLUnionType(newConfig);
-        }
-        else if (isInputObjectType(type)) {
-            const config = type.toConfig();
-            const newConfig = {
-                ...config,
-                fields: () => rewireInputFields(config.fields),
-            };
-            return new GraphQLInputObjectType(newConfig);
-        }
-        else if (isEnumType(type)) {
-            const enumConfig = type.toConfig();
-            return new GraphQLEnumType(enumConfig);
-        }
-        else if (isScalarType(type)) {
-            if (isSpecifiedScalarType(type)) {
-                return type;
-            }
-            const scalarConfig = type.toConfig();
-            return new GraphQLScalarType(scalarConfig);
-        }
-        throw new Error(`Unexpected schema type: ${type}`);
-    }
-    function rewireFields(fields) {
-        const rewiredFields = {};
-        for (const fieldName in fields) {
-            const field = fields[fieldName];
-            const rewiredFieldType = rewireType(field.type);
-            if (rewiredFieldType != null && field.args) {
-                field.type = rewiredFieldType;
-                field.args = rewireArgs(field.args);
-                rewiredFields[fieldName] = field;
-            }
-        }
-        return rewiredFields;
-    }
-    function rewireInputFields(fields) {
-        const rewiredFields = {};
-        for (const fieldName in fields) {
-            const field = fields[fieldName];
-            const rewiredFieldType = rewireType(field.type);
-            if (rewiredFieldType != null) {
-                field.type = rewiredFieldType;
-                rewiredFields[fieldName] = field;
-            }
-        }
-        return rewiredFields;
-    }
-    function rewireNamedTypes(namedTypes) {
-        const rewiredTypes = [];
-        for (const namedType of namedTypes) {
-            const rewiredType = rewireType(namedType);
-            if (rewiredType != null) {
-                rewiredTypes.push(rewiredType);
-            }
-        }
-        return rewiredTypes;
-    }
-    function rewireType(type) {
-        if (isListType(type)) {
-            const rewiredType = rewireType(type.ofType);
-            return rewiredType != null ? new GraphQLList(rewiredType) : null;
-        }
-        else if (isNonNullType(type)) {
-            const rewiredType = rewireType(type.ofType);
-            return rewiredType != null ? new GraphQLNonNull(rewiredType) : null;
-        }
-        else if (isNamedType(type)) {
-            let rewiredType = referenceTypeMap[type.name];
-            if (rewiredType === undefined) {
-                rewiredType = isNamedStub(type) ? getBuiltInForStub(type) : rewireNamedType(type);
-                newTypeMap[rewiredType.name] = referenceTypeMap[type.name] = rewiredType;
-            }
-            return rewiredType != null ? newTypeMap[rewiredType.name] : null;
-        }
-        return null;
-    }
-}
-
-function transformInputValue(type, value, inputLeafValueTransformer = null, inputObjectValueTransformer = null) {
-    if (value == null) {
-        return value;
-    }
-    const nullableType = getNullableType(type);
-    if (isLeafType(nullableType)) {
-        return inputLeafValueTransformer != null ? inputLeafValueTransformer(nullableType, value) : value;
-    }
-    else if (isListType(nullableType)) {
-        return value.map((listMember) => transformInputValue(nullableType.ofType, listMember, inputLeafValueTransformer, inputObjectValueTransformer));
-    }
-    else if (isInputObjectType(nullableType)) {
-        const fields = nullableType.getFields();
-        const newValue = {};
-        for (const key in value) {
-            const field = fields[key];
-            if (field != null) {
-                newValue[key] = transformInputValue(field.type, value[key], inputLeafValueTransformer, inputObjectValueTransformer);
-            }
-        }
-        return inputObjectValueTransformer != null ? inputObjectValueTransformer(nullableType, newValue) : newValue;
-    }
-    // unreachable, no other possible return value
-}
-function serializeInputValue(type, value) {
-    return transformInputValue(type, value, (t, v) => t.serialize(v));
-}
-function parseInputValue(type, value) {
-    return transformInputValue(type, value, (t, v) => t.parseValue(v));
-}
-
-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;
-}
-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;
-    }
-}
-
-function isDocumentNode(object) {
-    return object && typeof object === 'object' && 'kind' in object && object.kind === Kind.DOCUMENT;
-}
+import { getOperationAST, GraphQLError, print } from 'graphql';
+import { envelop, useSchema, isAsyncIterable } from '@envelop/core';
+import { mapSchema, isDocumentNode } from '@graphql-tools/utils';
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 function createSpiedPlugin() {