@graphql-tools/wrap 8.4.21 → 8.5.0-alpha-b76ec274.0

package/esm/transforms/MapLeafValues.js

@@ -0,0 +1,108 @@
+import { visit, Kind, TypeInfo, visitWithTypeInfo, valueFromAST, isLeafType, } from 'graphql';
+import { visitResult, updateArgument, transformInputValue, createVariableNameGenerator, } from '@graphql-tools/utils';
+export default class MapLeafValues {
+    constructor(inputValueTransformer, outputValueTransformer) {
+        this.inputValueTransformer = inputValueTransformer;
+        this.outputValueTransformer = outputValueTransformer;
+        this.resultVisitorMap = Object.create(null);
+    }
+    _getTypeInfo() {
+        const typeInfo = this.typeInfo;
+        if (typeInfo === undefined) {
+            throw new Error(`The MapLeafValues transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return typeInfo;
+    }
+    _getOriginalWrappingSchema() {
+        const originalWrappingSchema = this.originalWrappingSchema;
+        if (originalWrappingSchema === undefined) {
+            throw new Error(`The MapLeafValues transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return originalWrappingSchema;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        this.originalWrappingSchema = originalWrappingSchema;
+        const typeMap = originalWrappingSchema.getTypeMap();
+        for (const typeName in typeMap) {
+            const type = typeMap[typeName];
+            if (!typeName.startsWith('__')) {
+                if (isLeafType(type)) {
+                    this.resultVisitorMap[typeName] = (value) => this.outputValueTransformer(typeName, value);
+                }
+            }
+        }
+        this.typeInfo = new TypeInfo(originalWrappingSchema);
+        return originalWrappingSchema;
+    }
+    transformRequest(originalRequest, _delegationContext, transformationContext) {
+        var _a;
+        const document = originalRequest.document;
+        const variableValues = (_a = originalRequest.variables) !== null && _a !== void 0 ? _a : {};
+        const operations = document.definitions.filter(def => def.kind === Kind.OPERATION_DEFINITION);
+        const fragments = document.definitions.filter(def => def.kind === Kind.FRAGMENT_DEFINITION);
+        const newOperations = this.transformOperations(operations, variableValues);
+        const transformedRequest = {
+            ...originalRequest,
+            document: {
+                ...document,
+                definitions: [...newOperations, ...fragments],
+            },
+            variables: variableValues,
+        };
+        transformationContext.transformedRequest = transformedRequest;
+        return transformedRequest;
+    }
+    transformResult(originalResult, _delegationContext, transformationContext) {
+        return visitResult(originalResult, transformationContext.transformedRequest, this._getOriginalWrappingSchema(), this.resultVisitorMap);
+    }
+    transformOperations(operations, variableValues) {
+        return operations.map((operation) => {
+            var _a;
+            const variableDefinitionMap = ((_a = operation.variableDefinitions) !== null && _a !== void 0 ? _a : []).reduce((prev, def) => ({
+                ...prev,
+                [def.variable.name.value]: def,
+            }), {});
+            const newOperation = visit(operation, visitWithTypeInfo(this._getTypeInfo(), {
+                [Kind.FIELD]: node => this.transformFieldNode(node, variableDefinitionMap, variableValues),
+            }));
+            return {
+                ...newOperation,
+                variableDefinitions: Object.values(variableDefinitionMap),
+            };
+        });
+    }
+    transformFieldNode(field, variableDefinitionMap, variableValues) {
+        const targetField = this._getTypeInfo().getFieldDef();
+        if (!targetField) {
+            return;
+        }
+        const generateVariableName = createVariableNameGenerator(variableDefinitionMap);
+        if (!targetField.name.startsWith('__')) {
+            const argumentNodes = field.arguments;
+            if (argumentNodes != null) {
+                const argumentNodeMap = argumentNodes.reduce((prev, argument) => ({
+                    ...prev,
+                    [argument.name.value]: argument,
+                }), Object.create(null));
+                for (const argument of targetField.args) {
+                    const argName = argument.name;
+                    const argType = argument.type;
+                    const argumentNode = argumentNodeMap[argName];
+                    const argValue = argumentNode === null || argumentNode === void 0 ? void 0 : argumentNode.value;
+                    let value;
+                    if (argValue != null) {
+                        value = valueFromAST(argValue, argType, variableValues);
+                    }
+                    updateArgument(argumentNodeMap, variableDefinitionMap, variableValues, argName, generateVariableName(argName), argType, transformInputValue(argType, value, (t, v) => {
+                        const newValue = this.inputValueTransformer(t.name, v);
+                        return newValue === undefined ? v : newValue;
+                    }));
+                }
+                return {
+                    ...field,
+                    arguments: Object.values(argumentNodeMap),
+                };
+            }
+        }
+    }
+}

package/esm/transforms/PruneSchema.js

@@ -0,0 +1,9 @@
+import { pruneSchema } from '@graphql-tools/utils';
+export default class PruneTypes {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return pruneSchema(originalWrappingSchema, this.options);
+    }
+}

package/esm/transforms/RemoveObjectFieldDeprecations.js

@@ -0,0 +1,21 @@
+import { valueMatchesCriteria } from '@graphql-tools/utils';
+import FilterObjectFieldDirectives from './FilterObjectFieldDirectives.js';
+import TransformObjectFields from './TransformObjectFields.js';
+export default class RemoveObjectFieldDeprecations {
+    constructor(reason) {
+        const args = { reason };
+        this.removeDirectives = new FilterObjectFieldDirectives((dirName, dirValue) => {
+            return !(dirName === 'deprecated' && valueMatchesCriteria(dirValue, args));
+        });
+        this.removeDeprecations = new TransformObjectFields((_typeName, _fieldName, fieldConfig) => {
+            if (fieldConfig.deprecationReason && valueMatchesCriteria(fieldConfig.deprecationReason, reason)) {
+                fieldConfig = { ...fieldConfig };
+                delete fieldConfig.deprecationReason;
+            }
+            return fieldConfig;
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.removeDeprecations.transformSchema(this.removeDirectives.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema), subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/RemoveObjectFieldDirectives.js

@@ -0,0 +1,12 @@
+import { valueMatchesCriteria } from '@graphql-tools/utils';
+import FilterObjectFieldDirectives from './FilterObjectFieldDirectives.js';
+export default class RemoveObjectFieldDirectives {
+    constructor(directiveName, args = {}) {
+        this.transformer = new FilterObjectFieldDirectives((dirName, dirValue) => {
+            return !(valueMatchesCriteria(dirName, directiveName) && valueMatchesCriteria(dirValue, args));
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/RemoveObjectFieldsWithDeprecation.js

@@ -0,0 +1,15 @@
+import { valueMatchesCriteria } from '@graphql-tools/utils';
+import FilterObjectFields from './FilterObjectFields.js';
+export default class RemoveObjectFieldsWithDeprecation {
+    constructor(reason) {
+        this.transformer = new FilterObjectFields((_typeName, _fieldName, fieldConfig) => {
+            if (fieldConfig.deprecationReason) {
+                return !valueMatchesCriteria(fieldConfig.deprecationReason, reason);
+            }
+            return true;
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/RemoveObjectFieldsWithDirective.js

@@ -0,0 +1,15 @@
+import { getDirectives, valueMatchesCriteria } from '@graphql-tools/utils';
+import FilterObjectFields from './FilterObjectFields.js';
+export default class RemoveObjectFieldsWithDirective {
+    constructor(directiveName, args = {}) {
+        this.directiveName = directiveName;
+        this.args = args;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const transformer = new FilterObjectFields((_typeName, _fieldName, fieldConfig) => {
+            const directives = getDirectives(originalWrappingSchema, fieldConfig);
+            return !directives.some(directive => valueMatchesCriteria(directive.name, this.directiveName) && valueMatchesCriteria(directive.args, this.args));
+        });
+        return transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/RenameInputObjectFields.js

@@ -0,0 +1,53 @@
+import { mapSchema, MapperKind } from '@graphql-tools/utils';
+import TransformInputObjectFields from './TransformInputObjectFields.js';
+export default class RenameInputObjectFields {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.transformer = new TransformInputObjectFields((typeName, inputFieldName, inputFieldConfig) => {
+            const newName = renamer(typeName, inputFieldName, inputFieldConfig);
+            if (newName !== undefined && newName !== inputFieldName) {
+                const value = renamer(typeName, inputFieldName, inputFieldConfig);
+                if (value != null) {
+                    return [value, inputFieldConfig];
+                }
+            }
+        }, (typeName, inputFieldName, inputFieldNode) => {
+            if (!(typeName in this.reverseMap)) {
+                return inputFieldNode;
+            }
+            const inputFieldNameMap = this.reverseMap[typeName];
+            if (!(inputFieldName in inputFieldNameMap)) {
+                return inputFieldNode;
+            }
+            return {
+                ...inputFieldNode,
+                name: {
+                    ...inputFieldNode.name,
+                    value: inputFieldNameMap[inputFieldName],
+                },
+            };
+        });
+        this.reverseMap = Object.create(null);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        mapSchema(originalWrappingSchema, {
+            [MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
+                const newName = this.renamer(typeName, fieldName, inputFieldConfig);
+                if (newName !== undefined && newName !== fieldName) {
+                    if (this.reverseMap[typeName] == null) {
+                        this.reverseMap[typeName] = Object.create(null);
+                    }
+                    this.reverseMap[typeName][newName] = fieldName;
+                }
+                return undefined;
+            },
+            [MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}

package/esm/transforms/RenameInterfaceFields.js

@@ -0,0 +1,15 @@
+import TransformInterfaceFields from './TransformInterfaceFields.js';
+export default class RenameInterfaceFields {
+    constructor(renamer) {
+        this.transformer = new TransformInterfaceFields((typeName, fieldName, fieldConfig) => [
+            renamer(typeName, fieldName, fieldConfig),
+            fieldConfig,
+        ]);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}

package/esm/transforms/RenameObjectFieldArguments.js

@@ -0,0 +1,68 @@
+import { mapSchema, MapperKind } from '@graphql-tools/utils';
+import TransformObjectFields from './TransformObjectFields.js';
+export default class RenameObjectFieldArguments {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.transformer = new TransformObjectFields((typeName, fieldName, fieldConfig) => {
+            const argsConfig = Object.fromEntries(Object.entries(fieldConfig.args || []).map(([argName, conf]) => {
+                const newName = renamer(typeName, fieldName, argName);
+                if (newName !== undefined && newName !== argName) {
+                    if (newName != null) {
+                        return [newName, conf];
+                    }
+                }
+                return [argName, conf];
+            }));
+            return [fieldName, { ...fieldConfig, args: argsConfig }];
+        }, (typeName, fieldName, inputFieldNode) => {
+            if (!(typeName in this.reverseMap)) {
+                return inputFieldNode;
+            }
+            if (!(fieldName in this.reverseMap[typeName])) {
+                return inputFieldNode;
+            }
+            const fieldNameMap = this.reverseMap[typeName][fieldName];
+            return {
+                ...inputFieldNode,
+                arguments: (inputFieldNode.arguments || []).map(argNode => {
+                    return argNode.name.value in fieldNameMap
+                        ? {
+                            ...argNode,
+                            name: {
+                                ...argNode.name,
+                                value: fieldNameMap[argNode.name.value],
+                            },
+                        }
+                        : argNode;
+                }),
+            };
+        });
+        this.reverseMap = Object.create(null);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        mapSchema(originalWrappingSchema, {
+            [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
+                Object.entries(fieldConfig.args || {}).forEach(([argName]) => {
+                    const newName = this.renamer(typeName, fieldName, argName);
+                    if (newName !== undefined && newName !== fieldName) {
+                        if (this.reverseMap[typeName] == null) {
+                            this.reverseMap[typeName] = Object.create(null);
+                        }
+                        if (this.reverseMap[typeName][fieldName] == null) {
+                            this.reverseMap[typeName][fieldName] = Object.create(null);
+                        }
+                        this.reverseMap[typeName][fieldName][newName] = argName;
+                    }
+                });
+                return undefined;
+            },
+            [MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}

package/esm/transforms/RenameObjectFields.js

@@ -0,0 +1,15 @@
+import TransformObjectFields from './TransformObjectFields.js';
+export default class RenameObjectFields {
+    constructor(renamer) {
+        this.transformer = new TransformObjectFields((typeName, fieldName, fieldConfig) => [
+            renamer(typeName, fieldName, fieldConfig),
+            fieldConfig,
+        ]);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}

package/esm/transforms/RenameRootFields.js

@@ -0,0 +1,12 @@
+import TransformRootFields from './TransformRootFields.js';
+export default class RenameRootFields {
+    constructor(renamer) {
+        this.transformer = new TransformRootFields((operation, fieldName, fieldConfig) => [renamer(operation, fieldName, fieldConfig), fieldConfig]);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}

package/esm/transforms/RenameRootTypes.js

@@ -0,0 +1,54 @@
+import { visit, Kind } from 'graphql';
+import { MapperKind, mapSchema, renameType, visitData } from '@graphql-tools/utils';
+export default class RenameRootTypes {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.map = Object.create(null);
+        this.reverseMap = Object.create(null);
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return mapSchema(originalWrappingSchema, {
+            [MapperKind.ROOT_OBJECT]: type => {
+                const oldName = type.name;
+                const newName = this.renamer(oldName);
+                if (newName !== undefined && newName !== oldName) {
+                    this.map[oldName] = newName;
+                    this.reverseMap[newName] = oldName;
+                    return renameType(type, newName);
+                }
+            },
+        });
+    }
+    transformRequest(originalRequest, _delegationContext, _transformationContext) {
+        const document = visit(originalRequest.document, {
+            [Kind.NAMED_TYPE]: (node) => {
+                const name = node.name.value;
+                if (name in this.reverseMap) {
+                    return {
+                        ...node,
+                        name: {
+                            kind: Kind.NAME,
+                            value: this.reverseMap[name],
+                        },
+                    };
+                }
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformResult(originalResult, _delegationContext, _transformationContext) {
+        return {
+            ...originalResult,
+            data: visitData(originalResult.data, object => {
+                const typeName = object === null || object === void 0 ? void 0 : object.__typename;
+                if (typeName != null && typeName in this.map) {
+                    object.__typename = this.map[typeName];
+                }
+                return object;
+            }),
+        };
+    }
+}

package/esm/transforms/RenameTypes.js

@@ -0,0 +1,66 @@
+import { Kind, isScalarType, isSpecifiedScalarType, visit, } from 'graphql';
+import { MapperKind, mapSchema, visitData, renameType, } from '@graphql-tools/utils';
+export default class RenameTypes {
+    constructor(renamer, options) {
+        this.renamer = renamer;
+        this.map = Object.create(null);
+        this.reverseMap = Object.create(null);
+        const { renameBuiltins = false, renameScalars = true } = options != null ? options : {};
+        this.renameBuiltins = renameBuiltins;
+        this.renameScalars = renameScalars;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return mapSchema(originalWrappingSchema, {
+            [MapperKind.TYPE]: (type) => {
+                if (isSpecifiedScalarType(type) && !this.renameBuiltins) {
+                    return undefined;
+                }
+                if (isScalarType(type) && !this.renameScalars) {
+                    return undefined;
+                }
+                const oldName = type.name;
+                const newName = this.renamer(oldName);
+                if (newName !== undefined && newName !== oldName) {
+                    this.map[oldName] = newName;
+                    this.reverseMap[newName] = oldName;
+                    return renameType(type, newName);
+                }
+            },
+            [MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+    }
+    transformRequest(originalRequest, _delegationContext, _transformationContext) {
+        const document = visit(originalRequest.document, {
+            [Kind.NAMED_TYPE]: (node) => {
+                const name = node.name.value;
+                if (name in this.reverseMap) {
+                    return {
+                        ...node,
+                        name: {
+                            kind: Kind.NAME,
+                            value: this.reverseMap[name],
+                        },
+                    };
+                }
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformResult(originalResult, _delegationContext, _transformationContext) {
+        return {
+            ...originalResult,
+            data: visitData(originalResult.data, object => {
+                const typeName = object === null || object === void 0 ? void 0 : object.__typename;
+                if (typeName != null && typeName in this.map) {
+                    object.__typename = this.map[typeName];
+                }
+                return object;
+            }),
+        };
+    }
+}

package/esm/transforms/TransformCompositeFields.js

@@ -0,0 +1,140 @@
+import { TypeInfo, visit, visitWithTypeInfo, Kind, } from 'graphql';
+import { MapperKind, mapSchema, visitData } from '@graphql-tools/utils';
+export default class TransformCompositeFields {
+    constructor(fieldTransformer, fieldNodeTransformer, dataTransformer, errorsTransformer) {
+        this.fieldTransformer = fieldTransformer;
+        this.fieldNodeTransformer = fieldNodeTransformer;
+        this.dataTransformer = dataTransformer;
+        this.errorsTransformer = errorsTransformer;
+        this.mapping = {};
+    }
+    _getTypeInfo() {
+        const typeInfo = this.typeInfo;
+        if (typeInfo === undefined) {
+            throw new Error(`The TransformCompositeFields transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return typeInfo;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        var _a;
+        this.transformedSchema = mapSchema(originalWrappingSchema, {
+            [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                const transformedField = this.fieldTransformer(typeName, fieldName, fieldConfig);
+                if (Array.isArray(transformedField)) {
+                    const newFieldName = transformedField[0];
+                    if (newFieldName !== fieldName) {
+                        if (!(typeName in this.mapping)) {
+                            this.mapping[typeName] = {};
+                        }
+                        this.mapping[typeName][newFieldName] = fieldName;
+                    }
+                }
+                return transformedField;
+            },
+        });
+        this.typeInfo = new TypeInfo(this.transformedSchema);
+        this.subscriptionTypeName = (_a = originalWrappingSchema.getSubscriptionType()) === null || _a === void 0 ? void 0 : _a.name;
+        return this.transformedSchema;
+    }
+    transformRequest(originalRequest, _delegationContext, transformationContext) {
+        const document = originalRequest.document;
+        return {
+            ...originalRequest,
+            document: this.transformDocument(document, transformationContext),
+        };
+    }
+    transformResult(result, _delegationContext, transformationContext) {
+        const dataTransformer = this.dataTransformer;
+        if (dataTransformer != null) {
+            result.data = visitData(result.data, value => dataTransformer(value, transformationContext));
+        }
+        if (this.errorsTransformer != null && Array.isArray(result.errors)) {
+            result.errors = this.errorsTransformer(result.errors, transformationContext);
+        }
+        return result;
+    }
+    transformDocument(document, transformationContext) {
+        const fragments = Object.create(null);
+        for (const def of document.definitions) {
+            if (def.kind === Kind.FRAGMENT_DEFINITION) {
+                fragments[def.name.value] = def;
+            }
+        }
+        return visit(document, visitWithTypeInfo(this._getTypeInfo(), {
+            [Kind.SELECTION_SET]: {
+                leave: node => this.transformSelectionSet(node, this._getTypeInfo(), fragments, transformationContext),
+            },
+        }));
+    }
+    transformSelectionSet(node, typeInfo, fragments, transformationContext) {
+        var _a, _b;
+        const parentType = typeInfo.getParentType();
+        if (parentType == null) {
+            return undefined;
+        }
+        const parentTypeName = parentType.name;
+        let newSelections = [];
+        for (const selection of node.selections) {
+            if (selection.kind !== Kind.FIELD) {
+                newSelections.push(selection);
+                continue;
+            }
+            const newName = selection.name.value;
+            // See https://github.com/ardatan/graphql-tools/issues/2282
+            if ((this.dataTransformer != null || this.errorsTransformer != null) &&
+                (this.subscriptionTypeName == null || parentTypeName !== this.subscriptionTypeName)) {
+                newSelections.push({
+                    kind: Kind.FIELD,
+                    name: {
+                        kind: Kind.NAME,
+                        value: '__typename',
+                    },
+                });
+            }
+            let transformedSelection;
+            if (this.fieldNodeTransformer == null) {
+                transformedSelection = selection;
+            }
+            else {
+                transformedSelection = this.fieldNodeTransformer(parentTypeName, newName, selection, fragments, transformationContext);
+                transformedSelection = transformedSelection === undefined ? selection : transformedSelection;
+            }
+            if (transformedSelection == null) {
+                continue;
+            }
+            else if (Array.isArray(transformedSelection)) {
+                newSelections = newSelections.concat(transformedSelection);
+                continue;
+            }
+            else if (transformedSelection.kind !== Kind.FIELD) {
+                newSelections.push(transformedSelection);
+                continue;
+            }
+            const typeMapping = this.mapping[parentTypeName];
+            if (typeMapping == null) {
+                newSelections.push(transformedSelection);
+                continue;
+            }
+            const oldName = this.mapping[parentTypeName][newName];
+            if (oldName == null) {
+                newSelections.push(transformedSelection);
+                continue;
+            }
+            newSelections.push({
+                ...transformedSelection,
+                name: {
+                    kind: Kind.NAME,
+                    value: oldName,
+                },
+                alias: {
+                    kind: Kind.NAME,
+                    value: (_b = (_a = transformedSelection.alias) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : newName,
+                },
+            });
+        }
+        return {
+            ...node,
+            selections: newSelections,
+        };
+    }
+}

package/esm/transforms/TransformEnumValues.js

@@ -0,0 +1,51 @@
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+import MapLeafValues from './MapLeafValues.js';
+export default class TransformEnumValues {
+    constructor(enumValueTransformer, inputValueTransformer, outputValueTransformer) {
+        this.enumValueTransformer = enumValueTransformer;
+        this.mapping = Object.create(null);
+        this.reverseMapping = Object.create(null);
+        this.transformer = new MapLeafValues(generateValueTransformer(inputValueTransformer, this.reverseMapping), generateValueTransformer(outputValueTransformer, this.mapping));
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const mappingSchema = this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+        this.transformedSchema = mapSchema(mappingSchema, {
+            [MapperKind.ENUM_VALUE]: (valueConfig, typeName, _schema, externalValue) => this.transformEnumValue(typeName, externalValue, valueConfig),
+        });
+        return this.transformedSchema;
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return this.transformer.transformResult(originalResult, delegationContext, transformationContext);
+    }
+    transformEnumValue(typeName, externalValue, enumValueConfig) {
+        const transformedEnumValue = this.enumValueTransformer(typeName, externalValue, enumValueConfig);
+        if (Array.isArray(transformedEnumValue)) {
+            const newExternalValue = transformedEnumValue[0];
+            if (newExternalValue !== externalValue) {
+                if (!(typeName in this.mapping)) {
+                    this.mapping[typeName] = Object.create(null);
+                    this.reverseMapping[typeName] = Object.create(null);
+                }
+                this.mapping[typeName][externalValue] = newExternalValue;
+                this.reverseMapping[typeName][newExternalValue] = externalValue;
+            }
+        }
+        return transformedEnumValue;
+    }
+}
+function mapEnumValues(typeName, value, mapping) {
+    var _a;
+    const newExternalValue = (_a = mapping[typeName]) === null || _a === void 0 ? void 0 : _a[value];
+    return newExternalValue != null ? newExternalValue : value;
+}
+function generateValueTransformer(valueTransformer, mapping) {
+    if (valueTransformer == null) {
+        return (typeName, value) => mapEnumValues(typeName, value, mapping);
+    }
+    else {
+        return (typeName, value) => mapEnumValues(typeName, valueTransformer(typeName, value), mapping);
+    }
+}