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

package/esm/createRequest.js

@@ -0,0 +1,120 @@
+import { Kind, typeFromAST, } from 'graphql';
+import { createVariableNameGenerator, serializeInputValue, updateArgument, } from '@graphql-tools/utils';
+export function getDelegatingOperation(parentType, schema) {
+    if (parentType === schema.getMutationType()) {
+        return 'mutation';
+    }
+    else if (parentType === schema.getSubscriptionType()) {
+        return 'subscription';
+    }
+    return 'query';
+}
+export function createRequest({ sourceSchema, sourceParentType, sourceFieldName, fragments, variableDefinitions, variableValues, targetRootValue, targetOperationName, targetOperation, targetFieldName, selectionSet, fieldNodes, context, info, }) {
+    var _a, _b;
+    let newSelectionSet;
+    const argumentNodeMap = Object.create(null);
+    if (selectionSet != null) {
+        newSelectionSet = selectionSet;
+    }
+    else {
+        const selections = [];
+        for (const fieldNode of fieldNodes || []) {
+            if (fieldNode.selectionSet) {
+                for (const selection of fieldNode.selectionSet.selections) {
+                    selections.push(selection);
+                }
+            }
+        }
+        newSelectionSet = selections.length
+            ? {
+                kind: Kind.SELECTION_SET,
+                selections,
+            }
+            : undefined;
+        const args = (_a = fieldNodes === null || fieldNodes === void 0 ? void 0 : fieldNodes[0]) === null || _a === void 0 ? void 0 : _a.arguments;
+        if (args) {
+            for (const argNode of args) {
+                argumentNodeMap[argNode.name.value] = argNode;
+            }
+        }
+    }
+    const newVariables = Object.create(null);
+    const variableDefinitionMap = Object.create(null);
+    if (sourceSchema != null && variableDefinitions != null) {
+        for (const def of variableDefinitions) {
+            const varName = def.variable.name.value;
+            variableDefinitionMap[varName] = def;
+            const varType = typeFromAST(sourceSchema, def.type);
+            const serializedValue = serializeInputValue(varType, variableValues === null || variableValues === void 0 ? void 0 : variableValues[varName]);
+            if (serializedValue !== undefined) {
+                newVariables[varName] = serializedValue;
+            }
+        }
+    }
+    if (sourceParentType != null && sourceFieldName != null) {
+        updateArgumentsWithDefaults(sourceParentType, sourceFieldName, argumentNodeMap, variableDefinitionMap, newVariables);
+    }
+    const rootFieldName = targetFieldName !== null && targetFieldName !== void 0 ? targetFieldName : (_b = fieldNodes === null || fieldNodes === void 0 ? void 0 : fieldNodes[0]) === null || _b === void 0 ? void 0 : _b.name.value;
+    if (rootFieldName === undefined) {
+        throw new Error(`Either "targetFieldName" or a non empty "fieldNodes" array must be provided.`);
+    }
+    const rootfieldNode = {
+        kind: Kind.FIELD,
+        arguments: Object.values(argumentNodeMap),
+        name: {
+            kind: Kind.NAME,
+            value: rootFieldName,
+        },
+        selectionSet: newSelectionSet,
+    };
+    const operationName = targetOperationName
+        ? {
+            kind: Kind.NAME,
+            value: targetOperationName,
+        }
+        : undefined;
+    const operationDefinition = {
+        kind: Kind.OPERATION_DEFINITION,
+        name: operationName,
+        operation: targetOperation,
+        variableDefinitions: Object.values(variableDefinitionMap),
+        selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: [rootfieldNode],
+        },
+    };
+    const definitions = [operationDefinition];
+    if (fragments != null) {
+        for (const fragmentName in fragments) {
+            const fragment = fragments[fragmentName];
+            definitions.push(fragment);
+        }
+    }
+    const document = {
+        kind: Kind.DOCUMENT,
+        definitions,
+    };
+    return {
+        document,
+        variables: newVariables,
+        rootValue: targetRootValue,
+        operationName: targetOperationName,
+        context,
+        info,
+        operationType: targetOperation,
+    };
+}
+function updateArgumentsWithDefaults(sourceParentType, sourceFieldName, argumentNodeMap, variableDefinitionMap, variableValues) {
+    const generateVariableName = createVariableNameGenerator(variableDefinitionMap);
+    const sourceField = sourceParentType.getFields()[sourceFieldName];
+    for (const argument of sourceField.args) {
+        const argName = argument.name;
+        const sourceArgType = argument.type;
+        if (argumentNodeMap[argName] === undefined) {
+            const defaultValue = argument.defaultValue;
+            if (defaultValue !== undefined) {
+                updateArgument(argumentNodeMap, variableDefinitionMap, variableValues, argName, generateVariableName(argName), sourceArgType, serializeInputValue(sourceArgType, defaultValue));
+            }
+        }
+    }
+}

package/esm/defaultMergedResolver.js

@@ -0,0 +1,25 @@
+import { defaultFieldResolver } from 'graphql';
+import { getResponseKeyFromInfo } from '@graphql-tools/utils';
+import { resolveExternalValue } from './resolveExternalValue.js';
+import { getSubschema, getUnpathedErrors, isExternalObject } from './mergeFields.js';
+/**
+ * Resolver that knows how to:
+ * a) handle aliases for proxied schemas
+ * b) handle errors from proxied schemas
+ * c) handle external to internal enum conversion
+ */
+export function defaultMergedResolver(parent, args, context, info) {
+    if (!parent) {
+        return null;
+    }
+    const responseKey = getResponseKeyFromInfo(info);
+    // check to see if parent is not a proxied result, i.e. if parent resolver was manually overwritten
+    // See https://github.com/ardatan/graphql-tools/issues/967
+    if (!isExternalObject(parent)) {
+        return defaultFieldResolver(parent, args, context, info);
+    }
+    const data = parent[responseKey];
+    const unpathedErrors = getUnpathedErrors(parent);
+    const subschema = getSubschema(parent, responseKey);
+    return resolveExternalValue(data, unpathedErrors, subschema, context, info);
+}

package/esm/delegateToSchema.js

@@ -0,0 +1,143 @@
+import { validate, subscribe, execute, } from 'graphql';
+import { ValueOrPromise } from 'value-or-promise';
+import { getBatchingExecutor } from '@graphql-tools/batch-execute';
+import { mapAsyncIterator, AggregateError, isAsyncIterable, getDefinedRootType, memoize1, getOperationASTFromRequest, } from '@graphql-tools/utils';
+import { isSubschemaConfig } from './subschemaConfig.js';
+import { Subschema } from './Subschema.js';
+import { createRequest, getDelegatingOperation } from './createRequest.js';
+import { Transformer } from './Transformer.js';
+import { applySchemaTransforms } from './applySchemaTransforms.js';
+export function delegateToSchema(options) {
+    var _a, _b;
+    const { info, schema, rootValue = (_a = schema.rootValue) !== null && _a !== void 0 ? _a : info.rootValue, operationName = (_b = info.operation.name) === null || _b === void 0 ? void 0 : _b.value, operation = getDelegatingOperation(info.parentType, info.schema), fieldName = info.fieldName, selectionSet, fieldNodes = info.fieldNodes, context, } = options;
+    const request = createRequest({
+        sourceSchema: info.schema,
+        sourceParentType: info.parentType,
+        sourceFieldName: info.fieldName,
+        fragments: info.fragments,
+        variableDefinitions: info.operation.variableDefinitions,
+        variableValues: info.variableValues,
+        targetRootValue: rootValue,
+        targetOperationName: operationName,
+        targetOperation: operation,
+        targetFieldName: fieldName,
+        selectionSet,
+        fieldNodes,
+        context,
+        info,
+    });
+    return delegateRequest({
+        ...options,
+        request,
+    });
+}
+function getDelegationReturnType(targetSchema, operation, fieldName) {
+    const rootType = getDefinedRootType(targetSchema, operation);
+    return rootType.getFields()[fieldName].type;
+}
+export function delegateRequest(options) {
+    const delegationContext = getDelegationContext(options);
+    const transformer = new Transformer(delegationContext);
+    const processedRequest = transformer.transformRequest(options.request);
+    if (options.validateRequest) {
+        validateRequest(delegationContext, processedRequest.document);
+    }
+    const executor = getExecutor(delegationContext);
+    return new ValueOrPromise(() => executor(processedRequest))
+        .then(originalResult => {
+        if (isAsyncIterable(originalResult)) {
+            const iterator = originalResult[Symbol.asyncIterator]();
+            // "subscribe" to the subscription result and map the result through the transforms
+            return mapAsyncIterator(iterator, result => transformer.transformResult(result));
+        }
+        return transformer.transformResult(originalResult);
+    })
+        .resolve();
+}
+function getDelegationContext({ request, schema, fieldName, returnType, args, info, transforms = [], transformedSchema, skipTypeMerging = false, }) {
+    var _a, _b, _c, _d;
+    const operationDefinition = getOperationASTFromRequest(request);
+    let targetFieldName;
+    if (fieldName == null) {
+        targetFieldName = operationDefinition.selectionSet.selections[0].name.value;
+    }
+    else {
+        targetFieldName = fieldName;
+    }
+    const stitchingInfo = (_a = info === null || info === void 0 ? void 0 : info.schema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
+    const subschemaOrSubschemaConfig = (_b = stitchingInfo === null || stitchingInfo === void 0 ? void 0 : stitchingInfo.subschemaMap.get(schema)) !== null && _b !== void 0 ? _b : schema;
+    const operation = operationDefinition.operation;
+    if (isSubschemaConfig(subschemaOrSubschemaConfig)) {
+        const targetSchema = subschemaOrSubschemaConfig.schema;
+        return {
+            subschema: schema,
+            subschemaConfig: subschemaOrSubschemaConfig,
+            targetSchema,
+            operation,
+            fieldName: targetFieldName,
+            args,
+            context: request.context,
+            info,
+            returnType: (_c = returnType !== null && returnType !== void 0 ? returnType : info === null || info === void 0 ? void 0 : info.returnType) !== null && _c !== void 0 ? _c : getDelegationReturnType(targetSchema, operation, targetFieldName),
+            transforms: subschemaOrSubschemaConfig.transforms != null
+                ? subschemaOrSubschemaConfig.transforms.concat(transforms)
+                : transforms,
+            transformedSchema: transformedSchema !== null && transformedSchema !== void 0 ? transformedSchema : (subschemaOrSubschemaConfig instanceof Subschema
+                ? subschemaOrSubschemaConfig.transformedSchema
+                : applySchemaTransforms(targetSchema, subschemaOrSubschemaConfig)),
+            skipTypeMerging,
+        };
+    }
+    return {
+        subschema: schema,
+        subschemaConfig: undefined,
+        targetSchema: subschemaOrSubschemaConfig,
+        operation,
+        fieldName: targetFieldName,
+        args,
+        context: request.context,
+        info,
+        returnType: (_d = returnType !== null && returnType !== void 0 ? returnType : info === null || info === void 0 ? void 0 : info.returnType) !== null && _d !== void 0 ? _d : getDelegationReturnType(subschemaOrSubschemaConfig, operation, targetFieldName),
+        transforms,
+        transformedSchema: transformedSchema !== null && transformedSchema !== void 0 ? transformedSchema : subschemaOrSubschemaConfig,
+        skipTypeMerging,
+    };
+}
+function validateRequest(delegationContext, document) {
+    const errors = validate(delegationContext.targetSchema, document);
+    if (errors.length > 0) {
+        if (errors.length > 1) {
+            const combinedError = new AggregateError(errors, errors.map(error => error.message).join(', \n'));
+            throw combinedError;
+        }
+        const error = errors[0];
+        throw error.originalError || error;
+    }
+}
+const GLOBAL_CONTEXT = {};
+function getExecutor(delegationContext) {
+    const { subschemaConfig, targetSchema, context } = delegationContext;
+    let executor = (subschemaConfig === null || subschemaConfig === void 0 ? void 0 : subschemaConfig.executor) || createDefaultExecutor(targetSchema);
+    if (subschemaConfig === null || subschemaConfig === void 0 ? void 0 : subschemaConfig.batch) {
+        const batchingOptions = subschemaConfig === null || subschemaConfig === void 0 ? void 0 : subschemaConfig.batchingOptions;
+        executor = getBatchingExecutor(context !== null && context !== void 0 ? context : GLOBAL_CONTEXT, executor, batchingOptions === null || batchingOptions === void 0 ? void 0 : batchingOptions.dataLoaderOptions, batchingOptions === null || batchingOptions === void 0 ? void 0 : batchingOptions.extensionsReducer);
+    }
+    return executor;
+}
+export const createDefaultExecutor = memoize1(function createDefaultExecutor(schema) {
+    return function defaultExecutor(request) {
+        const executionArgs = {
+            schema,
+            document: request.document,
+            rootValue: request.rootValue,
+            contextValue: request.context,
+            variableValues: request.variables,
+            operationName: request.operationName,
+        };
+        const operationType = request.operationType || getOperationASTFromRequest(request).operation;
+        if (operationType === 'subscription') {
+            return subscribe(executionArgs);
+        }
+        return execute(executionArgs);
+    };
+});

package/esm/finalizeGatewayRequest.js

@@ -0,0 +1,313 @@
+import { getNamedType, isAbstractType, isInterfaceType, isObjectType, Kind, TypeInfo, TypeNameMetaFieldDef, versionInfo as graphqlVersionInfo, visit, visitWithTypeInfo, } from 'graphql';
+import { getDefinedRootType, serializeInputValue, updateArgument, createVariableNameGenerator, implementsAbstractType, inspect, } from '@graphql-tools/utils';
+import { getDocumentMetadata } from './getDocumentMetadata.js';
+function finalizeGatewayDocument(targetSchema, fragments, operations) {
+    var _a;
+    let usedVariables = [];
+    let usedFragments = [];
+    const newOperations = [];
+    let newFragments = [];
+    const validFragments = [];
+    const validFragmentsWithType = Object.create(null);
+    for (const fragment of fragments) {
+        const typeName = fragment.typeCondition.name.value;
+        const type = targetSchema.getType(typeName);
+        if (type != null) {
+            validFragments.push(fragment);
+            validFragmentsWithType[fragment.name.value] = type;
+        }
+    }
+    let fragmentSet = Object.create(null);
+    for (const operation of operations) {
+        const type = getDefinedRootType(targetSchema, operation.operation);
+        const { selectionSet, usedFragments: operationUsedFragments, usedVariables: operationUsedVariables, } = finalizeSelectionSet(targetSchema, type, validFragmentsWithType, operation.selectionSet);
+        usedFragments = union(usedFragments, operationUsedFragments);
+        const { usedVariables: collectedUsedVariables, newFragments: collectedNewFragments, fragmentSet: collectedFragmentSet, } = collectFragmentVariables(targetSchema, fragmentSet, validFragments, validFragmentsWithType, usedFragments);
+        const operationOrFragmentVariables = union(operationUsedVariables, collectedUsedVariables);
+        usedVariables = union(usedVariables, operationOrFragmentVariables);
+        newFragments = collectedNewFragments;
+        fragmentSet = collectedFragmentSet;
+        const variableDefinitions = ((_a = operation.variableDefinitions) !== null && _a !== void 0 ? _a : []).filter((variable) => operationOrFragmentVariables.indexOf(variable.variable.name.value) !== -1);
+        newOperations.push({
+            kind: Kind.OPERATION_DEFINITION,
+            operation: operation.operation,
+            name: operation.name,
+            directives: operation.directives,
+            variableDefinitions,
+            selectionSet,
+        });
+    }
+    const newDocument = {
+        kind: Kind.DOCUMENT,
+        definitions: [...newOperations, ...newFragments],
+    };
+    return {
+        usedVariables,
+        newDocument,
+    };
+}
+export function finalizeGatewayRequest(originalRequest, delegationContext) {
+    let { document, variables } = originalRequest;
+    let { operations, fragments } = getDocumentMetadata(document);
+    const { targetSchema, args } = delegationContext;
+    if (args) {
+        const requestWithNewVariables = addVariablesToRootFields(targetSchema, operations, args);
+        operations = requestWithNewVariables.newOperations;
+        variables = Object.assign({}, variables !== null && variables !== void 0 ? variables : {}, requestWithNewVariables.newVariables);
+    }
+    const { usedVariables, newDocument } = finalizeGatewayDocument(targetSchema, fragments, operations);
+    const newVariables = {};
+    if (variables != null) {
+        for (const variableName of usedVariables) {
+            const variableValue = variables[variableName];
+            if (variableValue !== undefined) {
+                newVariables[variableName] = variableValue;
+            }
+        }
+    }
+    return {
+        ...originalRequest,
+        document: newDocument,
+        variables: newVariables,
+    };
+}
+function addVariablesToRootFields(targetSchema, operations, args) {
+    const newVariables = Object.create(null);
+    const newOperations = operations.map((operation) => {
+        var _a, _b;
+        const variableDefinitionMap = ((_a = operation.variableDefinitions) !== null && _a !== void 0 ? _a : []).reduce((prev, def) => ({
+            ...prev,
+            [def.variable.name.value]: def,
+        }), {});
+        const type = getDefinedRootType(targetSchema, operation.operation);
+        const newSelections = [];
+        for (const selection of operation.selectionSet.selections) {
+            if (selection.kind === Kind.FIELD) {
+                const argumentNodes = (_b = selection.arguments) !== null && _b !== void 0 ? _b : [];
+                const argumentNodeMap = argumentNodes.reduce((prev, argument) => ({
+                    ...prev,
+                    [argument.name.value]: argument,
+                }), {});
+                const targetField = type.getFields()[selection.name.value];
+                // excludes __typename
+                if (targetField != null) {
+                    updateArguments(targetField, argumentNodeMap, variableDefinitionMap, newVariables, args);
+                }
+                newSelections.push({
+                    ...selection,
+                    arguments: Object.values(argumentNodeMap),
+                });
+            }
+            else {
+                newSelections.push(selection);
+            }
+        }
+        const newSelectionSet = {
+            kind: Kind.SELECTION_SET,
+            selections: newSelections,
+        };
+        return {
+            ...operation,
+            variableDefinitions: Object.values(variableDefinitionMap),
+            selectionSet: newSelectionSet,
+        };
+    });
+    return {
+        newOperations,
+        newVariables,
+    };
+}
+function updateArguments(targetField, argumentNodeMap, variableDefinitionMap, variableValues, newArgs) {
+    const generateVariableName = createVariableNameGenerator(variableDefinitionMap);
+    for (const argument of targetField.args) {
+        const argName = argument.name;
+        const argType = argument.type;
+        if (argName in newArgs) {
+            updateArgument(argumentNodeMap, variableDefinitionMap, variableValues, argName, generateVariableName(argName), argType, serializeInputValue(argType, newArgs[argName]));
+        }
+    }
+}
+function collectFragmentVariables(targetSchema, fragmentSet, validFragments, validFragmentsWithType, usedFragments) {
+    let remainingFragments = usedFragments.slice();
+    let usedVariables = [];
+    const newFragments = [];
+    while (remainingFragments.length !== 0) {
+        const nextFragmentName = remainingFragments.pop();
+        const fragment = validFragments.find(fr => fr.name.value === nextFragmentName);
+        if (fragment != null) {
+            const name = nextFragmentName;
+            const typeName = fragment.typeCondition.name.value;
+            const type = targetSchema.getType(typeName);
+            if (type == null) {
+                throw new Error(`Fragment reference type "${typeName}", but the type is not contained within the target schema.`);
+            }
+            const { selectionSet, usedFragments: fragmentUsedFragments, usedVariables: fragmentUsedVariables, } = finalizeSelectionSet(targetSchema, type, validFragmentsWithType, fragment.selectionSet);
+            remainingFragments = union(remainingFragments, fragmentUsedFragments);
+            usedVariables = union(usedVariables, fragmentUsedVariables);
+            if (name && !(name in fragmentSet)) {
+                fragmentSet[name] = true;
+                newFragments.push({
+                    kind: Kind.FRAGMENT_DEFINITION,
+                    name: {
+                        kind: Kind.NAME,
+                        value: name,
+                    },
+                    typeCondition: fragment.typeCondition,
+                    selectionSet,
+                });
+            }
+        }
+    }
+    return {
+        usedVariables,
+        newFragments,
+        fragmentSet,
+    };
+}
+const filteredSelectionSetVisitorKeys = {
+    SelectionSet: ['selections'],
+    Field: ['selectionSet'],
+    InlineFragment: ['selectionSet'],
+    FragmentDefinition: ['selectionSet'],
+};
+const variablesVisitorKeys = {
+    SelectionSet: ['selections'],
+    Field: ['arguments', 'directives', 'selectionSet'],
+    Argument: ['value'],
+    InlineFragment: ['directives', 'selectionSet'],
+    FragmentSpread: ['directives'],
+    FragmentDefinition: ['selectionSet'],
+    ObjectValue: ['fields'],
+    ObjectField: ['name', 'value'],
+    Directive: ['arguments'],
+    ListValue: ['values'],
+};
+function finalizeSelectionSet(schema, type, validFragments, selectionSet) {
+    const usedFragments = [];
+    const usedVariables = [];
+    const typeInfo = graphqlVersionInfo.major < 16 ? new TypeInfo(schema, undefined, type) : new TypeInfo(schema, type);
+    const filteredSelectionSet = visit(selectionSet, visitWithTypeInfo(typeInfo, {
+        [Kind.FIELD]: {
+            enter: node => {
+                const parentType = typeInfo.getParentType();
+                if (isObjectType(parentType) || isInterfaceType(parentType)) {
+                    const fields = parentType.getFields();
+                    const field = node.name.value === '__typename' ? TypeNameMetaFieldDef : fields[node.name.value];
+                    if (!field) {
+                        return null;
+                    }
+                    const args = field.args != null ? field.args : [];
+                    const argsMap = Object.create(null);
+                    for (const arg of args) {
+                        argsMap[arg.name] = arg;
+                    }
+                    if (node.arguments != null) {
+                        const newArgs = [];
+                        for (const arg of node.arguments) {
+                            if (arg.name.value in argsMap) {
+                                newArgs.push(arg);
+                            }
+                        }
+                        if (newArgs.length !== node.arguments.length) {
+                            return {
+                                ...node,
+                                arguments: newArgs,
+                            };
+                        }
+                    }
+                }
+            },
+            leave: node => {
+                const type = typeInfo.getType();
+                if (type == null) {
+                    throw new Error(`No type was found for field node ${inspect(node)}.`);
+                }
+                const namedType = getNamedType(type);
+                if (!schema.getType(namedType.name) == null) {
+                    return null;
+                }
+                if (isObjectType(namedType) || isInterfaceType(namedType)) {
+                    const selections = node.selectionSet != null ? node.selectionSet.selections : null;
+                    if (selections == null || selections.length === 0) {
+                        return null;
+                    }
+                }
+            },
+        },
+        [Kind.FRAGMENT_SPREAD]: {
+            enter: node => {
+                if (!(node.name.value in validFragments)) {
+                    return null;
+                }
+                const parentType = typeInfo.getParentType();
+                const innerType = validFragments[node.name.value];
+                if (!implementsAbstractType(schema, parentType, innerType)) {
+                    return null;
+                }
+                usedFragments.push(node.name.value);
+            },
+        },
+        [Kind.INLINE_FRAGMENT]: {
+            enter: node => {
+                if (node.typeCondition != null) {
+                    const parentType = typeInfo.getParentType();
+                    const innerType = schema.getType(node.typeCondition.name.value);
+                    if (!implementsAbstractType(schema, parentType, innerType)) {
+                        return null;
+                    }
+                }
+            },
+        },
+        [Kind.SELECTION_SET]: {
+            leave: node => {
+                const parentType = typeInfo.getParentType();
+                if (parentType != null && isAbstractType(parentType)) {
+                    const selections = node.selections.concat([
+                        {
+                            kind: Kind.FIELD,
+                            name: {
+                                kind: Kind.NAME,
+                                value: '__typename',
+                            },
+                        },
+                    ]);
+                    return {
+                        ...node,
+                        selections,
+                    };
+                }
+            },
+        },
+    }), 
+    // 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
+    filteredSelectionSetVisitorKeys);
+    visit(filteredSelectionSet, {
+        [Kind.VARIABLE]: variableNode => {
+            usedVariables.push(variableNode.name.value);
+        },
+    }, 
+    // 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
+    variablesVisitorKeys);
+    return {
+        selectionSet: filteredSelectionSet,
+        usedFragments,
+        usedVariables,
+    };
+}
+function union(...arrays) {
+    const cache = Object.create(null);
+    const result = [];
+    for (const array of arrays) {
+        for (const item of array) {
+            if (!(item in cache)) {
+                cache[item] = true;
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}

package/esm/getDocumentMetadata.js

@@ -0,0 +1,21 @@
+import { Kind } from 'graphql';
+export function getDocumentMetadata(document) {
+    const operations = [];
+    const fragments = [];
+    const fragmentNames = new Set();
+    for (let i = 0; i < document.definitions.length; i++) {
+        const def = document.definitions[i];
+        if (def.kind === Kind.FRAGMENT_DEFINITION) {
+            fragments.push(def);
+            fragmentNames.add(def.name.value);
+        }
+        else if (def.kind === Kind.OPERATION_DEFINITION) {
+            operations.push(def);
+        }
+    }
+    return {
+        operations,
+        fragments,
+        fragmentNames,
+    };
+}

package/esm/index.js

@@ -0,0 +1,10 @@
+export * from './Subschema.js';
+export * from './Transformer.js';
+export * from './applySchemaTransforms.js';
+export * from './createRequest.js';
+export * from './defaultMergedResolver.js';
+export * from './delegateToSchema.js';
+export * from './mergeFields.js';
+export * from './resolveExternalValue.js';
+export * from './subschemaConfig.js';
+export * from './types.js';