@apollo/gateway 0.300.0-alpha.2 → 2.0.0-alpha.2

package/dist/buildQueryPlan.js

@@ -1,670 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryPlanningContext = exports.buildQueryPlanningContext = exports.buildOperationContext = exports.collectSubfields = exports.buildQueryPlan = void 0;
-const apollo_env_1 = require("apollo-env");
-const graphql_1 = require("graphql");
-const FieldSet_1 = require("./FieldSet");
-const graphql_2 = require("./utilities/graphql");
-const MultiMap_1 = require("./utilities/MultiMap");
-const utils_1 = require("@apollo/federation/dist/composition/utils");
-const typenameField = {
-    kind: graphql_1.Kind.FIELD,
-    name: {
-        kind: graphql_1.Kind.NAME,
-        value: graphql_1.TypeNameMetaFieldDef.name,
-    },
-};
-function buildQueryPlan(operationContext, options = { autoFragmentization: false }) {
-    const context = buildQueryPlanningContext(operationContext, options);
-    if (context.operation.operation === 'subscription') {
-        throw new graphql_1.GraphQLError('Query planning does not support subscriptions for now.', [context.operation]);
-    }
-    const rootType = graphql_1.getOperationRootType(context.schema, context.operation);
-    const isMutation = context.operation.operation === 'mutation';
-    const fields = collectFields(context, context.newScope(rootType), context.operation.selectionSet);
-    const groups = isMutation
-        ? splitRootFieldsSerially(context, fields)
-        : splitRootFields(context, fields);
-    const nodes = groups.map(group => executionNodeForGroup(context, group, rootType));
-    return {
-        kind: 'QueryPlan',
-        node: nodes.length
-            ? flatWrap(isMutation ? 'Sequence' : 'Parallel', nodes)
-            : undefined,
-    };
-}
-exports.buildQueryPlan = buildQueryPlan;
-function executionNodeForGroup(context, { serviceName, fields, requiredFields, internalFragments, mergeAt, dependentGroups, }, parentType) {
-    const selectionSet = FieldSet_1.selectionSetFromFieldSet(fields, parentType);
-    const requires = requiredFields.length > 0
-        ? FieldSet_1.selectionSetFromFieldSet(requiredFields)
-        : undefined;
-    const variableUsages = context.getVariableUsages(selectionSet, internalFragments);
-    const operation = requires
-        ? operationForEntitiesFetch({
-            selectionSet,
-            variableUsages,
-            internalFragments,
-        })
-        : operationForRootFetch({
-            selectionSet,
-            variableUsages,
-            internalFragments,
-            operation: context.operation.operation,
-        });
-    const fetchNode = {
-        kind: 'Fetch',
-        serviceName,
-        selectionSet,
-        requires,
-        variableUsages,
-        internalFragments,
-        source: graphql_1.stripIgnoredCharacters(graphql_1.print(operation)),
-    };
-    const node = mergeAt && mergeAt.length > 0
-        ? {
-            kind: 'Flatten',
-            path: mergeAt,
-            node: fetchNode,
-        }
-        : fetchNode;
-    if (dependentGroups.length > 0) {
-        const dependentNodes = dependentGroups.map(dependentGroup => executionNodeForGroup(context, dependentGroup));
-        return flatWrap('Sequence', [node, flatWrap('Parallel', dependentNodes)]);
-    }
-    else {
-        return node;
-    }
-}
-function mapFetchNodeToVariableDefinitions(variableUsages) {
-    return variableUsages ? Object.values(variableUsages) : [];
-}
-function operationForRootFetch({ selectionSet, variableUsages, internalFragments, operation = 'query', }) {
-    return {
-        kind: graphql_1.Kind.DOCUMENT,
-        definitions: [
-            {
-                kind: graphql_1.Kind.OPERATION_DEFINITION,
-                operation,
-                selectionSet,
-                variableDefinitions: mapFetchNodeToVariableDefinitions(variableUsages),
-            },
-            ...internalFragments,
-        ],
-    };
-}
-function operationForEntitiesFetch({ selectionSet, variableUsages, internalFragments, }) {
-    const representationsVariable = {
-        kind: graphql_1.Kind.VARIABLE,
-        name: { kind: graphql_1.Kind.NAME, value: 'representations' },
-    };
-    return {
-        kind: graphql_1.Kind.DOCUMENT,
-        definitions: [
-            {
-                kind: graphql_1.Kind.OPERATION_DEFINITION,
-                operation: 'query',
-                variableDefinitions: [
-                    {
-                        kind: graphql_1.Kind.VARIABLE_DEFINITION,
-                        variable: representationsVariable,
-                        type: {
-                            kind: graphql_1.Kind.NON_NULL_TYPE,
-                            type: {
-                                kind: graphql_1.Kind.LIST_TYPE,
-                                type: {
-                                    kind: graphql_1.Kind.NON_NULL_TYPE,
-                                    type: {
-                                        kind: graphql_1.Kind.NAMED_TYPE,
-                                        name: { kind: graphql_1.Kind.NAME, value: '_Any' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ].concat(mapFetchNodeToVariableDefinitions(variableUsages)),
-                selectionSet: {
-                    kind: graphql_1.Kind.SELECTION_SET,
-                    selections: [
-                        {
-                            kind: graphql_1.Kind.FIELD,
-                            name: { kind: graphql_1.Kind.NAME, value: '_entities' },
-                            arguments: [
-                                {
-                                    kind: graphql_1.Kind.ARGUMENT,
-                                    name: {
-                                        kind: graphql_1.Kind.NAME,
-                                        value: representationsVariable.name.value,
-                                    },
-                                    value: representationsVariable,
-                                },
-                            ],
-                            selectionSet,
-                        },
-                    ],
-                },
-            },
-            ...internalFragments,
-        ],
-    };
-}
-function flatWrap(kind, nodes) {
-    if (nodes.length === 0) {
-        throw Error('programming error: should always be called with nodes');
-    }
-    if (nodes.length === 1) {
-        return nodes[0];
-    }
-    return {
-        kind,
-        nodes: nodes.flatMap(n => (n.kind === kind ? n.nodes : [n])),
-    };
-}
-function splitRootFields(context, fields) {
-    const groupsByService = Object.create(null);
-    function groupForService(serviceName) {
-        let group = groupsByService[serviceName];
-        if (!group) {
-            group = new FetchGroup(serviceName);
-            groupsByService[serviceName] = group;
-        }
-        return group;
-    }
-    splitFields(context, [], fields, field => {
-        const { scope, fieldNode, fieldDef } = field;
-        const { parentType } = scope;
-        const owningService = context.getOwningService(parentType, fieldDef);
-        if (!owningService) {
-            throw new graphql_1.GraphQLError(`Couldn't find owning service for field "${parentType.name}.${fieldDef.name}"`, fieldNode);
-        }
-        return groupForService(owningService);
-    });
-    return Object.values(groupsByService);
-}
-function splitRootFieldsSerially(context, fields) {
-    const fetchGroups = [];
-    function groupForField(serviceName) {
-        let group;
-        const previousGroup = fetchGroups[fetchGroups.length - 1];
-        if (previousGroup && previousGroup.serviceName === serviceName) {
-            return previousGroup;
-        }
-        group = new FetchGroup(serviceName);
-        fetchGroups.push(group);
-        return group;
-    }
-    splitFields(context, [], fields, field => {
-        const { scope, fieldNode, fieldDef } = field;
-        const { parentType } = scope;
-        const owningService = context.getOwningService(parentType, fieldDef);
-        if (!owningService) {
-            throw new graphql_1.GraphQLError(`Couldn't find owning service for field "${parentType.name}.${fieldDef.name}"`, fieldNode);
-        }
-        return groupForField(owningService);
-    });
-    return fetchGroups;
-}
-function splitSubfields(context, path, fields, parentGroup) {
-    splitFields(context, path, fields, field => {
-        const { scope, fieldNode, fieldDef } = field;
-        const { parentType } = scope;
-        let baseService, owningService;
-        const parentTypeFederationMetadata = utils_1.getFederationMetadata(parentType);
-        if (parentTypeFederationMetadata === null || parentTypeFederationMetadata === void 0 ? void 0 : parentTypeFederationMetadata.isValueType) {
-            baseService = parentGroup.serviceName;
-            owningService = parentGroup.serviceName;
-        }
-        else {
-            baseService = context.getBaseService(parentType);
-            owningService = context.getOwningService(parentType, fieldDef);
-        }
-        if (!baseService) {
-            throw new graphql_1.GraphQLError(`Couldn't find base service for type "${parentType.name}"`, fieldNode);
-        }
-        if (!owningService) {
-            throw new graphql_1.GraphQLError(`Couldn't find owning service for field "${parentType.name}.${fieldDef.name}"`, fieldNode);
-        }
-        if (owningService === baseService) {
-            if (owningService === parentGroup.serviceName ||
-                parentGroup.providedFields.some(FieldSet_1.matchesField(field))) {
-                return parentGroup;
-            }
-            else {
-                let keyFields = context.getKeyFields({
-                    parentType,
-                    serviceName: parentGroup.serviceName,
-                });
-                if (keyFields.length === 0 ||
-                    (keyFields.length === 1 &&
-                        keyFields[0].fieldDef.name === '__typename')) {
-                    keyFields = context.getKeyFields({
-                        parentType,
-                        serviceName: owningService,
-                    });
-                }
-                return parentGroup.dependentGroupForService(owningService, keyFields);
-            }
-        }
-        else {
-            const requiredFields = context.getRequiredFields(parentType, fieldDef, owningService);
-            if (requiredFields.every(requiredField => parentGroup.providedFields.some(FieldSet_1.matchesField(requiredField)))) {
-                if (owningService === parentGroup.serviceName) {
-                    return parentGroup;
-                }
-                else {
-                    return parentGroup.dependentGroupForService(owningService, requiredFields);
-                }
-            }
-            else {
-                const keyFields = context.getKeyFields({
-                    parentType,
-                    serviceName: parentGroup.serviceName,
-                });
-                if (!keyFields) {
-                    throw new graphql_1.GraphQLError(`Couldn't find keys for type "${parentType.name}}" in service "${baseService}"`, fieldNode);
-                }
-                if (baseService === parentGroup.serviceName) {
-                    return parentGroup.dependentGroupForService(owningService, requiredFields);
-                }
-                const baseGroup = parentGroup.dependentGroupForService(baseService, keyFields);
-                return baseGroup.dependentGroupForService(owningService, requiredFields);
-            }
-        }
-    });
-}
-function splitFields(context, path, fields, groupForField) {
-    for (const fieldsForResponseName of FieldSet_1.groupByResponseName(fields).values()) {
-        for (const [parentType, fieldsForParentType] of FieldSet_1.groupByParentType(fieldsForResponseName)) {
-            const field = fieldsForParentType[0];
-            const { scope, fieldDef } = field;
-            if (fieldDef.name === graphql_1.TypeNameMetaFieldDef.name) {
-                const { schema } = context;
-                const roots = [
-                    schema.getQueryType(),
-                    schema.getMutationType(),
-                    schema.getSubscriptionType(),
-                ]
-                    .filter(apollo_env_1.isNotNullOrUndefined)
-                    .map(type => type.name);
-                if (roots.indexOf(parentType.name) > -1)
-                    continue;
-            }
-            if (graphql_1.isIntrospectionType(graphql_1.getNamedType(fieldDef.type))) {
-                continue;
-            }
-            if (graphql_1.isObjectType(parentType) && scope.possibleTypes.includes(parentType)) {
-                const group = groupForField(field);
-                group.fields.push(completeField(context, scope, group, path, fieldsForParentType));
-            }
-            else {
-                const possibleFieldDefs = scope.possibleTypes.map(runtimeType => context.getFieldDef(runtimeType, field.fieldNode));
-                const hasNoExtendingFieldDefs = !possibleFieldDefs.some(utils_1.getFederationMetadata);
-                if (hasNoExtendingFieldDefs) {
-                    const group = groupForField(field);
-                    group.fields.push(completeField(context, scope, group, path, fieldsForResponseName));
-                    continue;
-                }
-                const groupsByRuntimeParentTypes = new MultiMap_1.MultiMap();
-                for (const runtimeParentType of scope.possibleTypes) {
-                    const fieldDef = context.getFieldDef(runtimeParentType, field.fieldNode);
-                    groupsByRuntimeParentTypes.add(groupForField({
-                        scope: context.newScope(runtimeParentType, scope),
-                        fieldNode: field.fieldNode,
-                        fieldDef,
-                    }), runtimeParentType);
-                }
-                for (const [group, runtimeParentTypes] of groupsByRuntimeParentTypes) {
-                    for (const runtimeParentType of runtimeParentTypes) {
-                        const fieldDef = context.getFieldDef(runtimeParentType, field.fieldNode);
-                        const fieldsWithRuntimeParentType = fieldsForParentType.map(field => ({
-                            ...field,
-                            fieldDef,
-                        }));
-                        group.fields.push(completeField(context, context.newScope(runtimeParentType, scope), group, path, fieldsWithRuntimeParentType));
-                    }
-                }
-            }
-        }
-    }
-}
-function completeField(context, scope, parentGroup, path, fields) {
-    const { fieldNode, fieldDef } = fields[0];
-    const returnType = graphql_1.getNamedType(fieldDef.type);
-    if (!graphql_1.isCompositeType(returnType)) {
-        return { scope, fieldNode, fieldDef };
-    }
-    else {
-        const fieldPath = addPath(path, graphql_2.getResponseName(fieldNode), fieldDef.type);
-        const subGroup = new FetchGroup(parentGroup.serviceName);
-        subGroup.mergeAt = fieldPath;
-        subGroup.providedFields = context.getProvidedFields(fieldDef, parentGroup.serviceName);
-        if (graphql_1.isAbstractType(returnType)) {
-            subGroup.fields.push({
-                scope: context.newScope(returnType, scope),
-                fieldNode: typenameField,
-                fieldDef: graphql_1.TypeNameMetaFieldDef,
-            });
-        }
-        const subfields = collectSubfields(context, returnType, fields);
-        splitSubfields(context, fieldPath, subfields, subGroup);
-        parentGroup.otherDependentGroups.push(...subGroup.dependentGroups);
-        let definition;
-        let selectionSet = FieldSet_1.selectionSetFromFieldSet(subGroup.fields, returnType);
-        if (context.autoFragmentization && subGroup.fields.length > 2) {
-            ({ definition, selectionSet } = getInternalFragment(selectionSet, returnType, context));
-            parentGroup.internalFragments.add(definition);
-        }
-        subGroup.internalFragments.forEach(fragment => {
-            parentGroup.internalFragments.add(fragment);
-        });
-        return {
-            scope,
-            fieldNode: {
-                ...fieldNode,
-                selectionSet,
-            },
-            fieldDef,
-        };
-    }
-}
-function getInternalFragment(selectionSet, returnType, context) {
-    const key = JSON.stringify(selectionSet);
-    if (!context.internalFragments.has(key)) {
-        const name = `__QueryPlanFragment_${context.internalFragmentCount++}__`;
-        const definition = {
-            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: returnType.name,
-                },
-            },
-            selectionSet,
-        };
-        const fragmentSelection = {
-            kind: graphql_1.Kind.SELECTION_SET,
-            selections: [
-                {
-                    kind: graphql_1.Kind.FRAGMENT_SPREAD,
-                    name: {
-                        kind: graphql_1.Kind.NAME,
-                        value: name,
-                    },
-                },
-            ],
-        };
-        context.internalFragments.set(key, {
-            name,
-            definition,
-            selectionSet: fragmentSelection,
-        });
-    }
-    return context.internalFragments.get(key);
-}
-function collectFields(context, scope, selectionSet, fields = [], visitedFragmentNames = Object.create(null)) {
-    for (const selection of selectionSet.selections) {
-        switch (selection.kind) {
-            case graphql_1.Kind.FIELD:
-                const fieldDef = context.getFieldDef(scope.parentType, selection);
-                fields.push({ scope, fieldNode: selection, fieldDef });
-                break;
-            case graphql_1.Kind.INLINE_FRAGMENT: {
-                const newScope = context.newScope(getFragmentCondition(selection), scope);
-                if (newScope.possibleTypes.length === 0) {
-                    break;
-                }
-                collectFields(context, context.newScope(getFragmentCondition(selection), scope), selection.selectionSet, fields, visitedFragmentNames);
-                break;
-            }
-            case graphql_1.Kind.FRAGMENT_SPREAD:
-                const fragmentName = selection.name.value;
-                const fragment = context.fragments[fragmentName];
-                if (!fragment) {
-                    continue;
-                }
-                const newScope = context.newScope(getFragmentCondition(fragment), scope);
-                if (newScope.possibleTypes.length === 0) {
-                    continue;
-                }
-                if (visitedFragmentNames[fragmentName]) {
-                    continue;
-                }
-                visitedFragmentNames[fragmentName] = true;
-                collectFields(context, newScope, fragment.selectionSet, fields, visitedFragmentNames);
-                break;
-        }
-    }
-    return fields;
-    function getFragmentCondition(fragment) {
-        const typeConditionNode = fragment.typeCondition;
-        if (!typeConditionNode)
-            return scope.parentType;
-        return graphql_1.typeFromAST(context.schema, typeConditionNode);
-    }
-}
-function collectSubfields(context, returnType, fields) {
-    let subfields = [];
-    const visitedFragmentNames = Object.create(null);
-    for (const field of fields) {
-        const selectionSet = field.fieldNode.selectionSet;
-        if (selectionSet) {
-            subfields = collectFields(context, context.newScope(returnType), selectionSet, subfields, visitedFragmentNames);
-        }
-    }
-    return subfields;
-}
-exports.collectSubfields = collectSubfields;
-class FetchGroup {
-    constructor(serviceName, fields = [], internalFragments = new Set()) {
-        this.serviceName = serviceName;
-        this.fields = fields;
-        this.internalFragments = internalFragments;
-        this.requiredFields = [];
-        this.providedFields = [];
-        this.dependentGroupsByService = Object.create(null);
-        this.otherDependentGroups = [];
-    }
-    dependentGroupForService(serviceName, requiredFields) {
-        let group = this.dependentGroupsByService[serviceName];
-        if (!group) {
-            group = new FetchGroup(serviceName);
-            group.mergeAt = this.mergeAt;
-            this.dependentGroupsByService[serviceName] = group;
-        }
-        if (requiredFields) {
-            if (group.requiredFields) {
-                group.requiredFields.push(...requiredFields);
-            }
-            else {
-                group.requiredFields = requiredFields;
-            }
-            this.fields.push(...requiredFields);
-        }
-        return group;
-    }
-    get dependentGroups() {
-        return [
-            ...Object.values(this.dependentGroupsByService),
-            ...this.otherDependentGroups,
-        ];
-    }
-}
-function buildOperationContext(schema, document, operationName) {
-    let operation;
-    const fragments = Object.create(null);
-    document.definitions.forEach(definition => {
-        switch (definition.kind) {
-            case graphql_1.Kind.OPERATION_DEFINITION:
-                if (!operationName && operation) {
-                    throw new graphql_1.GraphQLError('Must provide operation name if query contains ' +
-                        'multiple operations.');
-                }
-                if (!operationName ||
-                    (definition.name && definition.name.value === operationName)) {
-                    operation = definition;
-                }
-                break;
-            case graphql_1.Kind.FRAGMENT_DEFINITION:
-                fragments[definition.name.value] = definition;
-                break;
-        }
-    });
-    if (!operation) {
-        if (operationName) {
-            throw new graphql_1.GraphQLError(`Unknown operation named "${operationName}".`);
-        }
-        else {
-            throw new graphql_1.GraphQLError('Must provide an operation.');
-        }
-    }
-    return { schema, operation, fragments };
-}
-exports.buildOperationContext = buildOperationContext;
-function buildQueryPlanningContext({ operation, schema, fragments }, options) {
-    return new QueryPlanningContext(schema, operation, fragments, options.autoFragmentization);
-}
-exports.buildQueryPlanningContext = buildQueryPlanningContext;
-class QueryPlanningContext {
-    constructor(schema, operation, fragments, autoFragmentization) {
-        this.schema = schema;
-        this.operation = operation;
-        this.fragments = fragments;
-        this.autoFragmentization = autoFragmentization;
-        this.internalFragments = new Map();
-        this.internalFragmentCount = 0;
-        this.variableDefinitions = Object.create(null);
-        graphql_1.visit(operation, {
-            VariableDefinition: definition => {
-                this.variableDefinitions[definition.variable.name.value] = definition;
-            },
-        });
-    }
-    getFieldDef(parentType, fieldNode) {
-        const fieldName = fieldNode.name.value;
-        const fieldDef = graphql_2.getFieldDef(this.schema, parentType, fieldName);
-        if (!fieldDef) {
-            throw new graphql_1.GraphQLError(`Cannot query field "${fieldNode.name.value}" on type "${String(parentType)}"`, fieldNode);
-        }
-        return fieldDef;
-    }
-    getPossibleTypes(type) {
-        return graphql_1.isAbstractType(type) ? this.schema.getPossibleTypes(type) : [type];
-    }
-    getVariableUsages(selectionSet, fragments) {
-        const usages = Object.create(null);
-        const document = {
-            kind: graphql_1.Kind.DOCUMENT,
-            definitions: [
-                { kind: graphql_1.Kind.OPERATION_DEFINITION, selectionSet, operation: 'query' },
-                ...Array.from(fragments),
-            ],
-        };
-        graphql_1.visit(document, {
-            Variable: (node) => {
-                usages[node.name.value] = this.variableDefinitions[node.name.value];
-            },
-        });
-        return usages;
-    }
-    newScope(parentType, enclosingScope) {
-        return {
-            parentType,
-            possibleTypes: enclosingScope
-                ? this.getPossibleTypes(parentType).filter(type => enclosingScope.possibleTypes.includes(type))
-                : this.getPossibleTypes(parentType),
-            enclosingScope,
-        };
-    }
-    getBaseService(parentType) {
-        var _a;
-        return ((_a = utils_1.getFederationMetadata(parentType)) === null || _a === void 0 ? void 0 : _a.serviceName) || null;
-    }
-    getOwningService(parentType, fieldDef) {
-        const fieldFederationMetadata = utils_1.getFederationMetadata(fieldDef);
-        if ((fieldFederationMetadata === null || fieldFederationMetadata === void 0 ? void 0 : fieldFederationMetadata.serviceName) &&
-            !(fieldFederationMetadata === null || fieldFederationMetadata === void 0 ? void 0 : fieldFederationMetadata.belongsToValueType)) {
-            return fieldFederationMetadata.serviceName;
-        }
-        else {
-            return this.getBaseService(parentType);
-        }
-    }
-    getKeyFields({ parentType, serviceName, fetchAll = false, }) {
-        var _a, _b;
-        const keyFields = [];
-        keyFields.push({
-            scope: {
-                parentType,
-                possibleTypes: this.getPossibleTypes(parentType),
-            },
-            fieldNode: typenameField,
-            fieldDef: graphql_1.TypeNameMetaFieldDef,
-        });
-        for (const possibleType of this.getPossibleTypes(parentType)) {
-            const keys = (_b = (_a = utils_1.getFederationMetadata(possibleType)) === null || _a === void 0 ? void 0 : _a.keys) === null || _b === void 0 ? void 0 : _b[serviceName];
-            if (!(keys && keys.length > 0))
-                continue;
-            if (fetchAll) {
-                keyFields.push(...keys.flatMap(key => collectFields(this, this.newScope(possibleType), {
-                    kind: graphql_1.Kind.SELECTION_SET,
-                    selections: key,
-                })));
-            }
-            else {
-                keyFields.push(...collectFields(this, this.newScope(possibleType), {
-                    kind: graphql_1.Kind.SELECTION_SET,
-                    selections: keys[0],
-                }));
-            }
-        }
-        return keyFields;
-    }
-    getRequiredFields(parentType, fieldDef, serviceName) {
-        const requiredFields = [];
-        requiredFields.push(...this.getKeyFields({ parentType, serviceName }));
-        const fieldFederationMetadata = utils_1.getFederationMetadata(fieldDef);
-        if (fieldFederationMetadata === null || fieldFederationMetadata === void 0 ? void 0 : fieldFederationMetadata.requires) {
-            requiredFields.push(...collectFields(this, this.newScope(parentType), {
-                kind: graphql_1.Kind.SELECTION_SET,
-                selections: fieldFederationMetadata.requires,
-            }));
-        }
-        return requiredFields;
-    }
-    getProvidedFields(fieldDef, serviceName) {
-        const returnType = graphql_1.getNamedType(fieldDef.type);
-        if (!graphql_1.isCompositeType(returnType))
-            return [];
-        const providedFields = [];
-        providedFields.push(...this.getKeyFields({
-            parentType: returnType,
-            serviceName,
-            fetchAll: true,
-        }));
-        const fieldFederationMetadata = utils_1.getFederationMetadata(fieldDef);
-        if (fieldFederationMetadata === null || fieldFederationMetadata === void 0 ? void 0 : fieldFederationMetadata.provides) {
-            providedFields.push(...collectFields(this, this.newScope(returnType), {
-                kind: graphql_1.Kind.SELECTION_SET,
-                selections: fieldFederationMetadata.provides,
-            }));
-        }
-        return providedFields;
-    }
-}
-exports.QueryPlanningContext = QueryPlanningContext;
-function addPath(path, responseName, type) {
-    path = [...path, responseName];
-    while (!graphql_1.isNamedType(type)) {
-        if (graphql_1.isListType(type)) {
-            path.push('@');
-        }
-        type = type.ofType;
-    }
-    return path;
-}
-//# sourceMappingURL=buildQueryPlan.js.map