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

package/cjs/generateProxyingResolvers.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCreateProxyingResolver = exports.generateProxyingResolvers = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const delegate_1 = require("@graphql-tools/delegate");
+function generateProxyingResolvers(subschemaConfig) {
+    var _a;
+    const targetSchema = subschemaConfig.schema;
+    const createProxyingResolver = (_a = subschemaConfig.createProxyingResolver) !== null && _a !== void 0 ? _a : defaultCreateProxyingResolver;
+    const transformedSchema = (0, delegate_1.applySchemaTransforms)(targetSchema, subschemaConfig);
+    const rootTypeMap = (0, utils_1.getRootTypeMap)(targetSchema);
+    const resolvers = {};
+    for (const [operation, rootType] of rootTypeMap.entries()) {
+        const typeName = rootType.name;
+        const fields = rootType.getFields();
+        resolvers[typeName] = {};
+        for (const fieldName in fields) {
+            const proxyingResolver = createProxyingResolver({
+                subschemaConfig,
+                transformedSchema,
+                operation,
+                fieldName,
+            });
+            const finalResolver = createPossiblyNestedProxyingResolver(subschemaConfig, proxyingResolver);
+            if (operation === 'subscription') {
+                resolvers[typeName][fieldName] = {
+                    subscribe: finalResolver,
+                    resolve: identical,
+                };
+            }
+            else {
+                resolvers[typeName][fieldName] = {
+                    resolve: finalResolver,
+                };
+            }
+        }
+    }
+    return resolvers;
+}
+exports.generateProxyingResolvers = generateProxyingResolvers;
+function identical(value) {
+    return value;
+}
+function createPossiblyNestedProxyingResolver(subschemaConfig, proxyingResolver) {
+    return function possiblyNestedProxyingResolver(parent, args, context, info) {
+        if (parent != null) {
+            const responseKey = (0, utils_1.getResponseKeyFromInfo)(info);
+            // Check to see if the parent contains a proxied result
+            if ((0, delegate_1.isExternalObject)(parent)) {
+                const unpathedErrors = (0, delegate_1.getUnpathedErrors)(parent);
+                const subschema = (0, delegate_1.getSubschema)(parent, responseKey);
+                // If there is a proxied result from this subschema, return it
+                // This can happen even for a root field when the root type ia
+                // also nested as a field within a different type.
+                if (subschemaConfig === subschema && parent[responseKey] !== undefined) {
+                    return (0, delegate_1.resolveExternalValue)(parent[responseKey], unpathedErrors, subschema, context, info);
+                }
+            }
+        }
+        return proxyingResolver(parent, args, context, info);
+    };
+}
+function defaultCreateProxyingResolver({ subschemaConfig, operation, transformedSchema, }) {
+    return function proxyingResolver(_parent, _args, context, info) {
+        return (0, delegate_1.delegateToSchema)({
+            schema: subschemaConfig,
+            operation,
+            context,
+            info,
+            transformedSchema,
+        });
+    };
+}
+exports.defaultCreateProxyingResolver = defaultCreateProxyingResolver;

package/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProxyingResolvers = exports.defaultCreateProxyingResolver = exports.wrapSchema = void 0;
+const tslib_1 = require("tslib");
+var wrapSchema_js_1 = require("./wrapSchema.js");
+Object.defineProperty(exports, "wrapSchema", { enumerable: true, get: function () { return wrapSchema_js_1.wrapSchema; } });
+var generateProxyingResolvers_js_1 = require("./generateProxyingResolvers.js");
+Object.defineProperty(exports, "defaultCreateProxyingResolver", { enumerable: true, get: function () { return generateProxyingResolvers_js_1.defaultCreateProxyingResolver; } });
+Object.defineProperty(exports, "generateProxyingResolvers", { enumerable: true, get: function () { return generateProxyingResolvers_js_1.generateProxyingResolvers; } });
+tslib_1.__exportStar(require("./transforms/index.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./introspect.js"), exports);

package/cjs/introspect.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.introspectSchema = void 0;
+const graphql_1 = require("graphql");
+const value_or_promise_1 = require("value-or-promise");
+const utils_1 = require("@graphql-tools/utils");
+function getSchemaFromIntrospection(introspectionResult, options) {
+    var _a;
+    if ((_a = introspectionResult === null || introspectionResult === void 0 ? void 0 : introspectionResult.data) === null || _a === void 0 ? void 0 : _a.__schema) {
+        return (0, graphql_1.buildClientSchema)(introspectionResult.data, options);
+    }
+    throw new Error('Could not obtain introspection result, received: ' + JSON.stringify(introspectionResult));
+}
+function introspectSchema(executor, context, options) {
+    const parsedIntrospectionQuery = (0, graphql_1.parse)((0, graphql_1.getIntrospectionQuery)(options), options);
+    return new value_or_promise_1.ValueOrPromise(() => executor({
+        document: parsedIntrospectionQuery,
+        context,
+    }))
+        .then(introspection => {
+        if ((0, utils_1.isAsyncIterable)(introspection)) {
+            const iterator = introspection[Symbol.asyncIterator]();
+            return iterator.next().then(({ value }) => value);
+        }
+        return introspection;
+    })
+        .then(introspection => getSchemaFromIntrospection(introspection, options))
+        .resolve();
+}
+exports.introspectSchema = introspectSchema;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/transforms/ExtractField.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+class ExtractField {
+    constructor({ from, to }) {
+        this.from = from;
+        this.to = to;
+    }
+    transformRequest(originalRequest, _delegationContext, _transformationContext) {
+        let fromSelection;
+        const ourPathFrom = JSON.stringify(this.from);
+        const ourPathTo = JSON.stringify(this.to);
+        let fieldPath = [];
+        (0, graphql_1.visit)(originalRequest.document, {
+            [graphql_1.Kind.FIELD]: {
+                enter: (node) => {
+                    fieldPath.push(node.name.value);
+                    if (ourPathFrom === JSON.stringify(fieldPath)) {
+                        fromSelection = node.selectionSet;
+                        return graphql_1.BREAK;
+                    }
+                },
+                leave: () => {
+                    fieldPath.pop();
+                },
+            },
+        });
+        fieldPath = [];
+        const document = (0, graphql_1.visit)(originalRequest.document, {
+            [graphql_1.Kind.FIELD]: {
+                enter: (node) => {
+                    fieldPath.push(node.name.value);
+                    if (ourPathTo === JSON.stringify(fieldPath) && fromSelection != null) {
+                        return {
+                            ...node,
+                            selectionSet: fromSelection,
+                        };
+                    }
+                },
+                leave: () => {
+                    fieldPath.pop();
+                },
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+}
+exports.default = ExtractField;

package/cjs/transforms/FilterInputObjectFields.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformInputObjectFields_js_1 = tslib_1.__importDefault(require("./TransformInputObjectFields.js"));
+class FilterInputObjectFields {
+    constructor(filter, inputObjectNodeTransformer) {
+        this.transformer = new TransformInputObjectFields_js_1.default((typeName, fieldName, inputFieldConfig) => filter(typeName, fieldName, inputFieldConfig) ? undefined : null, undefined, inputObjectNodeTransformer);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+}
+exports.default = FilterInputObjectFields;

package/cjs/transforms/FilterInterfaceFields.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformInterfaceFields_js_1 = tslib_1.__importDefault(require("./TransformInterfaceFields.js"));
+class FilterInterfaceFields {
+    constructor(filter) {
+        this.transformer = new TransformInterfaceFields_js_1.default((typeName, fieldName, fieldConfig) => filter(typeName, fieldName, fieldConfig) ? undefined : null);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = FilterInterfaceFields;

package/cjs/transforms/FilterObjectFieldDirectives.js

@@ -0,0 +1,33 @@
+"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 FilterObjectFieldDirectives {
+    constructor(filter) {
+        this.filter = filter;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const transformer = new TransformObjectFields_js_1.default((_typeName, _fieldName, fieldConfig) => {
+            var _a, _b, _c, _d;
+            const keepDirectives = (_c = (_b = (_a = fieldConfig.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.filter(dir => {
+                const directiveDef = originalWrappingSchema.getDirective(dir.name.value);
+                const directiveValue = directiveDef ? (0, utils_1.getArgumentValues)(directiveDef, dir) : undefined;
+                return this.filter(dir.name.value, directiveValue);
+            })) !== null && _c !== void 0 ? _c : [];
+            if (((_d = fieldConfig.astNode) === null || _d === void 0 ? void 0 : _d.directives) != null &&
+                keepDirectives.length !== fieldConfig.astNode.directives.length) {
+                fieldConfig = {
+                    ...fieldConfig,
+                    astNode: {
+                        ...fieldConfig.astNode,
+                        directives: keepDirectives,
+                    },
+                };
+                return fieldConfig;
+            }
+        });
+        return transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = FilterObjectFieldDirectives;

package/cjs/transforms/FilterObjectFields.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformObjectFields_js_1 = tslib_1.__importDefault(require("./TransformObjectFields.js"));
+class FilterObjectFields {
+    constructor(filter) {
+        this.transformer = new TransformObjectFields_js_1.default((typeName, fieldName, fieldConfig) => filter(typeName, fieldName, fieldConfig) ? undefined : null);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = FilterObjectFields;

package/cjs/transforms/FilterRootFields.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformRootFields_js_1 = tslib_1.__importDefault(require("./TransformRootFields.js"));
+class FilterRootFields {
+    constructor(filter) {
+        this.transformer = new TransformRootFields_js_1.default((operation, fieldName, fieldConfig) => {
+            if (filter(operation, fieldName, fieldConfig)) {
+                return undefined;
+            }
+            return null;
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}
+exports.default = FilterRootFields;

package/cjs/transforms/FilterTypes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@graphql-tools/utils");
+class FilterTypes {
+    constructor(filter) {
+        this.filter = filter;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.MapperKind.TYPE]: (type) => {
+                if (this.filter(type)) {
+                    return undefined;
+                }
+                return null;
+            },
+        });
+    }
+}
+exports.default = FilterTypes;

package/cjs/transforms/HoistField.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapValue = exports.renameFieldNode = exports.wrapFieldNode = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const delegate_1 = require("@graphql-tools/delegate");
+const generateProxyingResolvers_js_1 = require("../generateProxyingResolvers.js");
+const MapFields_js_1 = tslib_1.__importDefault(require("./MapFields.js"));
+class HoistField {
+    constructor(typeName, pathConfig, newFieldName, alias = '__gqtlw__') {
+        this.typeName = typeName;
+        this.newFieldName = newFieldName;
+        const path = pathConfig.map(segment => (typeof segment === 'string' ? segment : segment.fieldName));
+        this.argFilters = pathConfig.map((segment, index) => {
+            if (typeof segment === 'string' || segment.argFilter == null) {
+                return index === pathConfig.length - 1 ? () => true : () => false;
+            }
+            return segment.argFilter;
+        });
+        const pathToField = path.slice();
+        const oldFieldName = pathToField.pop();
+        if (oldFieldName == null) {
+            throw new Error(`Cannot hoist field to ${newFieldName} on type ${typeName}, no path provided.`);
+        }
+        this.oldFieldName = oldFieldName;
+        this.pathToField = pathToField;
+        const argLevels = Object.create(null);
+        this.transformer = new MapFields_js_1.default({
+            [typeName]: {
+                [newFieldName]: fieldNode => wrapFieldNode(renameFieldNode(fieldNode, oldFieldName), pathToField, alias, argLevels),
+            },
+        }, {
+            [typeName]: value => unwrapValue(value, alias),
+        }, errors => (errors != null ? unwrapErrors(errors, alias) : undefined));
+        this.argLevels = argLevels;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        var _a, _b, _c, _d;
+        const argsMap = Object.create(null);
+        const innerType = this.pathToField.reduce((acc, pathSegment, index) => {
+            const field = acc.getFields()[pathSegment];
+            for (const arg of field.args) {
+                if (this.argFilters[index](arg)) {
+                    argsMap[arg.name] = arg;
+                    this.argLevels[arg.name] = index;
+                }
+            }
+            return (0, graphql_1.getNullableType)(field.type);
+        }, originalWrappingSchema.getType(this.typeName));
+        let [newSchema, targetFieldConfigMap] = (0, utils_1.removeObjectFields)(originalWrappingSchema, innerType.name, fieldName => fieldName === this.oldFieldName);
+        const targetField = targetFieldConfigMap[this.oldFieldName];
+        let resolve;
+        if (transformedSchema) {
+            const hoistingToRootField = this.typeName === ((_a = originalWrappingSchema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name) ||
+                this.typeName === ((_b = originalWrappingSchema.getMutationType()) === null || _b === void 0 ? void 0 : _b.name);
+            if (hoistingToRootField) {
+                const targetSchema = subschemaConfig.schema;
+                const operation = this.typeName === ((_c = targetSchema.getQueryType()) === null || _c === void 0 ? void 0 : _c.name) ? 'query' : 'mutation';
+                const createProxyingResolver = (_d = subschemaConfig.createProxyingResolver) !== null && _d !== void 0 ? _d : generateProxyingResolvers_js_1.defaultCreateProxyingResolver;
+                resolve = createProxyingResolver({
+                    subschemaConfig,
+                    transformedSchema,
+                    operation: operation,
+                    fieldName: this.newFieldName,
+                });
+            }
+            else {
+                resolve = delegate_1.defaultMergedResolver;
+            }
+        }
+        const newTargetField = {
+            ...targetField,
+            resolve: resolve,
+        };
+        const level = this.pathToField.length;
+        const args = targetField.args;
+        if (args != null) {
+            for (const argName in args) {
+                const argConfig = args[argName];
+                if (argConfig == null) {
+                    continue;
+                }
+                const arg = {
+                    ...argConfig,
+                    name: argName,
+                    description: argConfig.description,
+                    defaultValue: argConfig.defaultValue,
+                    extensions: argConfig.extensions,
+                    astNode: argConfig.astNode,
+                };
+                if (this.argFilters[level](arg)) {
+                    argsMap[argName] = arg;
+                    this.argLevels[arg.name] = level;
+                }
+            }
+        }
+        newTargetField.args = argsMap;
+        newSchema = (0, utils_1.appendObjectFields)(newSchema, this.typeName, {
+            [this.newFieldName]: newTargetField,
+        });
+        return this.transformer.transformSchema(newSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return this.transformer.transformResult(originalResult, delegationContext, transformationContext);
+    }
+}
+exports.default = HoistField;
+function wrapFieldNode(fieldNode, path, alias, argLevels) {
+    return path.reduceRight((acc, fieldName, index) => ({
+        kind: graphql_1.Kind.FIELD,
+        alias: {
+            kind: graphql_1.Kind.NAME,
+            value: alias,
+        },
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: fieldName,
+        },
+        selectionSet: {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: [acc],
+        },
+        arguments: fieldNode.arguments != null
+            ? fieldNode.arguments.filter(arg => argLevels[arg.name.value] === index)
+            : undefined,
+    }), {
+        ...fieldNode,
+        arguments: fieldNode.arguments != null
+            ? fieldNode.arguments.filter(arg => argLevels[arg.name.value] === path.length)
+            : undefined,
+    });
+}
+exports.wrapFieldNode = wrapFieldNode;
+function renameFieldNode(fieldNode, name) {
+    return {
+        ...fieldNode,
+        alias: {
+            kind: graphql_1.Kind.NAME,
+            value: fieldNode.alias != null ? fieldNode.alias.value : fieldNode.name.value,
+        },
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: name,
+        },
+    };
+}
+exports.renameFieldNode = renameFieldNode;
+function unwrapValue(originalValue, alias) {
+    let newValue = originalValue;
+    let object = newValue[alias];
+    while (object != null) {
+        newValue = object;
+        object = newValue[alias];
+    }
+    delete originalValue[alias];
+    Object.assign(originalValue, newValue);
+    return originalValue;
+}
+exports.unwrapValue = unwrapValue;
+function unwrapErrors(errors, alias) {
+    if (errors === undefined) {
+        return undefined;
+    }
+    return errors.map(error => {
+        const originalPath = error.path;
+        if (originalPath == null) {
+            return error;
+        }
+        const newPath = originalPath.filter(pathSegment => pathSegment !== alias);
+        return (0, utils_1.relocatedError)(error, newPath);
+    });
+}

package/cjs/transforms/MapFields.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformCompositeFields_js_1 = tslib_1.__importDefault(require("./TransformCompositeFields.js"));
+class MapFields {
+    constructor(fieldNodeTransformerMap, objectValueTransformerMap, errorsTransformer) {
+        this.fieldNodeTransformerMap = fieldNodeTransformerMap;
+        this.objectValueTransformerMap = objectValueTransformerMap;
+        this.errorsTransformer = errorsTransformer;
+    }
+    _getTransformer() {
+        const transformer = this.transformer;
+        if (transformer === undefined) {
+            throw new Error(`The MapFields transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return transformer;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        var _a;
+        const subscriptionTypeName = (_a = originalWrappingSchema.getSubscriptionType()) === null || _a === void 0 ? void 0 : _a.name;
+        const objectValueTransformerMap = this.objectValueTransformerMap;
+        this.transformer = new TransformCompositeFields_js_1.default(() => undefined, (typeName, fieldName, fieldNode, fragments, transformationContext) => {
+            const typeTransformers = this.fieldNodeTransformerMap[typeName];
+            if (typeTransformers == null) {
+                return undefined;
+            }
+            const fieldNodeTransformer = typeTransformers[fieldName];
+            if (fieldNodeTransformer == null) {
+                return undefined;
+            }
+            return fieldNodeTransformer(fieldNode, fragments, transformationContext);
+        }, objectValueTransformerMap != null
+            ? (data, transformationContext) => {
+                if (data == null) {
+                    return data;
+                }
+                let typeName = data.__typename;
+                if (typeName == null) {
+                    // see https://github.com/ardatan/graphql-tools/issues/2282
+                    typeName = subscriptionTypeName;
+                    if (typeName == null) {
+                        return data;
+                    }
+                }
+                const transformer = objectValueTransformerMap[typeName];
+                if (transformer == null) {
+                    return data;
+                }
+                return transformer(data, transformationContext);
+            }
+            : undefined, this.errorsTransformer != null ? this.errorsTransformer : undefined);
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return this._getTransformer().transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return this._getTransformer().transformResult(originalResult, delegationContext, transformationContext);
+    }
+}
+exports.default = MapFields;

package/cjs/transforms/MapLeafValues.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+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 ((0, graphql_1.isLeafType)(type)) {
+                    this.resultVisitorMap[typeName] = (value) => this.outputValueTransformer(typeName, value);
+                }
+            }
+        }
+        this.typeInfo = new graphql_1.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 === graphql_1.Kind.OPERATION_DEFINITION);
+        const fragments = document.definitions.filter(def => def.kind === graphql_1.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 (0, utils_1.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 = (0, graphql_1.visit)(operation, (0, graphql_1.visitWithTypeInfo)(this._getTypeInfo(), {
+                [graphql_1.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 = (0, utils_1.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 = (0, graphql_1.valueFromAST)(argValue, argType, variableValues);
+                    }
+                    (0, utils_1.updateArgument)(argumentNodeMap, variableDefinitionMap, variableValues, argName, generateVariableName(argName), argType, (0, utils_1.transformInputValue)(argType, value, (t, v) => {
+                        const newValue = this.inputValueTransformer(t.name, v);
+                        return newValue === undefined ? v : newValue;
+                    }));
+                }
+                return {
+                    ...field,
+                    arguments: Object.values(argumentNodeMap),
+                };
+            }
+        }
+    }
+}
+exports.default = MapLeafValues;

package/cjs/transforms/PruneSchema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@graphql-tools/utils");
+class PruneTypes {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return (0, utils_1.pruneSchema)(originalWrappingSchema, this.options);
+    }
+}
+exports.default = PruneTypes;