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

package/cjs/transforms/TransformInputObjectFields.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+class TransformInputObjectFields {
+    constructor(inputFieldTransformer, inputFieldNodeTransformer, inputObjectNodeTransformer) {
+        this.inputFieldTransformer = inputFieldTransformer;
+        this.inputFieldNodeTransformer = inputFieldNodeTransformer;
+        this.inputObjectNodeTransformer = inputObjectNodeTransformer;
+        this.mapping = {};
+    }
+    _getTransformedSchema() {
+        const transformedSchema = this.transformedSchema;
+        if (transformedSchema === undefined) {
+            throw new Error(`The TransformInputObjectFields transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return transformedSchema;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        this.transformedSchema = (0, utils_1.mapSchema)(originalWrappingSchema, {
+            [utils_1.MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
+                const transformedInputField = this.inputFieldTransformer(typeName, fieldName, inputFieldConfig);
+                if (Array.isArray(transformedInputField)) {
+                    const newFieldName = transformedInputField[0];
+                    if (newFieldName !== fieldName) {
+                        if (!(typeName in this.mapping)) {
+                            this.mapping[typeName] = {};
+                        }
+                        this.mapping[typeName][newFieldName] = fieldName;
+                    }
+                }
+                return transformedInputField;
+            },
+        });
+        return this.transformedSchema;
+    }
+    transformRequest(originalRequest, delegationContext, _transformationContext) {
+        var _a;
+        const variableValues = (_a = originalRequest.variables) !== null && _a !== void 0 ? _a : {};
+        const fragments = Object.create(null);
+        const operations = [];
+        for (const def of originalRequest.document.definitions) {
+            if (def.kind === graphql_1.Kind.OPERATION_DEFINITION) {
+                operations.push(def);
+            }
+            else if (def.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                fragments[def.name.value] = def;
+            }
+        }
+        for (const def of operations) {
+            const variableDefs = def.variableDefinitions;
+            if (variableDefs != null) {
+                for (const variableDef of variableDefs) {
+                    const varName = variableDef.variable.name.value;
+                    // Cast to NamedTypeNode required until upcomming graphql releases will have TypeNode paramter
+                    const varType = (0, graphql_1.typeFromAST)(delegationContext.transformedSchema, variableDef.type);
+                    if (!(0, graphql_1.isInputType)(varType)) {
+                        continue;
+                    }
+                    variableValues[varName] = (0, utils_1.transformInputValue)(varType, variableValues[varName], undefined, (type, originalValue) => {
+                        var _a;
+                        const newValue = Object.create(null);
+                        const fields = type.getFields();
+                        for (const key in originalValue) {
+                            const field = fields[key];
+                            if (field != null) {
+                                const newFieldName = (_a = this.mapping[type.name]) === null || _a === void 0 ? void 0 : _a[field.name];
+                                if (newFieldName != null) {
+                                    newValue[newFieldName] = originalValue[field.name];
+                                }
+                                else {
+                                    newValue[field.name] = originalValue[field.name];
+                                }
+                            }
+                        }
+                        return newValue;
+                    });
+                }
+            }
+        }
+        for (const def of originalRequest.document.definitions.filter(def => def.kind === graphql_1.Kind.FRAGMENT_DEFINITION)) {
+            fragments[def.name.value] = def;
+        }
+        const document = this.transformDocument(originalRequest.document, this.mapping, this.inputFieldNodeTransformer, this.inputObjectNodeTransformer, originalRequest, delegationContext);
+        return {
+            ...originalRequest,
+            document,
+            variables: variableValues,
+        };
+    }
+    transformDocument(document, mapping, inputFieldNodeTransformer, inputObjectNodeTransformer, request, delegationContext) {
+        const typeInfo = new graphql_1.TypeInfo(this._getTransformedSchema());
+        const newDocument = (0, graphql_1.visit)(document, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+            [graphql_1.Kind.OBJECT]: {
+                leave: (node) => {
+                    // The casting is kind of legit here as we are in a visitor
+                    const parentType = typeInfo.getInputType();
+                    if (parentType != null) {
+                        const parentTypeName = parentType.name;
+                        const newInputFields = [];
+                        for (const inputField of node.fields) {
+                            const newName = inputField.name.value;
+                            const transformedInputField = inputFieldNodeTransformer != null
+                                ? inputFieldNodeTransformer(parentTypeName, newName, inputField, request, delegationContext)
+                                : inputField;
+                            if (Array.isArray(transformedInputField)) {
+                                for (const individualTransformedInputField of transformedInputField) {
+                                    const typeMapping = mapping[parentTypeName];
+                                    if (typeMapping == null) {
+                                        newInputFields.push(individualTransformedInputField);
+                                        continue;
+                                    }
+                                    const oldName = typeMapping[newName];
+                                    if (oldName == null) {
+                                        newInputFields.push(individualTransformedInputField);
+                                        continue;
+                                    }
+                                    newInputFields.push({
+                                        ...individualTransformedInputField,
+                                        name: {
+                                            ...individualTransformedInputField.name,
+                                            value: oldName,
+                                        },
+                                    });
+                                }
+                                continue;
+                            }
+                            const typeMapping = mapping[parentTypeName];
+                            if (typeMapping == null) {
+                                newInputFields.push(transformedInputField);
+                                continue;
+                            }
+                            const oldName = typeMapping[newName];
+                            if (oldName == null) {
+                                newInputFields.push(transformedInputField);
+                                continue;
+                            }
+                            newInputFields.push({
+                                ...transformedInputField,
+                                name: {
+                                    ...transformedInputField.name,
+                                    value: oldName,
+                                },
+                            });
+                        }
+                        const newNode = {
+                            ...node,
+                            fields: newInputFields,
+                        };
+                        return inputObjectNodeTransformer != null
+                            ? inputObjectNodeTransformer(parentTypeName, newNode, request, delegationContext)
+                            : newNode;
+                    }
+                },
+            },
+        }));
+        return newDocument;
+    }
+}
+exports.default = TransformInputObjectFields;

package/cjs/transforms/TransformInterfaceFields.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const TransformCompositeFields_js_1 = tslib_1.__importDefault(require("./TransformCompositeFields.js"));
+class TransformInterfaceFields {
+    constructor(interfaceFieldTransformer, fieldNodeTransformer) {
+        this.interfaceFieldTransformer = interfaceFieldTransformer;
+        this.fieldNodeTransformer = fieldNodeTransformer;
+    }
+    _getTransformer() {
+        const transformer = this.transformer;
+        if (transformer === undefined) {
+            throw new Error(`The TransformInterfaceFields transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return transformer;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const compositeToObjectFieldTransformer = (typeName, fieldName, fieldConfig) => {
+            if ((0, graphql_1.isInterfaceType)(originalWrappingSchema.getType(typeName))) {
+                return this.interfaceFieldTransformer(typeName, fieldName, fieldConfig);
+            }
+            return undefined;
+        };
+        this.transformer = new TransformCompositeFields_js_1.default(compositeToObjectFieldTransformer, this.fieldNodeTransformer);
+        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 = TransformInterfaceFields;

package/cjs/transforms/TransformObjectFields.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const TransformCompositeFields_js_1 = tslib_1.__importDefault(require("./TransformCompositeFields.js"));
+class TransformObjectFields {
+    constructor(objectFieldTransformer, fieldNodeTransformer) {
+        this.objectFieldTransformer = objectFieldTransformer;
+        this.fieldNodeTransformer = fieldNodeTransformer;
+    }
+    _getTransformer() {
+        const transformer = this.transformer;
+        if (transformer === undefined) {
+            throw new Error(`The TransformObjectFields transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return transformer;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const compositeToObjectFieldTransformer = (typeName, fieldName, fieldConfig) => {
+            if ((0, graphql_1.isObjectType)(originalWrappingSchema.getType(typeName))) {
+                return this.objectFieldTransformer(typeName, fieldName, fieldConfig);
+            }
+            return undefined;
+        };
+        this.transformer = new TransformCompositeFields_js_1.default(compositeToObjectFieldTransformer, this.fieldNodeTransformer);
+        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 = TransformObjectFields;

package/cjs/transforms/TransformQuery.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+class TransformQuery {
+    constructor({ path, queryTransformer, resultTransformer = result => result, errorPathTransformer = errorPath => [...errorPath], fragments = {}, }) {
+        this.path = path;
+        this.queryTransformer = queryTransformer;
+        this.resultTransformer = resultTransformer;
+        this.errorPathTransformer = errorPathTransformer;
+        this.fragments = fragments;
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        const pathLength = this.path.length;
+        let index = 0;
+        const document = (0, graphql_1.visit)(originalRequest.document, {
+            [graphql_1.Kind.FIELD]: {
+                enter: node => {
+                    if (index === pathLength || node.name.value !== this.path[index]) {
+                        return false;
+                    }
+                    index++;
+                    if (index === pathLength) {
+                        const selectionSet = this.queryTransformer(node.selectionSet, this.fragments, delegationContext, transformationContext);
+                        return {
+                            ...node,
+                            selectionSet,
+                        };
+                    }
+                },
+                leave: () => {
+                    index--;
+                },
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        const data = this.transformData(originalResult.data, delegationContext, transformationContext);
+        const errors = originalResult.errors;
+        return {
+            data,
+            errors: errors != null ? this.transformErrors(errors) : undefined,
+        };
+    }
+    transformData(data, delegationContext, transformationContext) {
+        const leafIndex = this.path.length - 1;
+        let index = 0;
+        let newData = data;
+        if (newData) {
+            let next = this.path[index];
+            while (index < leafIndex) {
+                if (data[next]) {
+                    newData = newData[next];
+                }
+                else {
+                    break;
+                }
+                index++;
+                next = this.path[index];
+            }
+            newData[next] = this.resultTransformer(newData[next], delegationContext, transformationContext);
+        }
+        return data;
+    }
+    transformErrors(errors) {
+        return errors.map(error => {
+            const path = error.path;
+            if (path == null) {
+                return error;
+            }
+            let match = true;
+            let index = 0;
+            while (index < this.path.length) {
+                if (path[index] !== this.path[index]) {
+                    match = false;
+                    break;
+                }
+                index++;
+            }
+            const newPath = match ? path.slice(0, index).concat(this.errorPathTransformer(path.slice(index))) : path;
+            return (0, utils_1.relocatedError)(error, newPath);
+        });
+    }
+}
+exports.default = TransformQuery;

package/cjs/transforms/TransformRootFields.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const TransformObjectFields_js_1 = tslib_1.__importDefault(require("./TransformObjectFields.js"));
+class TransformRootFields {
+    constructor(rootFieldTransformer, fieldNodeTransformer) {
+        this.rootFieldTransformer = rootFieldTransformer;
+        this.fieldNodeTransformer = fieldNodeTransformer;
+    }
+    _getTransformer() {
+        const transformer = this.transformer;
+        if (transformer === undefined) {
+            throw new Error(`The TransformRootFields transform's  "transformRequest" and "transformResult" methods cannot be used without first calling "transformSchema".`);
+        }
+        return transformer;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const rootToObjectFieldTransformer = (typeName, fieldName, fieldConfig) => {
+            var _a, _b, _c;
+            if (typeName === ((_a = originalWrappingSchema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name)) {
+                return this.rootFieldTransformer('Query', fieldName, fieldConfig);
+            }
+            if (typeName === ((_b = originalWrappingSchema.getMutationType()) === null || _b === void 0 ? void 0 : _b.name)) {
+                return this.rootFieldTransformer('Mutation', fieldName, fieldConfig);
+            }
+            if (typeName === ((_c = originalWrappingSchema.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name)) {
+                return this.rootFieldTransformer('Subscription', fieldName, fieldConfig);
+            }
+            return undefined;
+        };
+        this.transformer = new TransformObjectFields_js_1.default(rootToObjectFieldTransformer, this.fieldNodeTransformer);
+        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 = TransformRootFields;

package/cjs/transforms/WrapFields.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dehoistValue = 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 MapFields_js_1 = tslib_1.__importDefault(require("./MapFields.js"));
+const generateProxyingResolvers_js_1 = require("../generateProxyingResolvers.js");
+class WrapFields {
+    constructor(outerTypeName, wrappingFieldNames, wrappingTypeNames, fieldNames, prefix = 'gqtld') {
+        this.outerTypeName = outerTypeName;
+        this.wrappingFieldNames = wrappingFieldNames;
+        this.wrappingTypeNames = wrappingTypeNames;
+        this.numWraps = wrappingFieldNames.length;
+        this.fieldNames = fieldNames;
+        const remainingWrappingFieldNames = this.wrappingFieldNames.slice();
+        const outerMostWrappingFieldName = remainingWrappingFieldNames.shift();
+        if (outerMostWrappingFieldName == null) {
+            throw new Error(`Cannot wrap fields, no wrapping field name provided.`);
+        }
+        this.transformer = new MapFields_js_1.default({
+            [outerTypeName]: {
+                [outerMostWrappingFieldName]: (fieldNode, fragments, transformationContext) => hoistFieldNodes({
+                    fieldNode,
+                    path: remainingWrappingFieldNames,
+                    fieldNames,
+                    fragments,
+                    transformationContext: transformationContext,
+                    prefix,
+                }),
+            },
+        }, {
+            [outerTypeName]: (value, context) => dehoistValue(value, context),
+        }, (errors, context) => dehoistErrors(errors, context));
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        var _a, _b, _c, _d;
+        const fieldNames = this.fieldNames;
+        const targetFieldConfigMap = (0, utils_1.selectObjectFields)(originalWrappingSchema, this.outerTypeName, !fieldNames ? () => true : fieldName => fieldNames.includes(fieldName));
+        const newTargetFieldConfigMap = Object.create(null);
+        for (const fieldName in targetFieldConfigMap) {
+            const field = targetFieldConfigMap[fieldName];
+            const newField = {
+                ...field,
+                resolve: delegate_1.defaultMergedResolver,
+            };
+            newTargetFieldConfigMap[fieldName] = newField;
+        }
+        let wrapIndex = this.numWraps - 1;
+        let wrappingTypeName = this.wrappingTypeNames[wrapIndex];
+        let wrappingFieldName = this.wrappingFieldNames[wrapIndex];
+        let newSchema = (0, utils_1.appendObjectFields)(originalWrappingSchema, wrappingTypeName, newTargetFieldConfigMap);
+        for (wrapIndex--; wrapIndex > -1; wrapIndex--) {
+            const nextWrappingTypeName = this.wrappingTypeNames[wrapIndex];
+            newSchema = (0, utils_1.appendObjectFields)(newSchema, nextWrappingTypeName, {
+                [wrappingFieldName]: {
+                    type: new graphql_1.GraphQLNonNull(newSchema.getType(wrappingTypeName)),
+                    resolve: delegate_1.defaultMergedResolver,
+                },
+            });
+            wrappingTypeName = nextWrappingTypeName;
+            wrappingFieldName = this.wrappingFieldNames[wrapIndex];
+        }
+        const wrappingRootField = this.outerTypeName === ((_a = originalWrappingSchema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name) ||
+            this.outerTypeName === ((_b = originalWrappingSchema.getMutationType()) === null || _b === void 0 ? void 0 : _b.name);
+        let resolve;
+        if (transformedSchema) {
+            if (wrappingRootField) {
+                const targetSchema = subschemaConfig.schema;
+                const operation = this.outerTypeName === ((_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: wrappingFieldName,
+                });
+            }
+            else {
+                resolve = delegate_1.defaultMergedResolver;
+            }
+        }
+        [newSchema] = (0, utils_1.modifyObjectFields)(newSchema, this.outerTypeName, fieldName => !!newTargetFieldConfigMap[fieldName], {
+            [wrappingFieldName]: {
+                type: new graphql_1.GraphQLNonNull(newSchema.getType(wrappingTypeName)),
+                resolve,
+            },
+        });
+        return this.transformer.transformSchema(newSchema, subschemaConfig, transformedSchema);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        transformationContext.nextIndex = 0;
+        transformationContext.paths = Object.create(null);
+        return this.transformer.transformRequest(originalRequest, delegationContext, transformationContext);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return this.transformer.transformResult(originalResult, delegationContext, transformationContext);
+    }
+}
+exports.default = WrapFields;
+function collectFields(selectionSet, fragments, fields = [], visitedFragmentNames = {}) {
+    if (selectionSet != null) {
+        for (const selection of selectionSet.selections) {
+            switch (selection.kind) {
+                case graphql_1.Kind.FIELD:
+                    fields.push(selection);
+                    break;
+                case graphql_1.Kind.INLINE_FRAGMENT:
+                    collectFields(selection.selectionSet, fragments, fields, visitedFragmentNames);
+                    break;
+                case graphql_1.Kind.FRAGMENT_SPREAD: {
+                    const fragmentName = selection.name.value;
+                    if (!visitedFragmentNames[fragmentName]) {
+                        visitedFragmentNames[fragmentName] = true;
+                        collectFields(fragments[fragmentName].selectionSet, fragments, fields, visitedFragmentNames);
+                    }
+                    break;
+                }
+                default:
+                    // unreachable
+                    break;
+            }
+        }
+    }
+    return fields;
+}
+function aliasFieldNode(fieldNode, str) {
+    return {
+        ...fieldNode,
+        alias: {
+            kind: graphql_1.Kind.NAME,
+            value: str,
+        },
+    };
+}
+function hoistFieldNodes({ fieldNode, fieldNames, path, fragments, transformationContext, prefix, index = 0, wrappingPath = [], }) {
+    const alias = fieldNode.alias != null ? fieldNode.alias.value : fieldNode.name.value;
+    let newFieldNodes = [];
+    if (index < path.length) {
+        const pathSegment = path[index];
+        for (const possibleFieldNode of collectFields(fieldNode.selectionSet, fragments)) {
+            if (possibleFieldNode.name.value === pathSegment) {
+                const newWrappingPath = wrappingPath.concat([alias]);
+                newFieldNodes = newFieldNodes.concat(hoistFieldNodes({
+                    fieldNode: possibleFieldNode,
+                    fieldNames,
+                    path,
+                    fragments,
+                    transformationContext,
+                    prefix,
+                    index: index + 1,
+                    wrappingPath: newWrappingPath,
+                }));
+            }
+        }
+    }
+    else {
+        for (const possibleFieldNode of collectFields(fieldNode.selectionSet, fragments)) {
+            if (!fieldNames || fieldNames.includes(possibleFieldNode.name.value)) {
+                const nextIndex = transformationContext.nextIndex;
+                transformationContext.nextIndex++;
+                const indexingAlias = `__${prefix}${nextIndex}__`;
+                transformationContext.paths[indexingAlias] = {
+                    pathToField: wrappingPath.concat([alias]),
+                    alias: possibleFieldNode.alias != null ? possibleFieldNode.alias.value : possibleFieldNode.name.value,
+                };
+                newFieldNodes.push(aliasFieldNode(possibleFieldNode, indexingAlias));
+            }
+        }
+    }
+    return newFieldNodes;
+}
+function dehoistValue(originalValue, context) {
+    if (originalValue == null) {
+        return originalValue;
+    }
+    const newValue = Object.create(null);
+    for (const alias in originalValue) {
+        let obj = newValue;
+        const path = context.paths[alias];
+        if (path == null) {
+            newValue[alias] = originalValue[alias];
+            continue;
+        }
+        const pathToField = path.pathToField;
+        const fieldAlias = path.alias;
+        for (const key of pathToField) {
+            obj = obj[key] = obj[key] || Object.create(null);
+        }
+        obj[fieldAlias] = originalValue[alias];
+    }
+    return newValue;
+}
+exports.dehoistValue = dehoistValue;
+function dehoistErrors(errors, context) {
+    if (errors === undefined) {
+        return undefined;
+    }
+    return errors.map(error => {
+        const originalPath = error.path;
+        if (originalPath == null) {
+            return error;
+        }
+        let newPath = [];
+        for (const pathSegment of originalPath) {
+            if (typeof pathSegment !== 'string') {
+                newPath.push(pathSegment);
+                continue;
+            }
+            const path = context.paths[pathSegment];
+            if (path == null) {
+                newPath.push(pathSegment);
+                continue;
+            }
+            newPath = newPath.concat(path.pathToField, [path.alias]);
+        }
+        return (0, utils_1.relocatedError)(error, newPath);
+    });
+}

package/cjs/transforms/WrapQuery.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+class WrapQuery {
+    constructor(path, wrapper, extractor) {
+        this.path = path;
+        this.wrapper = wrapper;
+        this.extractor = extractor;
+    }
+    transformRequest(originalRequest, _delegationContext, _transformationContext) {
+        const fieldPath = [];
+        const ourPath = JSON.stringify(this.path);
+        const document = (0, graphql_1.visit)(originalRequest.document, {
+            [graphql_1.Kind.FIELD]: {
+                enter: (node) => {
+                    fieldPath.push(node.name.value);
+                    if (node.selectionSet != null && ourPath === JSON.stringify(fieldPath)) {
+                        const wrapResult = this.wrapper(node.selectionSet);
+                        // Selection can be either a single selection or a selection set. If it's just one selection,
+                        // let's wrap it in a selection set. Otherwise, keep it as is.
+                        const selectionSet = wrapResult != null && wrapResult.kind === graphql_1.Kind.SELECTION_SET
+                            ? wrapResult
+                            : {
+                                kind: graphql_1.Kind.SELECTION_SET,
+                                selections: [wrapResult],
+                            };
+                        return {
+                            ...node,
+                            selectionSet,
+                        };
+                    }
+                },
+                leave: () => {
+                    fieldPath.pop();
+                },
+            },
+        });
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformResult(originalResult, _delegationContext, _transformationContext) {
+        const rootData = originalResult.data;
+        if (rootData != null) {
+            let data = rootData;
+            const path = [...this.path];
+            while (path.length > 1) {
+                const next = path.shift();
+                if (data[next]) {
+                    data = data[next];
+                }
+            }
+            data[path[0]] = this.extractor(data[path[0]]);
+        }
+        return {
+            data: rootData,
+            errors: originalResult.errors,
+        };
+    }
+}
+exports.default = WrapQuery;

package/cjs/transforms/WrapType.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const WrapFields_js_1 = tslib_1.__importDefault(require("./WrapFields.js"));
+class WrapType {
+    constructor(outerTypeName, innerTypeName, fieldName) {
+        this.transformer = new WrapFields_js_1.default(outerTypeName, [fieldName], [innerTypeName]);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, 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 = WrapType;