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

package/cjs/transforms/RemoveObjectFieldDeprecations.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const FilterObjectFieldDirectives_js_1 = tslib_1.__importDefault(require("./FilterObjectFieldDirectives.js"));
+const TransformObjectFields_js_1 = tslib_1.__importDefault(require("./TransformObjectFields.js"));
+class RemoveObjectFieldDeprecations {
+    constructor(reason) {
+        const args = { reason };
+        this.removeDirectives = new FilterObjectFieldDirectives_js_1.default((dirName, dirValue) => {
+            return !(dirName === 'deprecated' && (0, utils_1.valueMatchesCriteria)(dirValue, args));
+        });
+        this.removeDeprecations = new TransformObjectFields_js_1.default((_typeName, _fieldName, fieldConfig) => {
+            if (fieldConfig.deprecationReason && (0, utils_1.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);
+    }
+}
+exports.default = RemoveObjectFieldDeprecations;

package/cjs/transforms/RemoveObjectFieldDirectives.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const FilterObjectFieldDirectives_js_1 = tslib_1.__importDefault(require("./FilterObjectFieldDirectives.js"));
+class RemoveObjectFieldDirectives {
+    constructor(directiveName, args = {}) {
+        this.transformer = new FilterObjectFieldDirectives_js_1.default((dirName, dirValue) => {
+            return !((0, utils_1.valueMatchesCriteria)(dirName, directiveName) && (0, utils_1.valueMatchesCriteria)(dirValue, args));
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = RemoveObjectFieldDirectives;

package/cjs/transforms/RemoveObjectFieldsWithDeprecation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const FilterObjectFields_js_1 = tslib_1.__importDefault(require("./FilterObjectFields.js"));
+class RemoveObjectFieldsWithDeprecation {
+    constructor(reason) {
+        this.transformer = new FilterObjectFields_js_1.default((_typeName, _fieldName, fieldConfig) => {
+            if (fieldConfig.deprecationReason) {
+                return !(0, utils_1.valueMatchesCriteria)(fieldConfig.deprecationReason, reason);
+            }
+            return true;
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = RemoveObjectFieldsWithDeprecation;

package/cjs/transforms/RemoveObjectFieldsWithDirective.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const FilterObjectFields_js_1 = tslib_1.__importDefault(require("./FilterObjectFields.js"));
+class RemoveObjectFieldsWithDirective {
+    constructor(directiveName, args = {}) {
+        this.directiveName = directiveName;
+        this.args = args;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const transformer = new FilterObjectFields_js_1.default((_typeName, _fieldName, fieldConfig) => {
+            const directives = (0, utils_1.getDirectives)(originalWrappingSchema, fieldConfig);
+            return !directives.some(directive => (0, utils_1.valueMatchesCriteria)(directive.name, this.directiveName) && (0, utils_1.valueMatchesCriteria)(directive.args, this.args));
+        });
+        return transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = RemoveObjectFieldsWithDirective;

package/cjs/transforms/RenameInputObjectFields.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const TransformInputObjectFields_js_1 = tslib_1.__importDefault(require("./TransformInputObjectFields.js"));
+class RenameInputObjectFields {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.transformer = new TransformInputObjectFields_js_1.default((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) {
+        (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.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;
+            },
+            [utils_1.MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}
+exports.default = RenameInputObjectFields;

package/cjs/transforms/RenameInterfaceFields.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformInterfaceFields_js_1 = tslib_1.__importDefault(require("./TransformInterfaceFields.js"));
+class RenameInterfaceFields {
+    constructor(renamer) {
+        this.transformer = new TransformInterfaceFields_js_1.default((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);
+    }
+}
+exports.default = RenameInterfaceFields;

package/cjs/transforms/RenameObjectFieldArguments.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const TransformObjectFields_js_1 = tslib_1.__importDefault(require("./TransformObjectFields.js"));
+class RenameObjectFieldArguments {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.transformer = new TransformObjectFields_js_1.default((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) {
+        (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.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;
+            },
+            [utils_1.MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}
+exports.default = RenameObjectFieldArguments;

package/cjs/transforms/RenameObjectFields.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformObjectFields_js_1 = tslib_1.__importDefault(require("./TransformObjectFields.js"));
+class RenameObjectFields {
+    constructor(renamer) {
+        this.transformer = new TransformObjectFields_js_1.default((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);
+    }
+}
+exports.default = RenameObjectFields;

package/cjs/transforms/RenameRootFields.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformRootFields_js_1 = tslib_1.__importDefault(require("./TransformRootFields.js"));
+class RenameRootFields {
+    constructor(renamer) {
+        this.transformer = new TransformRootFields_js_1.default((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);
+    }
+}
+exports.default = RenameRootFields;

package/cjs/transforms/RenameRootTypes.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+class RenameRootTypes {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.map = Object.create(null);
+        this.reverseMap = Object.create(null);
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.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 (0, utils_1.renameType)(type, newName);
+                }
+            },
+        });
+    }
+    transformRequest(originalRequest, _delegationContext, _transformationContext) {
+        const document = (0, graphql_1.visit)(originalRequest.document, {
+            [graphql_1.Kind.NAMED_TYPE]: (node) => {
+                const name = node.name.value;
+                if (name in this.reverseMap) {
+                    return {
+                        ...node,
+                        name: {
+                            kind: graphql_1.Kind.NAME,
+                            value: this.reverseMap[name],
+                        },
+                    };
+                }
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformResult(originalResult, _delegationContext, _transformationContext) {
+        return {
+            ...originalResult,
+            data: (0, utils_1.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;
+            }),
+        };
+    }
+}
+exports.default = RenameRootTypes;

package/cjs/transforms/RenameTypes.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+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 (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.MapperKind.TYPE]: (type) => {
+                if ((0, graphql_1.isSpecifiedScalarType)(type) && !this.renameBuiltins) {
+                    return undefined;
+                }
+                if ((0, graphql_1.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 (0, utils_1.renameType)(type, newName);
+                }
+            },
+            [utils_1.MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+    }
+    transformRequest(originalRequest, _delegationContext, _transformationContext) {
+        const document = (0, graphql_1.visit)(originalRequest.document, {
+            [graphql_1.Kind.NAMED_TYPE]: (node) => {
+                const name = node.name.value;
+                if (name in this.reverseMap) {
+                    return {
+                        ...node,
+                        name: {
+                            kind: graphql_1.Kind.NAME,
+                            value: this.reverseMap[name],
+                        },
+                    };
+                }
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformResult(originalResult, _delegationContext, _transformationContext) {
+        return {
+            ...originalResult,
+            data: (0, utils_1.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;
+            }),
+        };
+    }
+}
+exports.default = RenameTypes;

package/cjs/transforms/TransformCompositeFields.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+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 = (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.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 graphql_1.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 = (0, utils_1.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 === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                fragments[def.name.value] = def;
+            }
+        }
+        return (0, graphql_1.visit)(document, (0, graphql_1.visitWithTypeInfo)(this._getTypeInfo(), {
+            [graphql_1.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 !== graphql_1.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: graphql_1.Kind.FIELD,
+                    name: {
+                        kind: graphql_1.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 !== graphql_1.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: graphql_1.Kind.NAME,
+                    value: oldName,
+                },
+                alias: {
+                    kind: graphql_1.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,
+        };
+    }
+}
+exports.default = TransformCompositeFields;

package/cjs/transforms/TransformEnumValues.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const MapLeafValues_js_1 = tslib_1.__importDefault(require("./MapLeafValues.js"));
+class TransformEnumValues {
+    constructor(enumValueTransformer, inputValueTransformer, outputValueTransformer) {
+        this.enumValueTransformer = enumValueTransformer;
+        this.mapping = Object.create(null);
+        this.reverseMapping = Object.create(null);
+        this.transformer = new MapLeafValues_js_1.default(generateValueTransformer(inputValueTransformer, this.reverseMapping), generateValueTransformer(outputValueTransformer, this.mapping));
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const mappingSchema = this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+        this.transformedSchema = (0, utils_1.mapSchema)(mappingSchema, {
+            [utils_1.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;
+    }
+}
+exports.default = TransformEnumValues;
+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);
+    }
+}