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

package/esm/mergeFields.js

@@ -0,0 +1,79 @@
+import { responsePathAsArray, GraphQLError, locatedError, } from 'graphql';
+import { collectFields, relocatedError } from '@graphql-tools/utils';
+import { FIELD_SUBSCHEMA_MAP_SYMBOL, OBJECT_SUBSCHEMA_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols.js';
+export function isExternalObject(data) {
+    return data[UNPATHED_ERRORS_SYMBOL] !== undefined;
+}
+export function annotateExternalObject(object, errors, subschema, subschemaMap) {
+    Object.defineProperties(object, {
+        [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema },
+        [FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap },
+        [UNPATHED_ERRORS_SYMBOL]: { value: errors },
+    });
+    return object;
+}
+export function getSubschema(object, responseKey) {
+    var _a;
+    return (_a = object[FIELD_SUBSCHEMA_MAP_SYMBOL][responseKey]) !== null && _a !== void 0 ? _a : object[OBJECT_SUBSCHEMA_SYMBOL];
+}
+export function getUnpathedErrors(object) {
+    return object[UNPATHED_ERRORS_SYMBOL];
+}
+const EMPTY_ARRAY = [];
+const EMPTY_OBJECT = Object.create(null);
+export async function mergeFields(mergedTypeInfo, object, sourceSubschema, context, info) {
+    var _a;
+    const delegationMaps = mergedTypeInfo.delegationPlanBuilder(info.schema, sourceSubschema, info.variableValues != null && Object.keys(info.variableValues).length > 0 ? info.variableValues : EMPTY_OBJECT, info.fragments != null && Object.keys(info.fragments).length > 0 ? info.fragments : EMPTY_OBJECT, ((_a = info.fieldNodes) === null || _a === void 0 ? void 0 : _a.length) ? info.fieldNodes : EMPTY_ARRAY);
+    for (const delegationMap of delegationMaps) {
+        await executeDelegationStage(mergedTypeInfo, delegationMap, object, context, info);
+    }
+    return object;
+}
+async function executeDelegationStage(mergedTypeInfo, delegationMap, object, context, info) {
+    const combinedErrors = object[UNPATHED_ERRORS_SYMBOL];
+    const path = responsePathAsArray(info.path);
+    const combinedFieldSubschemaMap = object[FIELD_SUBSCHEMA_MAP_SYMBOL];
+    await Promise.all([...delegationMap.entries()].map(async ([subschema, selectionSet]) => {
+        var _a;
+        const schema = subschema.transformedSchema || info.schema;
+        const type = schema.getType(object.__typename);
+        const resolver = mergedTypeInfo.resolvers.get(subschema);
+        if (resolver) {
+            let source;
+            try {
+                source = await resolver(object, context, info, subschema, selectionSet, undefined, type);
+            }
+            catch (error) {
+                source = error;
+            }
+            if (source instanceof Error || source == null) {
+                const fieldNodeResponseKeyMap = collectFields(schema, EMPTY_OBJECT, EMPTY_OBJECT, type, selectionSet, new Map(), new Set());
+                const nullResult = {};
+                for (const [responseKey, fieldNodes] of fieldNodeResponseKeyMap) {
+                    const combinedPath = [...path, responseKey];
+                    if (source instanceof GraphQLError) {
+                        nullResult[responseKey] = relocatedError(source, combinedPath);
+                    }
+                    else if (source instanceof Error) {
+                        nullResult[responseKey] = locatedError(source, fieldNodes, combinedPath);
+                    }
+                    else {
+                        nullResult[responseKey] = null;
+                    }
+                }
+                source = nullResult;
+            }
+            else {
+                if (source[UNPATHED_ERRORS_SYMBOL]) {
+                    combinedErrors.push(...source[UNPATHED_ERRORS_SYMBOL]);
+                }
+            }
+            const objectSubschema = source[OBJECT_SUBSCHEMA_SYMBOL];
+            const fieldSubschemaMap = source[FIELD_SUBSCHEMA_MAP_SYMBOL];
+            for (const responseKey in source) {
+                object[responseKey] = source[responseKey];
+                combinedFieldSubschemaMap[responseKey] = (_a = fieldSubschemaMap === null || fieldSubschemaMap === void 0 ? void 0 : fieldSubschemaMap[responseKey]) !== null && _a !== void 0 ? _a : objectSubschema;
+            }
+        }
+    }));
+}

package/esm/prepareGatewayDocument.js

@@ -0,0 +1,307 @@
+import { Kind, TypeInfo, getNamedType, isAbstractType, isInterfaceType, visit, visitWithTypeInfo, isObjectType, } from 'graphql';
+import { implementsAbstractType, getRootTypeNames, memoize2 } from '@graphql-tools/utils';
+import { getDocumentMetadata } from './getDocumentMetadata.js';
+export 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 } = getDocumentMetadata(wrappedConcreteTypesDocument);
+    const { expandedFragments, fragmentReplacements } = getExpandedFragments(fragments, fragmentNames, possibleTypesMap);
+    const typeInfo = new TypeInfo(transformedSchema);
+    const expandedDocument = {
+        kind: Kind.DOCUMENT,
+        definitions: [...operations, ...fragments, ...expandedFragments],
+    };
+    const visitorKeyMap = {
+        Document: ['definitions'],
+        OperationDefinition: ['selectionSet'],
+        SelectionSet: ['selections'],
+        Field: ['selectionSet'],
+        InlineFragment: ['selectionSet'],
+        FragmentDefinition: ['selectionSet'],
+    };
+    return visit(expandedDocument, visitWithTypeInfo(typeInfo, {
+        [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);
+}
+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 = 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 === 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 && implementsAbstractType(schema, parentType, maybePossibleType)) {
+                            newSelections.add(generateInlineFragment(possibleTypeName, selection.selectionSet));
+                        }
+                    }
+                }
+            }
+            else if (selection.kind === 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 && implementsAbstractType(schema, parentType, maybeType)) {
+                        newSelections.add({
+                            kind: Kind.FRAGMENT_SPREAD,
+                            name: {
+                                kind: 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: Kind.FIELD,
+                name: {
+                    kind: 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: Kind.SELECTION_SET,
+                        selections: interfaceExtensionFields,
+                    }));
+                }
+            }
+        }
+        return {
+            ...node,
+            selections: Array.from(newSelections),
+        };
+    }
+    return node;
+}
+function generateInlineFragment(typeName, selectionSet) {
+    return {
+        kind: Kind.INLINE_FRAGMENT,
+        typeCondition: {
+            kind: Kind.NAMED_TYPE,
+            name: {
+                kind: Kind.NAME,
+                value: typeName,
+            },
+        },
+        selectionSet,
+    };
+}
+const getSchemaMetaData = 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 (isAbstractType(type)) {
+            const targetType = targetTypeMap[typeName];
+            if (isInterfaceType(type) && 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] || !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: Kind.FRAGMENT_DEFINITION,
+                    name: {
+                        kind: Kind.NAME,
+                        value: name,
+                    },
+                    typeCondition: {
+                        kind: Kind.NAMED_TYPE,
+                        name: {
+                            kind: Kind.NAME,
+                            value: possibleTypeName,
+                        },
+                    },
+                    selectionSet: fragment.selectionSet,
+                });
+                fragmentReplacements[fragmentName].push({
+                    fragmentName: name,
+                    typeName: possibleTypeName,
+                });
+            }
+        }
+    }
+    return {
+        expandedFragments,
+        fragmentReplacements,
+    };
+}
+function wrapConcreteTypes(returnType, targetSchema, document) {
+    const namedType = getNamedType(returnType);
+    if (!isObjectType(namedType)) {
+        return document;
+    }
+    const rootTypeNames = getRootTypeNames(targetSchema);
+    const typeInfo = new TypeInfo(targetSchema);
+    const visitorKeys = {
+        Document: ['definitions'],
+        OperationDefinition: ['selectionSet'],
+        SelectionSet: ['selections'],
+        InlineFragment: ['selectionSet'],
+        FragmentDefinition: ['selectionSet'],
+    };
+    return visit(document, visitWithTypeInfo(typeInfo, {
+        [Kind.FRAGMENT_DEFINITION]: (node) => {
+            const typeName = node.typeCondition.name.value;
+            if (!rootTypeNames.has(typeName)) {
+                return false;
+            }
+        },
+        [Kind.FIELD]: (node) => {
+            const type = typeInfo.getType();
+            if (type != null && isAbstractType(getNamedType(type))) {
+                return {
+                    ...node,
+                    selectionSet: {
+                        kind: Kind.SELECTION_SET,
+                        selections: [
+                            {
+                                kind: Kind.INLINE_FRAGMENT,
+                                typeCondition: {
+                                    kind: Kind.NAMED_TYPE,
+                                    name: {
+                                        kind: 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/esm/resolveExternalValue.js

@@ -0,0 +1,99 @@
+import { getNullableType, isCompositeType, isListType, isAbstractType, locatedError, } from 'graphql';
+import { AggregateError } from '@graphql-tools/utils';
+import { annotateExternalObject, isExternalObject, mergeFields } from './mergeFields.js';
+export function resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType(info), skipTypeMerging) {
+    const type = getNullableType(returnType);
+    if (result instanceof Error) {
+        return result;
+    }
+    if (result == null) {
+        return reportUnpathedErrorsViaNull(unpathedErrors);
+    }
+    if ('parseValue' in type) {
+        return type.parseValue(result);
+    }
+    else if (isCompositeType(type)) {
+        return resolveExternalObject(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+    else if (isListType(type)) {
+        return resolveExternalList(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+}
+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 (!isExternalObject(object)) {
+        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 = 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 mergeFields(mergedTypeInfo, object, subschema, context, info);
+}
+function resolveExternalList(type, list, unpathedErrors, subschema, context, info, skipTypeMerging) {
+    return list.map(listMember => resolveExternalListMember(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 (isCompositeType(type)) {
+        return resolveExternalObject(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging);
+    }
+    else if (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 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 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/esm/subschemaConfig.js

@@ -0,0 +1,26 @@
+export function isSubschemaConfig(value) {
+    return Boolean(value === null || value === void 0 ? void 0 : value.schema);
+}
+export 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;
+}

package/esm/symbols.js

@@ -0,0 +1,3 @@
+export const UNPATHED_ERRORS_SYMBOL = Symbol('subschemaErrors');
+export const OBJECT_SUBSCHEMA_SYMBOL = Symbol('initialSubschema');
+export const FIELD_SUBSCHEMA_MAP_SYMBOL = Symbol('subschemaMap');

package/esm/types.js

@@ -0,0 +1 @@
+import { OBJECT_SUBSCHEMA_SYMBOL, FIELD_SUBSCHEMA_MAP_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols.js';

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@graphql-tools/delegate",
-  "version": "9.0.0-alpha-e2ab84c8.0",
+  "version": "9.0.0-alpha-25204a2f.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
-    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/batch-execute": "8.1.1-alpha-e2ab84c8.0",
-    "@graphql-tools/schema": "8.2.1-alpha-e2ab84c8.0",
-    "@graphql-tools/utils": "9.0.0-alpha-e2ab84c8.0",
-    "dataloader": "2.0.0",
-    "tslib": "~2.3.0",
-    "value-or-promise": "1.0.10"
+    "@graphql-tools/batch-execute": "8.5.0",
+    "@graphql-tools/schema": "8.5.0",
+    "@graphql-tools/utils": "8.8.0",
+    "dataloader": "2.1.0",
+    "tslib": "~2.4.0",
+    "value-or-promise": "1.0.11"
   },
   "repository": {
     "type": "git",
@@ -20,20 +20,42 @@
     "directory": "packages/delegate"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
-    }
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./package.json": "./package.json"
   }
-}
+}

package/{Subschema.d.ts → typings/Subschema.d.ts}

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
-import { SubschemaConfig, Transform, MergedTypeConfig, CreateProxyingResolverFn, BatchingOptions } from './types';
+import { SubschemaConfig, Transform, MergedTypeConfig, CreateProxyingResolverFn, BatchingOptions } from './types.js';
 import { Executor } from '@graphql-tools/utils';
 export declare function isSubschema(value: any): value is Subschema;
-export declare class Subschema<K = any, V = any, C = K, TContext = Record<string, any>> implements SubschemaConfig<K, V, C, TContext> {
+interface ISubschema<K = any, V = any, C = K, TContext = Record<string, any>> extends SubschemaConfig<K, V, C, TContext> {
+    transformedSchema: GraphQLSchema;
+}
+export declare class Subschema<K = any, V = any, C = K, TContext = Record<string, any>> implements ISubschema<K, V, C, TContext> {
     schema: GraphQLSchema;
     executor?: Executor<TContext>;
     batch?: boolean;
@@ -10,6 +13,7 @@ export declare class Subschema<K = any, V = any, C = K, TContext = Record<string
     createProxyingResolver?: CreateProxyingResolverFn<TContext>;
     transforms: Array<Transform<any, TContext>>;
     transformedSchema: GraphQLSchema;
-    merge?: Record<string, MergedTypeConfig<any, TContext>>;
+    merge?: Record<string, MergedTypeConfig<any, any, TContext>>;
     constructor(config: SubschemaConfig<K, V, C, TContext>);
 }
+export {};

package/{Transformer.d.ts → typings/Transformer.d.ts}

@@ -1,10 +1,10 @@
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
-import { DelegationContext } from './types';
-export declare class Transformer<TContext = Record<string, any>> {
+import { DelegationContext } from './types.js';
+export declare class Transformer<TContext extends Record<string, any> = Record<string, any>> {
     private transformations;
     private delegationContext;
     constructor(context: DelegationContext<TContext>);
     private addTransform;
     transformRequest(originalRequest: ExecutionRequest): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult): ExecutionResult;
+    transformResult(originalResult: ExecutionResult): any;
 }

package/{applySchemaTransforms.d.ts → typings/applySchemaTransforms.d.ts}

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
-import { SubschemaConfig } from './types';
-export declare function applySchemaTransforms(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, any>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+import { SubschemaConfig } from './types.js';
+export declare function applySchemaTransforms(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, any>): GraphQLSchema;

package/typings/checkResultAndHandleErrors.d.ts

@@ -0,0 +1,8 @@
+import { GraphQLError } from 'graphql';
+import { ExecutionResult } from '@graphql-tools/utils';
+import { DelegationContext } from './types.js';
+export declare function checkResultAndHandleErrors<TContext extends Record<string, any>>(result: ExecutionResult, delegationContext: DelegationContext<TContext>): any;
+export declare function mergeDataAndErrors(data: any, errors: ReadonlyArray<GraphQLError>, path: Array<string | number> | undefined, onLocatedError?: (originalError: GraphQLError) => GraphQLError, index?: number): {
+    data: any;
+    unpathedErrors: Array<GraphQLError>;
+};

package/{createRequest.d.ts → typings/createRequest.d.ts}

@@ -1,6 +1,5 @@
 import { GraphQLSchema, GraphQLObjectType, OperationTypeNode } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
-import { ICreateRequestFromInfo, ICreateRequest } from './types';
+import { ICreateRequest } from './types.js';
 export declare function getDelegatingOperation(parentType: GraphQLObjectType, schema: GraphQLSchema): OperationTypeNode;
-export declare function createRequestFromInfo({ info, rootValue, operationName, operation, fieldName, selectionSet, fieldNodes, context, }: ICreateRequestFromInfo): ExecutionRequest;
 export declare function createRequest({ sourceSchema, sourceParentType, sourceFieldName, fragments, variableDefinitions, variableValues, targetRootValue, targetOperationName, targetOperation, targetFieldName, selectionSet, fieldNodes, context, info, }: ICreateRequest): ExecutionRequest;