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

package/cjs/transforms/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractField = exports.WrapQuery = exports.MapFields = exports.HoistField = exports.WrapFields = exports.WrapType = exports.PruneSchema = exports.RemoveObjectFieldsWithDeprecation = exports.RemoveObjectFieldDeprecations = exports.RemoveObjectFieldsWithDirective = exports.RemoveObjectFieldDirectives = exports.FilterObjectFieldDirectives = exports.TransformQuery = exports.TransformEnumValues = exports.MapLeafValues = exports.FilterInputObjectFields = exports.RenameInputObjectFields = exports.TransformInputObjectFields = exports.FilterInterfaceFields = exports.RenameInterfaceFields = exports.TransformInterfaceFields = exports.FilterObjectFields = exports.RenameObjectFieldArguments = exports.RenameObjectFields = exports.TransformObjectFields = exports.FilterRootFields = exports.RenameRootFields = exports.TransformRootFields = exports.TransformCompositeFields = exports.RenameRootTypes = exports.FilterTypes = exports.RenameTypes = void 0;
+var RenameTypes_js_1 = require("./RenameTypes.js");
+Object.defineProperty(exports, "RenameTypes", { enumerable: true, get: function () { return __importDefault(RenameTypes_js_1).default; } });
+var FilterTypes_js_1 = require("./FilterTypes.js");
+Object.defineProperty(exports, "FilterTypes", { enumerable: true, get: function () { return __importDefault(FilterTypes_js_1).default; } });
+var RenameRootTypes_js_1 = require("./RenameRootTypes.js");
+Object.defineProperty(exports, "RenameRootTypes", { enumerable: true, get: function () { return __importDefault(RenameRootTypes_js_1).default; } });
+var TransformCompositeFields_js_1 = require("./TransformCompositeFields.js");
+Object.defineProperty(exports, "TransformCompositeFields", { enumerable: true, get: function () { return __importDefault(TransformCompositeFields_js_1).default; } });
+var TransformRootFields_js_1 = require("./TransformRootFields.js");
+Object.defineProperty(exports, "TransformRootFields", { enumerable: true, get: function () { return __importDefault(TransformRootFields_js_1).default; } });
+var RenameRootFields_js_1 = require("./RenameRootFields.js");
+Object.defineProperty(exports, "RenameRootFields", { enumerable: true, get: function () { return __importDefault(RenameRootFields_js_1).default; } });
+var FilterRootFields_js_1 = require("./FilterRootFields.js");
+Object.defineProperty(exports, "FilterRootFields", { enumerable: true, get: function () { return __importDefault(FilterRootFields_js_1).default; } });
+var TransformObjectFields_js_1 = require("./TransformObjectFields.js");
+Object.defineProperty(exports, "TransformObjectFields", { enumerable: true, get: function () { return __importDefault(TransformObjectFields_js_1).default; } });
+var RenameObjectFields_js_1 = require("./RenameObjectFields.js");
+Object.defineProperty(exports, "RenameObjectFields", { enumerable: true, get: function () { return __importDefault(RenameObjectFields_js_1).default; } });
+var RenameObjectFieldArguments_js_1 = require("./RenameObjectFieldArguments.js");
+Object.defineProperty(exports, "RenameObjectFieldArguments", { enumerable: true, get: function () { return __importDefault(RenameObjectFieldArguments_js_1).default; } });
+var FilterObjectFields_js_1 = require("./FilterObjectFields.js");
+Object.defineProperty(exports, "FilterObjectFields", { enumerable: true, get: function () { return __importDefault(FilterObjectFields_js_1).default; } });
+var TransformInterfaceFields_js_1 = require("./TransformInterfaceFields.js");
+Object.defineProperty(exports, "TransformInterfaceFields", { enumerable: true, get: function () { return __importDefault(TransformInterfaceFields_js_1).default; } });
+var RenameInterfaceFields_js_1 = require("./RenameInterfaceFields.js");
+Object.defineProperty(exports, "RenameInterfaceFields", { enumerable: true, get: function () { return __importDefault(RenameInterfaceFields_js_1).default; } });
+var FilterInterfaceFields_js_1 = require("./FilterInterfaceFields.js");
+Object.defineProperty(exports, "FilterInterfaceFields", { enumerable: true, get: function () { return __importDefault(FilterInterfaceFields_js_1).default; } });
+var TransformInputObjectFields_js_1 = require("./TransformInputObjectFields.js");
+Object.defineProperty(exports, "TransformInputObjectFields", { enumerable: true, get: function () { return __importDefault(TransformInputObjectFields_js_1).default; } });
+var RenameInputObjectFields_js_1 = require("./RenameInputObjectFields.js");
+Object.defineProperty(exports, "RenameInputObjectFields", { enumerable: true, get: function () { return __importDefault(RenameInputObjectFields_js_1).default; } });
+var FilterInputObjectFields_js_1 = require("./FilterInputObjectFields.js");
+Object.defineProperty(exports, "FilterInputObjectFields", { enumerable: true, get: function () { return __importDefault(FilterInputObjectFields_js_1).default; } });
+var MapLeafValues_js_1 = require("./MapLeafValues.js");
+Object.defineProperty(exports, "MapLeafValues", { enumerable: true, get: function () { return __importDefault(MapLeafValues_js_1).default; } });
+var TransformEnumValues_js_1 = require("./TransformEnumValues.js");
+Object.defineProperty(exports, "TransformEnumValues", { enumerable: true, get: function () { return __importDefault(TransformEnumValues_js_1).default; } });
+var TransformQuery_js_1 = require("./TransformQuery.js");
+Object.defineProperty(exports, "TransformQuery", { enumerable: true, get: function () { return __importDefault(TransformQuery_js_1).default; } });
+var FilterObjectFieldDirectives_js_1 = require("./FilterObjectFieldDirectives.js");
+Object.defineProperty(exports, "FilterObjectFieldDirectives", { enumerable: true, get: function () { return __importDefault(FilterObjectFieldDirectives_js_1).default; } });
+var RemoveObjectFieldDirectives_js_1 = require("./RemoveObjectFieldDirectives.js");
+Object.defineProperty(exports, "RemoveObjectFieldDirectives", { enumerable: true, get: function () { return __importDefault(RemoveObjectFieldDirectives_js_1).default; } });
+var RemoveObjectFieldsWithDirective_js_1 = require("./RemoveObjectFieldsWithDirective.js");
+Object.defineProperty(exports, "RemoveObjectFieldsWithDirective", { enumerable: true, get: function () { return __importDefault(RemoveObjectFieldsWithDirective_js_1).default; } });
+var RemoveObjectFieldDeprecations_js_1 = require("./RemoveObjectFieldDeprecations.js");
+Object.defineProperty(exports, "RemoveObjectFieldDeprecations", { enumerable: true, get: function () { return __importDefault(RemoveObjectFieldDeprecations_js_1).default; } });
+var RemoveObjectFieldsWithDeprecation_js_1 = require("./RemoveObjectFieldsWithDeprecation.js");
+Object.defineProperty(exports, "RemoveObjectFieldsWithDeprecation", { enumerable: true, get: function () { return __importDefault(RemoveObjectFieldsWithDeprecation_js_1).default; } });
+var PruneSchema_js_1 = require("./PruneSchema.js");
+Object.defineProperty(exports, "PruneSchema", { enumerable: true, get: function () { return __importDefault(PruneSchema_js_1).default; } });
+var WrapType_js_1 = require("./WrapType.js");
+Object.defineProperty(exports, "WrapType", { enumerable: true, get: function () { return __importDefault(WrapType_js_1).default; } });
+var WrapFields_js_1 = require("./WrapFields.js");
+Object.defineProperty(exports, "WrapFields", { enumerable: true, get: function () { return __importDefault(WrapFields_js_1).default; } });
+var HoistField_js_1 = require("./HoistField.js");
+Object.defineProperty(exports, "HoistField", { enumerable: true, get: function () { return __importDefault(HoistField_js_1).default; } });
+var MapFields_js_1 = require("./MapFields.js");
+Object.defineProperty(exports, "MapFields", { enumerable: true, get: function () { return __importDefault(MapFields_js_1).default; } });
+// superseded by TransformQuery
+var WrapQuery_js_1 = require("./WrapQuery.js");
+Object.defineProperty(exports, "WrapQuery", { enumerable: true, get: function () { return __importDefault(WrapQuery_js_1).default; } });
+var ExtractField_js_1 = require("./ExtractField.js");
+Object.defineProperty(exports, "ExtractField", { enumerable: true, get: function () { return __importDefault(ExtractField_js_1).default; } });

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/wrapSchema.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapSchema = void 0;
+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");
+function wrapSchema(subschemaConfig) {
+    const targetSchema = subschemaConfig.schema;
+    const proxyingResolvers = (0, generateProxyingResolvers_js_1.generateProxyingResolvers)(subschemaConfig);
+    const schema = createWrappingSchema(targetSchema, proxyingResolvers);
+    const transformedSchema = (0, delegate_1.applySchemaTransforms)(schema, subschemaConfig);
+    return (0, delegate_1.applySchemaTransforms)(schema, subschemaConfig, transformedSchema);
+}
+exports.wrapSchema = wrapSchema;
+function createWrappingSchema(schema, proxyingResolvers) {
+    return (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.ROOT_OBJECT]: type => {
+            var _a;
+            const config = type.toConfig();
+            const fieldConfigMap = config.fields;
+            for (const fieldName in fieldConfigMap) {
+                const field = fieldConfigMap[fieldName];
+                if (field == null) {
+                    continue;
+                }
+                fieldConfigMap[fieldName] = {
+                    ...field,
+                    ...(_a = proxyingResolvers[type.name]) === null || _a === void 0 ? void 0 : _a[fieldName],
+                };
+            }
+            return new graphql_1.GraphQLObjectType(config);
+        },
+        [utils_1.MapperKind.OBJECT_TYPE]: type => {
+            const config = type.toConfig();
+            config.isTypeOf = undefined;
+            for (const fieldName in config.fields) {
+                const field = config.fields[fieldName];
+                if (field == null) {
+                    continue;
+                }
+                field.resolve = delegate_1.defaultMergedResolver;
+                field.subscribe = undefined;
+            }
+            return new graphql_1.GraphQLObjectType(config);
+        },
+        [utils_1.MapperKind.INTERFACE_TYPE]: type => {
+            const config = type.toConfig();
+            delete config.resolveType;
+            return new graphql_1.GraphQLInterfaceType(config);
+        },
+        [utils_1.MapperKind.UNION_TYPE]: type => {
+            const config = type.toConfig();
+            delete config.resolveType;
+            return new graphql_1.GraphQLUnionType(config);
+        },
+    });
+}

package/esm/generateProxyingResolvers.js

@@ -0,0 +1,69 @@
+import { getResponseKeyFromInfo, getRootTypeMap } from '@graphql-tools/utils';
+import { delegateToSchema, getSubschema, resolveExternalValue, applySchemaTransforms, isExternalObject, getUnpathedErrors, } from '@graphql-tools/delegate';
+export function generateProxyingResolvers(subschemaConfig) {
+    var _a;
+    const targetSchema = subschemaConfig.schema;
+    const createProxyingResolver = (_a = subschemaConfig.createProxyingResolver) !== null && _a !== void 0 ? _a : defaultCreateProxyingResolver;
+    const transformedSchema = applySchemaTransforms(targetSchema, subschemaConfig);
+    const rootTypeMap = 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;
+}
+function identical(value) {
+    return value;
+}
+function createPossiblyNestedProxyingResolver(subschemaConfig, proxyingResolver) {
+    return function possiblyNestedProxyingResolver(parent, args, context, info) {
+        if (parent != null) {
+            const responseKey = getResponseKeyFromInfo(info);
+            // Check to see if the parent contains a proxied result
+            if (isExternalObject(parent)) {
+                const unpathedErrors = getUnpathedErrors(parent);
+                const subschema = 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 resolveExternalValue(parent[responseKey], unpathedErrors, subschema, context, info);
+                }
+            }
+        }
+        return proxyingResolver(parent, args, context, info);
+    };
+}
+export function defaultCreateProxyingResolver({ subschemaConfig, operation, transformedSchema, }) {
+    return function proxyingResolver(_parent, _args, context, info) {
+        return delegateToSchema({
+            schema: subschemaConfig,
+            operation,
+            context,
+            info,
+            transformedSchema,
+        });
+    };
+}

package/esm/index.js

@@ -0,0 +1,5 @@
+export { wrapSchema } from './wrapSchema.js';
+export { defaultCreateProxyingResolver, generateProxyingResolvers } from './generateProxyingResolvers.js';
+export * from './transforms/index.js';
+export * from './types.js';
+export * from './introspect.js';

package/esm/introspect.js

@@ -0,0 +1,26 @@
+import { getIntrospectionQuery, buildClientSchema, parse, } from 'graphql';
+import { ValueOrPromise } from 'value-or-promise';
+import { isAsyncIterable } from '@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 buildClientSchema(introspectionResult.data, options);
+    }
+    throw new Error('Could not obtain introspection result, received: ' + JSON.stringify(introspectionResult));
+}
+export function introspectSchema(executor, context, options) {
+    const parsedIntrospectionQuery = parse(getIntrospectionQuery(options), options);
+    return new ValueOrPromise(() => executor({
+        document: parsedIntrospectionQuery,
+        context,
+    }))
+        .then(introspection => {
+        if (isAsyncIterable(introspection)) {
+            const iterator = introspection[Symbol.asyncIterator]();
+            return iterator.next().then(({ value }) => value);
+        }
+        return introspection;
+    })
+        .then(introspection => getSchemaFromIntrospection(introspection, options))
+        .resolve();
+}

package/esm/transforms/ExtractField.js

@@ -0,0 +1,48 @@
+import { visit, Kind, BREAK } from 'graphql';
+export default 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 = [];
+        visit(originalRequest.document, {
+            [Kind.FIELD]: {
+                enter: (node) => {
+                    fieldPath.push(node.name.value);
+                    if (ourPathFrom === JSON.stringify(fieldPath)) {
+                        fromSelection = node.selectionSet;
+                        return BREAK;
+                    }
+                },
+                leave: () => {
+                    fieldPath.pop();
+                },
+            },
+        });
+        fieldPath = [];
+        const document = visit(originalRequest.document, {
+            [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,
+        };
+    }
+}

package/esm/transforms/FilterInputObjectFields.js

@@ -0,0 +1,12 @@
+import TransformInputObjectFields from './TransformInputObjectFields.js';
+export default class FilterInputObjectFields {
+    constructor(filter, inputObjectNodeTransformer) {
+        this.transformer = new TransformInputObjectFields((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);
+    }
+}

package/esm/transforms/FilterInterfaceFields.js

@@ -0,0 +1,9 @@
+import TransformInterfaceFields from './TransformInterfaceFields.js';
+export default class FilterInterfaceFields {
+    constructor(filter) {
+        this.transformer = new TransformInterfaceFields((typeName, fieldName, fieldConfig) => filter(typeName, fieldName, fieldConfig) ? undefined : null);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/FilterObjectFieldDirectives.js

@@ -0,0 +1,29 @@
+import { getArgumentValues } from '@graphql-tools/utils';
+import TransformObjectFields from './TransformObjectFields.js';
+export default class FilterObjectFieldDirectives {
+    constructor(filter) {
+        this.filter = filter;
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        const transformer = new TransformObjectFields((_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 ? 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);
+    }
+}

package/esm/transforms/FilterObjectFields.js

@@ -0,0 +1,9 @@
+import TransformObjectFields from './TransformObjectFields.js';
+export default class FilterObjectFields {
+    constructor(filter) {
+        this.transformer = new TransformObjectFields((typeName, fieldName, fieldConfig) => filter(typeName, fieldName, fieldConfig) ? undefined : null);
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/FilterRootFields.js

@@ -0,0 +1,14 @@
+import TransformRootFields from './TransformRootFields.js';
+export default class FilterRootFields {
+    constructor(filter) {
+        this.transformer = new TransformRootFields((operation, fieldName, fieldConfig) => {
+            if (filter(operation, fieldName, fieldConfig)) {
+                return undefined;
+            }
+            return null;
+        });
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return this.transformer.transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema);
+    }
+}

package/esm/transforms/FilterTypes.js

@@ -0,0 +1,16 @@
+import { mapSchema, MapperKind } from '@graphql-tools/utils';
+export default class FilterTypes {
+    constructor(filter) {
+        this.filter = filter;
+    }
+    transformSchema(originalWrappingSchema, _subschemaConfig, _transformedSchema) {
+        return mapSchema(originalWrappingSchema, {
+            [MapperKind.TYPE]: (type) => {
+                if (this.filter(type)) {
+                    return undefined;
+                }
+                return null;
+            },
+        });
+    }
+}

package/esm/transforms/HoistField.js

@@ -0,0 +1,168 @@
+import { getNullableType, Kind, } from 'graphql';
+import { appendObjectFields, removeObjectFields, relocatedError, } from '@graphql-tools/utils';
+import { defaultMergedResolver } from '@graphql-tools/delegate';
+import { defaultCreateProxyingResolver } from '../generateProxyingResolvers.js';
+import MapFields from './MapFields.js';
+export default 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({
+            [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 getNullableType(field.type);
+        }, originalWrappingSchema.getType(this.typeName));
+        let [newSchema, targetFieldConfigMap] = 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 : defaultCreateProxyingResolver;
+                resolve = createProxyingResolver({
+                    subschemaConfig,
+                    transformedSchema,
+                    operation: operation,
+                    fieldName: this.newFieldName,
+                });
+            }
+            else {
+                resolve = 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 = 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);
+    }
+}
+export function wrapFieldNode(fieldNode, path, alias, argLevels) {
+    return path.reduceRight((acc, fieldName, index) => ({
+        kind: Kind.FIELD,
+        alias: {
+            kind: Kind.NAME,
+            value: alias,
+        },
+        name: {
+            kind: Kind.NAME,
+            value: fieldName,
+        },
+        selectionSet: {
+            kind: 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,
+    });
+}
+export function renameFieldNode(fieldNode, name) {
+    return {
+        ...fieldNode,
+        alias: {
+            kind: Kind.NAME,
+            value: fieldNode.alias != null ? fieldNode.alias.value : fieldNode.name.value,
+        },
+        name: {
+            kind: Kind.NAME,
+            value: name,
+        },
+    };
+}
+export 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;
+}
+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 relocatedError(error, newPath);
+    });
+}

package/esm/transforms/MapFields.js

@@ -0,0 +1,57 @@
+import TransformCompositeFields from './TransformCompositeFields.js';
+export default 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(() => 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);
+    }
+}