@graphql-tools/delegate 9.0.0-alpha-e2ab84c8.0 → 9.0.0-alpha-25204a2f.0

package/cjs/prepareGatewayDocument.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareGatewayDocument = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const getDocumentMetadata_js_1 = require("./getDocumentMetadata.js");
+function prepareGatewayDocument(originalDocument, transformedSchema, returnType, infoSchema) {
+    const wrappedConcreteTypesDocument = wrapConcreteTypes(returnType, transformedSchema, originalDocument);
+    if (infoSchema == null) {
+        return wrappedConcreteTypesDocument;
+    }
+    const { possibleTypesMap, reversePossibleTypesMap, interfaceExtensionsMap, fieldNodesByType, fieldNodesByField, dynamicSelectionSetsByField, } = getSchemaMetaData(infoSchema, transformedSchema);
+    const { operations, fragments, fragmentNames } = (0, getDocumentMetadata_js_1.getDocumentMetadata)(wrappedConcreteTypesDocument);
+    const { expandedFragments, fragmentReplacements } = getExpandedFragments(fragments, fragmentNames, possibleTypesMap);
+    const typeInfo = new graphql_1.TypeInfo(transformedSchema);
+    const expandedDocument = {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: [...operations, ...fragments, ...expandedFragments],
+    };
+    const visitorKeyMap = {
+        Document: ['definitions'],
+        OperationDefinition: ['selectionSet'],
+        SelectionSet: ['selections'],
+        Field: ['selectionSet'],
+        InlineFragment: ['selectionSet'],
+        FragmentDefinition: ['selectionSet'],
+    };
+    return (0, graphql_1.visit)(expandedDocument, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+        [graphql_1.Kind.SELECTION_SET]: node => visitSelectionSet(node, fragmentReplacements, transformedSchema, typeInfo, possibleTypesMap, reversePossibleTypesMap, interfaceExtensionsMap, fieldNodesByType, fieldNodesByField, dynamicSelectionSetsByField),
+    }), 
+    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
+    // empty keys cannot be removed only because of typescript errors
+    // will hopefully be fixed in future version of graphql-js to be optional
+    visitorKeyMap);
+}
+exports.prepareGatewayDocument = prepareGatewayDocument;
+function visitSelectionSet(node, fragmentReplacements, schema, typeInfo, possibleTypesMap, reversePossibleTypesMap, interfaceExtensionsMap, fieldNodesByType, fieldNodesByField, dynamicSelectionSetsByField) {
+    var _a, _b;
+    const newSelections = new Set();
+    const maybeType = typeInfo.getParentType();
+    if (maybeType != null) {
+        const parentType = (0, graphql_1.getNamedType)(maybeType);
+        const parentTypeName = parentType.name;
+        const fieldNodes = fieldNodesByType[parentTypeName];
+        if (fieldNodes) {
+            for (const fieldNode of fieldNodes) {
+                newSelections.add(fieldNode);
+            }
+        }
+        const interfaceExtensions = interfaceExtensionsMap[parentType.name];
+        const interfaceExtensionFields = [];
+        for (const selection of node.selections) {
+            if (selection.kind === graphql_1.Kind.INLINE_FRAGMENT) {
+                if (selection.typeCondition != null) {
+                    const possibleTypes = possibleTypesMap[selection.typeCondition.name.value];
+                    if (possibleTypes == null) {
+                        newSelections.add(selection);
+                        continue;
+                    }
+                    for (const possibleTypeName of possibleTypes) {
+                        const maybePossibleType = schema.getType(possibleTypeName);
+                        if (maybePossibleType != null && (0, utils_1.implementsAbstractType)(schema, parentType, maybePossibleType)) {
+                            newSelections.add(generateInlineFragment(possibleTypeName, selection.selectionSet));
+                        }
+                    }
+                }
+            }
+            else if (selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
+                const fragmentName = selection.name.value;
+                if (!fragmentReplacements[fragmentName]) {
+                    newSelections.add(selection);
+                    continue;
+                }
+                for (const replacement of fragmentReplacements[fragmentName]) {
+                    const typeName = replacement.typeName;
+                    const maybeReplacementType = schema.getType(typeName);
+                    if (maybeReplacementType != null && (0, utils_1.implementsAbstractType)(schema, parentType, maybeType)) {
+                        newSelections.add({
+                            kind: graphql_1.Kind.FRAGMENT_SPREAD,
+                            name: {
+                                kind: graphql_1.Kind.NAME,
+                                value: replacement.fragmentName,
+                            },
+                        });
+                    }
+                }
+            }
+            else {
+                const fieldName = selection.name.value;
+                const fieldNodes = (_a = fieldNodesByField[parentTypeName]) === null || _a === void 0 ? void 0 : _a[fieldName];
+                if (fieldNodes != null) {
+                    for (const fieldNode of fieldNodes) {
+                        newSelections.add(fieldNode);
+                    }
+                }
+                const dynamicSelectionSets = (_b = dynamicSelectionSetsByField[parentTypeName]) === null || _b === void 0 ? void 0 : _b[fieldName];
+                if (dynamicSelectionSets != null) {
+                    for (const selectionSetFn of dynamicSelectionSets) {
+                        const selectionSet = selectionSetFn(selection);
+                        if (selectionSet != null) {
+                            for (const selection of selectionSet.selections) {
+                                newSelections.add(selection);
+                            }
+                        }
+                    }
+                }
+                if (interfaceExtensions === null || interfaceExtensions === void 0 ? void 0 : interfaceExtensions[fieldName]) {
+                    interfaceExtensionFields.push(selection);
+                }
+                else {
+                    newSelections.add(selection);
+                }
+            }
+        }
+        if (reversePossibleTypesMap[parentType.name]) {
+            newSelections.add({
+                kind: graphql_1.Kind.FIELD,
+                name: {
+                    kind: graphql_1.Kind.NAME,
+                    value: '__typename',
+                },
+            });
+        }
+        if (interfaceExtensionFields.length) {
+            const possibleTypes = possibleTypesMap[parentType.name];
+            if (possibleTypes != null) {
+                for (const possibleType of possibleTypes) {
+                    newSelections.add(generateInlineFragment(possibleType, {
+                        kind: graphql_1.Kind.SELECTION_SET,
+                        selections: interfaceExtensionFields,
+                    }));
+                }
+            }
+        }
+        return {
+            ...node,
+            selections: Array.from(newSelections),
+        };
+    }
+    return node;
+}
+function generateInlineFragment(typeName, selectionSet) {
+    return {
+        kind: graphql_1.Kind.INLINE_FRAGMENT,
+        typeCondition: {
+            kind: graphql_1.Kind.NAMED_TYPE,
+            name: {
+                kind: graphql_1.Kind.NAME,
+                value: typeName,
+            },
+        },
+        selectionSet,
+    };
+}
+const getSchemaMetaData = (0, utils_1.memoize2)((sourceSchema, targetSchema) => {
+    var _a, _b, _c, _d;
+    const typeMap = sourceSchema.getTypeMap();
+    const targetTypeMap = targetSchema.getTypeMap();
+    const possibleTypesMap = Object.create(null);
+    const interfaceExtensionsMap = Object.create(null);
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        if ((0, graphql_1.isAbstractType)(type)) {
+            const targetType = targetTypeMap[typeName];
+            if ((0, graphql_1.isInterfaceType)(type) && (0, graphql_1.isInterfaceType)(targetType)) {
+                const targetTypeFields = targetType.getFields();
+                const sourceTypeFields = type.getFields();
+                const extensionFields = Object.create(null);
+                let isExtensionFieldsEmpty = true;
+                for (const fieldName in sourceTypeFields) {
+                    if (!targetTypeFields[fieldName]) {
+                        extensionFields[fieldName] = true;
+                        isExtensionFieldsEmpty = false;
+                    }
+                }
+                if (!isExtensionFieldsEmpty) {
+                    interfaceExtensionsMap[typeName] = extensionFields;
+                }
+            }
+            if (interfaceExtensionsMap[typeName] || !(0, graphql_1.isAbstractType)(targetType)) {
+                const implementations = sourceSchema.getPossibleTypes(type);
+                possibleTypesMap[typeName] = [];
+                for (const impl of implementations) {
+                    if (targetTypeMap[impl.name]) {
+                        possibleTypesMap[typeName].push(impl.name);
+                    }
+                }
+            }
+        }
+    }
+    const stitchingInfo = (_a = sourceSchema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
+    return {
+        possibleTypesMap,
+        reversePossibleTypesMap: reversePossibleTypesMap(possibleTypesMap),
+        interfaceExtensionsMap,
+        fieldNodesByType: (_b = stitchingInfo === null || stitchingInfo === void 0 ? void 0 : stitchingInfo.fieldNodesByType) !== null && _b !== void 0 ? _b : {},
+        fieldNodesByField: (_c = stitchingInfo === null || stitchingInfo === void 0 ? void 0 : stitchingInfo.fieldNodesByField) !== null && _c !== void 0 ? _c : {},
+        dynamicSelectionSetsByField: (_d = stitchingInfo === null || stitchingInfo === void 0 ? void 0 : stitchingInfo.dynamicSelectionSetsByField) !== null && _d !== void 0 ? _d : {},
+    };
+});
+function reversePossibleTypesMap(possibleTypesMap) {
+    const result = Object.create(null);
+    for (const typeName in possibleTypesMap) {
+        const toTypeNames = possibleTypesMap[typeName];
+        for (const toTypeName of toTypeNames) {
+            if (!result[toTypeName]) {
+                result[toTypeName] = [];
+            }
+            result[toTypeName].push(typeName);
+        }
+    }
+    return result;
+}
+function getExpandedFragments(fragments, fragmentNames, possibleTypesMap) {
+    let fragmentCounter = 0;
+    function generateFragmentName(typeName) {
+        let fragmentName;
+        do {
+            fragmentName = `_${typeName}_Fragment${fragmentCounter.toString()}`;
+            fragmentCounter++;
+        } while (fragmentNames.has(fragmentName));
+        return fragmentName;
+    }
+    const expandedFragments = [];
+    const fragmentReplacements = Object.create(null);
+    for (const fragment of fragments) {
+        const possibleTypes = possibleTypesMap[fragment.typeCondition.name.value];
+        if (possibleTypes != null) {
+            const fragmentName = fragment.name.value;
+            fragmentReplacements[fragmentName] = [];
+            for (const possibleTypeName of possibleTypes) {
+                const name = generateFragmentName(possibleTypeName);
+                fragmentNames.add(name);
+                expandedFragments.push({
+                    kind: graphql_1.Kind.FRAGMENT_DEFINITION,
+                    name: {
+                        kind: graphql_1.Kind.NAME,
+                        value: name,
+                    },
+                    typeCondition: {
+                        kind: graphql_1.Kind.NAMED_TYPE,
+                        name: {
+                            kind: graphql_1.Kind.NAME,
+                            value: possibleTypeName,
+                        },
+                    },
+                    selectionSet: fragment.selectionSet,
+                });
+                fragmentReplacements[fragmentName].push({
+                    fragmentName: name,
+                    typeName: possibleTypeName,
+                });
+            }
+        }
+    }
+    return {
+        expandedFragments,
+        fragmentReplacements,
+    };
+}
+function wrapConcreteTypes(returnType, targetSchema, document) {
+    const namedType = (0, graphql_1.getNamedType)(returnType);
+    if (!(0, graphql_1.isObjectType)(namedType)) {
+        return document;
+    }
+    const rootTypeNames = (0, utils_1.getRootTypeNames)(targetSchema);
+    const typeInfo = new graphql_1.TypeInfo(targetSchema);
+    const visitorKeys = {
+        Document: ['definitions'],
+        OperationDefinition: ['selectionSet'],
+        SelectionSet: ['selections'],
+        InlineFragment: ['selectionSet'],
+        FragmentDefinition: ['selectionSet'],
+    };
+    return (0, graphql_1.visit)(document, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+        [graphql_1.Kind.FRAGMENT_DEFINITION]: (node) => {
+            const typeName = node.typeCondition.name.value;
+            if (!rootTypeNames.has(typeName)) {
+                return false;
+            }
+        },
+        [graphql_1.Kind.FIELD]: (node) => {
+            const type = typeInfo.getType();
+            if (type != null && (0, graphql_1.isAbstractType)((0, graphql_1.getNamedType)(type))) {
+                return {
+                    ...node,
+                    selectionSet: {
+                        kind: graphql_1.Kind.SELECTION_SET,
+                        selections: [
+                            {
+                                kind: graphql_1.Kind.INLINE_FRAGMENT,
+                                typeCondition: {
+                                    kind: graphql_1.Kind.NAMED_TYPE,
+                                    name: {
+                                        kind: graphql_1.Kind.NAME,
+                                        value: namedType.name,
+                                    },
+                                },
+                                selectionSet: node.selectionSet,
+                            },
+                        ],
+                    },
+                };
+            }
+        },
+    }), 
+    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
+    // empty keys cannot be removed only because of typescript errors
+    // will hopefully be fixed in future version of graphql-js to be optional
+    visitorKeys);
+}

package/cjs/resolveExternalValue.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExternalValue = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const mergeFields_js_1 = require("./mergeFields.js");
+function resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType(info), skipTypeMerging) {
+    const type = (0, graphql_1.getNullableType)(returnType);
+    if (result instanceof Error) {
+        return result;
+    }
+    if (result == null) {
+        return reportUnpathedErrorsViaNull(unpathedErrors);
+    }
+    if ('parseValue' in type) {
+        return type.parseValue(result);
+    }
+    else if ((0, graphql_1.isCompositeType)(type)) {
+        return resolveExternalObject(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+    else if ((0, graphql_1.isListType)(type)) {
+        return resolveExternalList(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+}
+exports.resolveExternalValue = resolveExternalValue;
+function resolveExternalObject(type, object, unpathedErrors, subschema, context, info, skipTypeMerging) {
+    var _a;
+    // if we have already resolved this object, for example, when the identical object appears twice
+    // in a list, see https://github.com/ardatan/graphql-tools/issues/2304
+    if (!(0, mergeFields_js_1.isExternalObject)(object)) {
+        (0, mergeFields_js_1.annotateExternalObject)(object, unpathedErrors, subschema, Object.create(null));
+    }
+    if (skipTypeMerging || info == null) {
+        return object;
+    }
+    const stitchingInfo = (_a = info.schema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
+    if (stitchingInfo == null) {
+        return object;
+    }
+    const typeName = (0, graphql_1.isAbstractType)(type) ? object.__typename : type.name;
+    const mergedTypeInfo = stitchingInfo.mergedTypes[typeName];
+    let targetSubschemas;
+    // Within the stitching context, delegation to a stitched GraphQLSchema or SubschemaConfig
+    // will be redirected to the appropriate Subschema object, from which merge targets can be queried.
+    if (mergedTypeInfo != null) {
+        targetSubschemas = mergedTypeInfo.targetSubschemas.get(subschema);
+    }
+    // If there are no merge targets from the subschema, return.
+    if (!targetSubschemas || !targetSubschemas.length) {
+        return object;
+    }
+    return (0, mergeFields_js_1.mergeFields)(mergedTypeInfo, object, subschema, context, info);
+}
+function resolveExternalList(type, list, unpathedErrors, subschema, context, info, skipTypeMerging) {
+    return list.map(listMember => resolveExternalListMember((0, graphql_1.getNullableType)(type.ofType), listMember, unpathedErrors, subschema, context, info, skipTypeMerging));
+}
+function resolveExternalListMember(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging) {
+    if (listMember instanceof Error) {
+        return listMember;
+    }
+    if (listMember == null) {
+        return reportUnpathedErrorsViaNull(unpathedErrors);
+    }
+    if ('parseValue' in type) {
+        return type.parseValue(listMember);
+    }
+    else if ((0, graphql_1.isCompositeType)(type)) {
+        return resolveExternalObject(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+    else if ((0, graphql_1.isListType)(type)) {
+        return resolveExternalList(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+}
+const reportedErrors = new WeakMap();
+function reportUnpathedErrorsViaNull(unpathedErrors) {
+    if (unpathedErrors.length) {
+        const unreportedErrors = [];
+        for (const error of unpathedErrors) {
+            if (!reportedErrors.has(error)) {
+                unreportedErrors.push(error);
+                reportedErrors.set(error, true);
+            }
+        }
+        if (unreportedErrors.length) {
+            if (unreportedErrors.length === 1) {
+                return unreportedErrors[0];
+            }
+            const combinedError = new utils_1.AggregateError(unreportedErrors, unreportedErrors.map(error => error.message).join(', \n'));
+            // We cast path as any for GraphQL.js 14 compat
+            // locatedError path argument must be defined, but it is just forwarded to a constructor that allows a undefined value
+            // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/locatedError.js#L25
+            // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/GraphQLError.js#L19
+            return (0, graphql_1.locatedError)(combinedError, undefined, unreportedErrors[0].path);
+        }
+    }
+    return null;
+}
+function getReturnType(info) {
+    if (info == null) {
+        throw new Error(`Return type cannot be inferred without a source schema.`);
+    }
+    return info.returnType;
+}

package/cjs/subschemaConfig.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneSubschemaConfig = exports.isSubschemaConfig = void 0;
+function isSubschemaConfig(value) {
+    return Boolean(value === null || value === void 0 ? void 0 : value.schema);
+}
+exports.isSubschemaConfig = isSubschemaConfig;
+function cloneSubschemaConfig(subschemaConfig) {
+    var _a, _b;
+    const newSubschemaConfig = {
+        ...subschemaConfig,
+        transforms: subschemaConfig.transforms != null ? [...subschemaConfig.transforms] : undefined,
+    };
+    if (newSubschemaConfig.merge != null) {
+        newSubschemaConfig.merge = { ...subschemaConfig.merge };
+        for (const typeName in newSubschemaConfig.merge) {
+            const mergedTypeConfig = (newSubschemaConfig.merge[typeName] = { ...((_b = (_a = subschemaConfig.merge) === null || _a === void 0 ? void 0 : _a[typeName]) !== null && _b !== void 0 ? _b : {}) });
+            if (mergedTypeConfig.entryPoints != null) {
+                mergedTypeConfig.entryPoints = mergedTypeConfig.entryPoints.map(entryPoint => ({ ...entryPoint }));
+            }
+            if (mergedTypeConfig.fields != null) {
+                const fields = (mergedTypeConfig.fields = { ...mergedTypeConfig.fields });
+                for (const fieldName in fields) {
+                    fields[fieldName] = { ...fields[fieldName] };
+                }
+            }
+        }
+    }
+    return newSubschemaConfig;
+}
+exports.cloneSubschemaConfig = cloneSubschemaConfig;

package/cjs/symbols.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIELD_SUBSCHEMA_MAP_SYMBOL = exports.OBJECT_SUBSCHEMA_SYMBOL = exports.UNPATHED_ERRORS_SYMBOL = void 0;
+exports.UNPATHED_ERRORS_SYMBOL = Symbol('subschemaErrors');
+exports.OBJECT_SUBSCHEMA_SYMBOL = Symbol('initialSubschema');
+exports.FIELD_SUBSCHEMA_MAP_SYMBOL = Symbol('subschemaMap');

package/cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbols_js_1 = require("./symbols.js");

package/esm/Subschema.js

@@ -0,0 +1,17 @@
+import { applySchemaTransforms } from './applySchemaTransforms.js';
+export function isSubschema(value) {
+    return Boolean(value.transformedSchema);
+}
+export class Subschema {
+    constructor(config) {
+        var _a;
+        this.schema = config.schema;
+        this.executor = config.executor;
+        this.batch = config.batch;
+        this.batchingOptions = config.batchingOptions;
+        this.createProxyingResolver = config.createProxyingResolver;
+        this.transforms = (_a = config.transforms) !== null && _a !== void 0 ? _a : [];
+        this.transformedSchema = applySchemaTransforms(this.schema, config);
+        this.merge = config.merge;
+    }
+}

package/esm/Transformer.js

@@ -0,0 +1,41 @@
+import { prepareGatewayDocument } from './prepareGatewayDocument.js';
+import { finalizeGatewayRequest } from './finalizeGatewayRequest.js';
+import { checkResultAndHandleErrors } from './checkResultAndHandleErrors.js';
+export class Transformer {
+    constructor(context) {
+        this.transformations = [];
+        this.delegationContext = context;
+        const transforms = context.transforms;
+        const delegationTransforms = transforms.slice().reverse();
+        for (const transform of delegationTransforms) {
+            this.addTransform(transform, {});
+        }
+    }
+    addTransform(transform, context = {}) {
+        this.transformations.push({ transform, context });
+    }
+    transformRequest(originalRequest) {
+        var _a;
+        let request = {
+            ...originalRequest,
+            document: prepareGatewayDocument(originalRequest.document, this.delegationContext.transformedSchema, this.delegationContext.returnType, (_a = this.delegationContext.info) === null || _a === void 0 ? void 0 : _a.schema),
+        };
+        for (const transformation of this.transformations) {
+            if (transformation.transform.transformRequest) {
+                request = transformation.transform.transformRequest(request, this.delegationContext, transformation.context);
+            }
+        }
+        return finalizeGatewayRequest(request, this.delegationContext);
+    }
+    transformResult(originalResult) {
+        let result = originalResult;
+        // from right to left
+        for (let i = this.transformations.length - 1; i >= 0; i--) {
+            const transformation = this.transformations[i];
+            if (transformation.transform.transformResult) {
+                result = transformation.transform.transformResult(result, this.delegationContext, transformation.context);
+            }
+        }
+        return checkResultAndHandleErrors(result, this.delegationContext);
+    }
+}

package/esm/applySchemaTransforms.js

@@ -0,0 +1,7 @@
+export function applySchemaTransforms(originalWrappingSchema, subschemaConfig) {
+    const schemaTransforms = subschemaConfig.transforms;
+    if (schemaTransforms == null) {
+        return originalWrappingSchema;
+    }
+    return schemaTransforms.reduce((schema, transform) => transform.transformSchema != null ? transform.transformSchema(schema, subschemaConfig) : schema, originalWrappingSchema);
+}

package/esm/checkResultAndHandleErrors.js

@@ -0,0 +1,72 @@
+import { responsePathAsArray, locatedError } from 'graphql';
+import { AggregateError, getResponseKeyFromInfo, relocatedError } from '@graphql-tools/utils';
+import { resolveExternalValue } from './resolveExternalValue.js';
+export function checkResultAndHandleErrors(result, delegationContext) {
+    const { context, info, fieldName: responseKey = getResponseKey(info), subschema, returnType = getReturnType(info), skipTypeMerging, onLocatedError, } = delegationContext;
+    const { data, unpathedErrors } = mergeDataAndErrors(result.data == null ? undefined : result.data[responseKey], result.errors == null ? [] : result.errors, info != null && info.path ? responsePathAsArray(info.path) : undefined, onLocatedError);
+    return resolveExternalValue(data, unpathedErrors, subschema, context, info, returnType, skipTypeMerging);
+}
+export function mergeDataAndErrors(data, errors, path, onLocatedError, index = 1) {
+    var _a;
+    if (data == null) {
+        if (!errors.length) {
+            return { data: null, unpathedErrors: [] };
+        }
+        if (errors.length === 1) {
+            const error = onLocatedError ? onLocatedError(errors[0]) : errors[0];
+            const newPath = path === undefined ? error.path : !error.path ? path : path.concat(error.path.slice(1));
+            return { data: relocatedError(errors[0], newPath), unpathedErrors: [] };
+        }
+        // We cast path as any for GraphQL.js 14 compat
+        // locatedError path argument must be defined, but it is just forwarded to a constructor that allows a undefined value
+        // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/locatedError.js#L25
+        // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/GraphQLError.js#L19
+        const combinedError = new AggregateError(errors, errors.map(error => error.message).join(', \n'));
+        const newError = locatedError(combinedError, undefined, path);
+        return { data: newError, unpathedErrors: [] };
+    }
+    if (!errors.length) {
+        return { data, unpathedErrors: [] };
+    }
+    const unpathedErrors = [];
+    const errorMap = new Map();
+    for (const error of errors) {
+        const pathSegment = (_a = error.path) === null || _a === void 0 ? void 0 : _a[index];
+        if (pathSegment != null) {
+            let pathSegmentErrors = errorMap.get(pathSegment);
+            if (pathSegmentErrors === undefined) {
+                pathSegmentErrors = [error];
+                errorMap.set(pathSegment, pathSegmentErrors);
+            }
+            else {
+                pathSegmentErrors.push(error);
+            }
+        }
+        else {
+            unpathedErrors.push(error);
+        }
+    }
+    for (const [pathSegment, pathSegmentErrors] of errorMap) {
+        if (data[pathSegment] !== undefined) {
+            const { data: newData, unpathedErrors: newErrors } = mergeDataAndErrors(data[pathSegment], pathSegmentErrors, path, onLocatedError, index + 1);
+            data[pathSegment] = newData;
+            unpathedErrors.push(...newErrors);
+        }
+        else {
+            unpathedErrors.push(...pathSegmentErrors);
+        }
+    }
+    return { data, unpathedErrors };
+}
+function getResponseKey(info) {
+    if (info == null) {
+        throw new Error(`Data cannot be extracted from result without an explicit key or source schema.`);
+    }
+    return getResponseKeyFromInfo(info);
+}
+function getReturnType(info) {
+    if (info == null) {
+        throw new Error(`Return type cannot be inferred without a source schema.`);
+    }
+    return info.returnType;
+}