@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/esm/supergraph/validation/rules/satisfiablity-rule.js

@@ -0,0 +1,862 @@
+import { GraphQLError, Kind, OperationTypeNode, print, specifiedScalarTypes, } from 'graphql';
+import { parseFields } from '../../../subgraph/helpers.js';
+import { TypeKind } from '../../../subgraph/state.js';
+import { DepGraph } from '../../../utils/dependency-graph.js';
+import { isDefined } from '../../../utils/helpers.js';
+import { isList, isNonNull, stripNonNull, stripTypeModifiers } from '../../../utils/state.js';
+function canGraphMoveToGraph(supergraphState, objectTypeState, sourceGraphId, targetGraphId) {
+    const sourceGraphKeys = objectTypeState.byGraph.get(sourceGraphId).keys;
+    const targetGraphKeys = objectTypeState.byGraph.get(targetGraphId).keys;
+    if (sourceGraphKeys.length === 0 && targetGraphKeys.length === 0) {
+        return false;
+    }
+    const fieldsOfSourceGraph = Array.from(objectTypeState.fields.values()).filter(f => f.byGraph.get(sourceGraphId));
+    const nonExternalFieldsOfSourceGraph = fieldsOfSourceGraph.filter(f => f.byGraph.get(sourceGraphId).external === false);
+    if (sourceGraphKeys.length === 0) {
+        return targetGraphKeys
+            .filter(k => k.resolvable === true)
+            .some(k => {
+            const targetKeyFields = resolveFieldsFromFieldSet(k.fields, objectTypeState.name, targetGraphId, supergraphState);
+            return Array.from(targetKeyFields.coordinates).every(fieldPath => {
+                const [typeName, fieldName] = fieldPath.split('.');
+                if (typeName === objectTypeState.name) {
+                    const fieldState = objectTypeState.fields.get(fieldName);
+                    if (!fieldState) {
+                        throw new Error(`Field "${fieldPath}" not found in object type "${typeName}"`);
+                    }
+                    const fieldStateByGraph = fieldState.byGraph.get(targetGraphId);
+                    if (!fieldStateByGraph) {
+                        throw new Error(`Field "${fieldPath}" not found in object type "${typeName}" in graph "${targetGraphId}"`);
+                    }
+                    return fieldStateByGraph.external === false;
+                }
+                const currentTypeState = supergraphState.objectTypes.get(typeName) ??
+                    supergraphState.interfaceTypes.get(typeName);
+                if (!currentTypeState) {
+                    throw new Error(`Type "${typeName}" not found`);
+                }
+                const fieldState = currentTypeState.fields.get(fieldName);
+                if (!fieldState) {
+                    throw new Error(`Field "${fieldPath}" not found in object type "${typeName}"`);
+                }
+                const fieldStateByGraph = fieldState.byGraph.get(targetGraphId);
+                if (!fieldStateByGraph) {
+                    throw new Error(`Field "${fieldPath}" not found in object type "${typeName}" in graph "${targetGraphId}"`);
+                }
+                if ('external' in fieldStateByGraph) {
+                    return fieldStateByGraph.external === false;
+                }
+                return true;
+            });
+        });
+    }
+    return sourceGraphKeys.some(sourceGraphKey => {
+        const sourceKeyFields = resolveFieldsFromFieldSet(sourceGraphKey.fields, objectTypeState.name, sourceGraphId, supergraphState);
+        return (targetGraphKeys
+            .filter(k => k.resolvable === true)
+            .some(k => {
+            const targetKeyFields = resolveFieldsFromFieldSet(k.fields, objectTypeState.name, targetGraphId, supergraphState);
+            for (const fieldPath of targetKeyFields.paths) {
+                if (!sourceKeyFields.paths.has(fieldPath)) {
+                    return false;
+                }
+            }
+            return true;
+        }));
+    });
+}
+function canGraphResolveFieldDirectly(objectTypeSuperState, fieldSuperState, graphId, supergraphState) {
+    const objectTypeInGraph = objectTypeSuperState.byGraph.get(graphId);
+    if (!objectTypeInGraph) {
+        throw new Error(`Object type "${objectTypeSuperState.name}" not found in graph "${graphId}"`);
+    }
+    const fieldInGraph = fieldSuperState.byGraph.get(graphId);
+    if (!fieldInGraph) {
+        return false;
+    }
+    if ((fieldInGraph.shareable === true ||
+        objectTypeSuperState.byGraph.get(graphId).shareable === true) &&
+        supergraphState.graphs.get(graphId).version !== 'v1.0') {
+        return true;
+    }
+    if (fieldInGraph.external === true) {
+        if (fieldInGraph.usedAsKey === true) {
+            const graphHasAtLeastOneResolvableField = Array.from(objectTypeSuperState.fields.values()).some(f => {
+                if (f.name === fieldSuperState.name) {
+                    return false;
+                }
+                const fInGraph = f.byGraph.get(graphId);
+                if (!fInGraph) {
+                    return false;
+                }
+                if (fInGraph.external === true) {
+                    return false;
+                }
+                if (fInGraph.inaccessible === true) {
+                    return false;
+                }
+                if (typeof fInGraph.override === 'string') {
+                    return false;
+                }
+                return true;
+            });
+            if (graphHasAtLeastOneResolvableField) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return true;
+}
+function canGraphResolveField(objectTypeSuperState, fieldSuperState, graphId, supergraphState, movabilityGraph) {
+    const objectTypeInGraph = objectTypeSuperState.byGraph.get(graphId);
+    if (!objectTypeInGraph) {
+        throw new Error(`Object type "${objectTypeSuperState.name}" not found in graph "${graphId}"`);
+    }
+    const fieldInGraph = fieldSuperState.byGraph.get(graphId);
+    if (fieldInGraph &&
+        fieldInGraph.external === false &&
+        canGraphResolveFieldDirectly(objectTypeSuperState, fieldSuperState, graphId, supergraphState)) {
+        return true;
+    }
+    const graphsWithField = Array.from(fieldSuperState.byGraph).filter(([g, _]) => {
+        if (g === graphId) {
+            return false;
+        }
+        const fieldInGraph = fieldSuperState.byGraph.get(g);
+        if (!fieldInGraph || fieldInGraph.external === true) {
+            return false;
+        }
+        return true;
+    });
+    const canMoveToGraphWithField = graphsWithField.some(([g, _]) => {
+        return canGraphMoveToGraphBasedOnMovabilityGraph(movabilityGraph, graphId, g);
+    });
+    return canMoveToGraphWithField;
+}
+function canGraphMoveToGraphBasedOnMovabilityGraph(movabilityGraph, sourceId, destinationId, visited = new Set()) {
+    const key = `${sourceId} => ${destinationId}`;
+    if (visited.has(key)) {
+        return false;
+    }
+    else {
+        visited.add(key);
+    }
+    const deps = movabilityGraph.directDependenciesOf(sourceId);
+    if (deps.includes(destinationId)) {
+        return true;
+    }
+    return deps.some(depId => canGraphMoveToGraphBasedOnMovabilityGraph(movabilityGraph, depId, destinationId, visited));
+}
+function findLeafs(movabilityGraph, sourceId, destinationId, leafs, visited = new Set()) {
+    const key = `${sourceId} => ${destinationId}`;
+    if (leafs === undefined) {
+        leafs = new Set();
+    }
+    const deps = movabilityGraph.directDependenciesOf(sourceId);
+    if (visited.has(key)) {
+        return Array.from(leafs);
+    }
+    else {
+        visited.add(key);
+    }
+    for (const depId of deps) {
+        if (!canGraphMoveToGraphBasedOnMovabilityGraph(movabilityGraph, depId, destinationId)) {
+            leafs.add(depId);
+            findLeafs(movabilityGraph, depId, destinationId, leafs, visited);
+        }
+    }
+    return Array.from(leafs);
+}
+export function SatisfiabilityRule(context, supergraphState) {
+    const typeDependencies = buildOutputTypesDependencies(supergraphState);
+    let currentMovabilityGraphType;
+    let movabilityGraph;
+    return {
+        ObjectType(objectState) {
+            currentMovabilityGraphType = objectState.name;
+            movabilityGraph = new DepGraph({
+                circular: true,
+            });
+            const graphIds = Array.from(objectState.byGraph.keys());
+            for (const sourceGraphId of objectState.byGraph.keys()) {
+                movabilityGraph.addNode(sourceGraphId);
+            }
+            for (const sourceGraphId of objectState.byGraph.keys()) {
+                const otherGraphIds = graphIds.filter(g => g !== sourceGraphId);
+                for (const destGraphId of otherGraphIds) {
+                    if (canGraphMoveToGraph(supergraphState, objectState, sourceGraphId, destGraphId)) {
+                        movabilityGraph.addDependency(sourceGraphId, destGraphId);
+                    }
+                }
+            }
+        },
+        ObjectTypeField(objectState, fieldState) {
+            if (currentMovabilityGraphType !== objectState.name) {
+                throw new Error('ObjectTypeField runs before ObjectType! This should not happen.');
+            }
+            if (objectState.name === 'Query' ||
+                objectState.name === 'Mutation' ||
+                objectState.name === 'Subscription') {
+                return;
+            }
+            if (objectState.byGraph.size === 1) {
+                return;
+            }
+            const dependenciesOfObjectType = typeDependencies.dependentsOf(objectState.name);
+            const isReachableByRootType = {
+                query: dependenciesOfObjectType.includes('Query'),
+                mutation: dependenciesOfObjectType.includes('Mutation'),
+                subscription: dependenciesOfObjectType.includes('Subscription'),
+            };
+            const isReachable = isReachableByRootType.query ||
+                isReachableByRootType.mutation ||
+                isReachableByRootType.subscription;
+            if (!isReachable) {
+                return;
+            }
+            const objectStateGraphPairs = Array.from(objectState.byGraph);
+            const fieldStateGraphPairs = Array.from(fieldState.byGraph);
+            if (objectStateGraphPairs.some(([_, objectTypeStateInGraph]) => objectTypeStateInGraph.inaccessible === true) ||
+                fieldStateGraphPairs.some(([_, fieldStateInGraph]) => fieldStateInGraph.inaccessible === true)) {
+                return;
+            }
+            const isFieldShareableInAllSubgraphs = Array.from(fieldState.byGraph).every(([graphId, fieldStateInGraph]) => {
+                const fieldShareable = fieldStateInGraph.shareable &&
+                    context.subgraphStates.get(graphId).version !== 'v1.0';
+                const typeShareable = objectState.byGraph.get(graphId).shareable === true;
+                return fieldShareable || typeShareable;
+            });
+            if (isFieldShareableInAllSubgraphs) {
+                return;
+            }
+            if (fieldState.byGraph.size === objectState.byGraph.size &&
+                fieldStateGraphPairs.every(([_, f]) => f.usedAsKey === true && f.external === false && !f.override)) {
+                return;
+            }
+            const keysInAllGraphs = objectStateGraphPairs.every(([_, o]) => o.keys.length > 0);
+            const uniqueKeyFieldsSet = new Set(objectStateGraphPairs
+                .map(([_, o]) => o.keys.map(k => k.fields))
+                .flat(1));
+            if (keysInAllGraphs && uniqueKeyFieldsSet.size === 1) {
+                return;
+            }
+            const aggregatedErrorByRootType = {
+                Query: {
+                    query: null,
+                    reasons: [],
+                },
+                Mutation: {
+                    query: null,
+                    reasons: [],
+                },
+                Subscription: {
+                    query: null,
+                    reasons: [],
+                },
+            };
+            if (uniqueKeyFieldsSet.size > 0) {
+                for (const graphId of objectState.byGraph.keys()) {
+                    if (canGraphResolveField(objectState, fieldState, graphId, supergraphState, movabilityGraph)) {
+                        continue;
+                    }
+                    const fieldStateInGraph = fieldState.byGraph.get(graphId);
+                    if (fieldStateInGraph?.external === true) {
+                        const objectStateInGraph = objectState.byGraph.get(graphId);
+                        if (objectStateInGraph.extension === true) {
+                            continue;
+                        }
+                        if (fieldStateInGraph.required) {
+                            continue;
+                        }
+                        if (fieldStateInGraph.provided) {
+                            continue;
+                        }
+                    }
+                    const subgraphState = context.subgraphStates.get(graphId);
+                    const schemaDefinitionOfGraph = subgraphState.schema;
+                    const rootTypes = [
+                        schemaDefinitionOfGraph.queryType
+                            ? [
+                                'Query',
+                                subgraphState.types.get(schemaDefinitionOfGraph.queryType),
+                            ]
+                            : undefined,
+                        schemaDefinitionOfGraph.mutationType
+                            ? [
+                                'Mutation',
+                                subgraphState.types.get(schemaDefinitionOfGraph.mutationType),
+                            ]
+                            : undefined,
+                        schemaDefinitionOfGraph.subscriptionType
+                            ? [
+                                'Subscription',
+                                subgraphState.types.get(schemaDefinitionOfGraph.subscriptionType),
+                            ]
+                            : undefined,
+                    ].filter(isDefined);
+                    if (rootTypes.length === 0) {
+                        continue;
+                    }
+                    const otherGraphIds = objectStateGraphPairs
+                        .filter(([g, _]) => g !== graphId)
+                        .map(([g, _]) => g);
+                    const graphsWithField = fieldStateGraphPairs
+                        .filter(([g, _]) => canGraphResolveFieldDirectly(objectState, fieldState, g, supergraphState))
+                        .map(([g, _]) => g);
+                    const leafs = graphsWithField.map(g => findLeafs(movabilityGraph, graphId, g)).flat(1);
+                    if (leafs.length === 0 && movabilityGraph.directDependenciesOf(graphId).length > 0) {
+                        continue;
+                    }
+                    for (const [normalizedName, rootType] of rootTypes) {
+                        const query = printExampleQuery(supergraphState, normalizedName, Array.from(rootType.fields.keys()), objectState.name, fieldState.name, dependenciesOfObjectType);
+                        const reasons = [];
+                        const canBeIndirectlyResolved = leafs.length > 0;
+                        const cannotMoveToList = (sourceGraphId) => canBeIndirectlyResolved
+                            ? graphsWithField
+                                .map(gid => {
+                                const keys = objectState.byGraph.get(gid).keys.map(k => k.fields);
+                                if (keys.length > 0) {
+                                    return objectState.byGraph
+                                        .get(gid)
+                                        .keys.map(k => k.fields)
+                                        .map(fields => `cannot move to subgraph "${context.graphIdToName(gid)}" using @key(fields: "${fields}") of "${objectState.name}", the key field(s) cannot be resolved from subgraph "${context.graphIdToName(sourceGraphId)}".`);
+                                }
+                                return `cannot move to subgraph "${context.graphIdToName(gid)}", which has field "${objectState.name}.${fieldState.name}", because type "${objectState.name}" has no @key defined in subgraph "${context.graphIdToName(gid)}".`;
+                            })
+                                .flat(1)
+                            : otherGraphIds
+                                .filter(g => !movabilityGraph.directDependenciesOf(graphId).includes(g))
+                                .map(gid => {
+                                const keys = objectState.byGraph.get(gid).keys.map(k => k.fields);
+                                if (keys.length > 0) {
+                                    return objectState.byGraph
+                                        .get(gid)
+                                        .keys.map(k => k.fields)
+                                        .map(fields => `cannot move to subgraph "${context.graphIdToName(gid)}" using @key(fields: "${fields}") of "${objectState.name}", the key field(s) cannot be resolved from subgraph "${context.graphIdToName(sourceGraphId)}".`);
+                                }
+                                return `cannot move to subgraph "${context.graphIdToName(gid)}", which has field "${objectState.name}.${fieldState.name}", because type "${objectState.name}" has no @key defined in subgraph "${context.graphIdToName(gid)}".`;
+                            })
+                                .flat(1);
+                        const fromSubgraphs = [graphId].concat(leafs);
+                        if (!fieldStateInGraph) {
+                            fromSubgraphs.forEach(gid => {
+                                reasons.push([
+                                    gid,
+                                    [`cannot find field "${objectState.name}.${fieldState.name}".`].concat(cannotMoveToList(gid)),
+                                ]);
+                            });
+                        }
+                        else if (fieldStateInGraph.external) {
+                            fromSubgraphs.forEach(gid => {
+                                reasons.push([
+                                    gid,
+                                    [
+                                        `field "${objectState.name}.${fieldState.name}" is not resolvable because marked @external.`,
+                                    ].concat(cannotMoveToList(gid)),
+                                ]);
+                            });
+                        }
+                        else {
+                            console.log('can NOT resolve field', fieldState.name, 'in graph', graphId, 'reason: unknown');
+                        }
+                        if (!query || reasons.length === 0) {
+                            continue;
+                        }
+                        context.reportError(new GraphQLError([
+                            'The following supergraph API query:',
+                            query,
+                            'cannot be satisfied by the subgraphs because:',
+                            ...reasons.map(([gid, reasons]) => {
+                                return (`- from subgraph "${context.graphIdToName(gid)}":\n` +
+                                    reasons.map(r => `  - ${r}`).join('\n'));
+                            }),
+                        ].join('\n'), {
+                            extensions: {
+                                code: 'SATISFIABILITY_ERROR',
+                            },
+                        }));
+                    }
+                }
+            }
+            else {
+                const graphsWithoutField = objectStateGraphPairs.filter(([graphId]) => !fieldState.byGraph.has(graphId));
+                const graphsWithField = fieldStateGraphPairs.map(([graphId]) => graphId);
+                for (const [graphId] of graphsWithoutField) {
+                    const subgraphState = context.subgraphStates.get(graphId);
+                    const isShareableWithOtherGraphs = Array.from(subgraphState.types.values())
+                        .filter(t => dependenciesOfObjectType.includes(t.name))
+                        .every(t => {
+                        if (t.kind === TypeKind.OBJECT) {
+                            if (t.shareable &&
+                                subgraphState.version !== 'v1.0') {
+                                return true;
+                            }
+                            const fields = Array.from(t.fields.values());
+                            if (fields
+                                .filter(f => stripTypeModifiers(f.type) === objectState.name)
+                                .every(f => f.shareable === true &&
+                                subgraphState.version !== 'v1.0')) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    });
+                    if (isShareableWithOtherGraphs) {
+                        continue;
+                    }
+                    const graphHasAtLeastOneResolvableField = Array.from(objectState.fields.values()).some(f => {
+                        const fieldInGraph = f.byGraph.get(graphId);
+                        if (!fieldInGraph) {
+                            return false;
+                        }
+                        if (fieldInGraph.inaccessible === true) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    if (!graphHasAtLeastOneResolvableField) {
+                        continue;
+                    }
+                    const schemaDefinitionOfGraph = subgraphState.schema;
+                    const rootTypes = [
+                        schemaDefinitionOfGraph.queryType
+                            ? [
+                                'Query',
+                                subgraphState.types.get(schemaDefinitionOfGraph.queryType),
+                            ]
+                            : undefined,
+                        schemaDefinitionOfGraph.mutationType
+                            ? [
+                                'Mutation',
+                                subgraphState.types.get(schemaDefinitionOfGraph.mutationType),
+                            ]
+                            : undefined,
+                        schemaDefinitionOfGraph.subscriptionType
+                            ? [
+                                'Subscription',
+                                subgraphState.types.get(schemaDefinitionOfGraph.subscriptionType),
+                            ]
+                            : undefined,
+                    ].filter(isDefined);
+                    if (rootTypes.length === 0) {
+                        continue;
+                    }
+                    for (const [normalizedName, rootType] of rootTypes) {
+                        const rootTypeFields = Array.from(rootType.fields.keys()).filter(f => f !== '_entities' && f !== '_service');
+                        if (rootTypeFields.length === 0) {
+                            continue;
+                        }
+                        const supergraphRootType = supergraphState.objectTypes.get(normalizedName);
+                        const rootFieldsReferencingObjectType = Array.from(supergraphRootType.fields.values()).filter(f => {
+                            const fieldOutputTypeName = stripTypeModifiers(f.type);
+                            return (fieldOutputTypeName === objectState.name ||
+                                dependenciesOfObjectType.includes(fieldOutputTypeName));
+                        });
+                        if (rootFieldsReferencingObjectType.length === 0) {
+                            continue;
+                        }
+                        const graphIdsImplementingObjectType = Array.from(objectState.byGraph.keys());
+                        if (rootFieldsReferencingObjectType.every(field => graphIdsImplementingObjectType.every(g => field.byGraph.has(g)))) {
+                            continue;
+                        }
+                        const areRootFieldsShared = graphsWithField.every(g => {
+                            const localVersion = context.subgraphStates.get(g).version;
+                            if (localVersion !== 'v1.0') {
+                                return false;
+                            }
+                            const localSubgraph = context.subgraphStates.get(g);
+                            const localSchemaDefinition = localSubgraph.schema;
+                            const localRootTypeName = normalizedName === 'Query'
+                                ? localSchemaDefinition.queryType
+                                : normalizedName === 'Mutation'
+                                    ? localSchemaDefinition.mutationType
+                                    : normalizedName === 'Subscription'
+                                        ? localSchemaDefinition.subscriptionType
+                                        : undefined;
+                            if (!localRootTypeName) {
+                                return true;
+                            }
+                            const localRootType = localSubgraph.types.get(localRootTypeName);
+                            const localRootFields = Array.from(localRootType.fields.keys());
+                            return rootFieldsReferencingObjectType.every(f => localRootFields.includes(f.name));
+                        });
+                        if (areRootFieldsShared) {
+                            continue;
+                        }
+                        if (!aggregatedErrorByRootType[normalizedName].query) {
+                            aggregatedErrorByRootType[normalizedName].query = printExampleQuery(supergraphState, normalizedName, rootTypeFields, objectState.name, fieldState.name, dependenciesOfObjectType);
+                        }
+                        const firstFieldImplementingGraph = graphsWithField[0];
+                        const graphNameOwningField = context.graphIdToName(firstFieldImplementingGraph);
+                        aggregatedErrorByRootType[normalizedName].reasons.push([
+                            graphId,
+                            [
+                                `cannot find field "${objectState.name}.${fieldState.name}".`,
+                                `cannot move to subgraph "${graphNameOwningField}", which has field "${objectState.name}.${fieldState.name}", because type "${objectState.name}" has no @key defined in subgraph "${graphNameOwningField}".`,
+                            ],
+                        ]);
+                    }
+                }
+            }
+            for (const rootTypeName in aggregatedErrorByRootType) {
+                const details = aggregatedErrorByRootType[rootTypeName];
+                if (!details.query || details.reasons.length === 0) {
+                    continue;
+                }
+                context.reportError(new GraphQLError([
+                    'The following supergraph API query:',
+                    details.query,
+                    'cannot be satisfied by the subgraphs because:',
+                    ...details.reasons.map(([graphId, reasons]) => {
+                        return (`- from subgraph "${context.graphIdToName(graphId)}":\n` +
+                            reasons.map(r => `  - ${r}`).join('\n'));
+                    }),
+                ].join('\n'), {
+                    extensions: {
+                        code: 'SATISFIABILITY_ERROR',
+                    },
+                }));
+            }
+        },
+    };
+}
+function buildOutputTypesDependencies(supergraphState) {
+    const graph = new DepGraph({
+        circular: true,
+    });
+    for (const [typeName, typeState] of supergraphState.objectTypes) {
+        if (typeName === '_Service') {
+            continue;
+        }
+        graph.addNode(typeName);
+        for (const [_, fieldState] of typeState.fields) {
+            const referencedTypeName = stripTypeModifiers(fieldState.type);
+            if (!graph.hasNode(referencedTypeName)) {
+                graph.addNode(referencedTypeName);
+            }
+            graph.addDependency(typeName, referencedTypeName);
+        }
+    }
+    for (const [typeName, typeState] of supergraphState.unionTypes) {
+        if (typeName === '_Entity') {
+            continue;
+        }
+        graph.addNode(typeName);
+        for (const memberType of typeState.members) {
+            const referencedTypeName = memberType;
+            if (!graph.hasNode(referencedTypeName)) {
+                graph.addNode(referencedTypeName);
+            }
+            graph.addDependency(typeName, referencedTypeName);
+        }
+    }
+    return graph;
+}
+function printExampleQuery(supergraphState, rootTypeName, rootTypeFieldsToStartWith, leafTypeName, leafFieldName, typesInBetweenRootAndLeaf = []) {
+    const rootType = supergraphState.objectTypes.get(rootTypeName);
+    function visitType(typeState, descendants, visitedTypes) {
+        if (visitedTypes.includes(typeState.name)) {
+            return null;
+        }
+        if ('members' in typeState) {
+            for (const member of typeState.members) {
+                const result = member === leafTypeName
+                    ? visitLeafType(supergraphState.objectTypes.get(member), descendants.concat([
+                        {
+                            kind: Kind.INLINE_FRAGMENT,
+                            typeCondition: {
+                                kind: Kind.NAMED_TYPE,
+                                name: {
+                                    kind: Kind.NAME,
+                                    value: member,
+                                },
+                            },
+                            selectionSet: {
+                                kind: Kind.SELECTION_SET,
+                                selections: [],
+                            },
+                        },
+                    ]))
+                    : visitType(supergraphState.objectTypes.get(member), descendants.concat([
+                        {
+                            kind: Kind.INLINE_FRAGMENT,
+                            typeCondition: {
+                                kind: Kind.NAMED_TYPE,
+                                name: {
+                                    kind: Kind.NAME,
+                                    value: member,
+                                },
+                            },
+                            selectionSet: {
+                                kind: Kind.SELECTION_SET,
+                                selections: [],
+                            },
+                        },
+                    ]), visitedTypes.concat(typeState.name));
+                if (result) {
+                    return result;
+                }
+            }
+            return null;
+        }
+        for (const [fieldName, fieldState] of Array.from(typeState.fields.entries()).reverse()) {
+            if (typeState.name === rootTypeName && !rootTypeFieldsToStartWith.includes(fieldName)) {
+                continue;
+            }
+            const fieldOutputTypeName = stripTypeModifiers(fieldState.type);
+            if (fieldOutputTypeName === leafTypeName) {
+                return visitLeafType(supergraphState.objectTypes.get(fieldOutputTypeName), descendants.concat([
+                    {
+                        kind: Kind.FIELD,
+                        name: {
+                            kind: Kind.NAME,
+                            value: fieldName,
+                        },
+                        arguments: Array.from(fieldState.args).map(([argName, argState]) => ({
+                            kind: Kind.ARGUMENT,
+                            name: {
+                                kind: Kind.NAME,
+                                value: argName,
+                            },
+                            value: createEmptyValueNode(argState.type, supergraphState),
+                        })),
+                    },
+                ]));
+            }
+            else if (typesInBetweenRootAndLeaf.includes(fieldOutputTypeName) &&
+                !visitedTypes.includes(fieldOutputTypeName)) {
+                const referencedType = supergraphState.objectTypes.get(fieldOutputTypeName) ??
+                    supergraphState.unionTypes.get(fieldOutputTypeName);
+                return visitType(referencedType, descendants.concat([
+                    {
+                        kind: Kind.FIELD,
+                        name: {
+                            kind: Kind.NAME,
+                            value: fieldName,
+                        },
+                        arguments: Array.from(fieldState.args).map(([argName, argState]) => ({
+                            kind: Kind.ARGUMENT,
+                            name: {
+                                kind: Kind.NAME,
+                                value: argName,
+                            },
+                            value: createEmptyValueNode(argState.type, supergraphState),
+                        })),
+                    },
+                ]), visitedTypes.concat(typeState.name));
+            }
+        }
+        return null;
+    }
+    function visitLeafType(objectTypeState, descendants) {
+        for (const [fieldName, fieldState] of objectTypeState.fields) {
+            if (fieldName !== leafFieldName) {
+                continue;
+            }
+            const fieldOutputTypeName = stripTypeModifiers(fieldState.type);
+            const isObjectSpreadCapable = supergraphState.objectTypes.has(fieldOutputTypeName) ||
+                supergraphState.interfaceTypes.has(fieldOutputTypeName) ||
+                supergraphState.unionTypes.has(fieldOutputTypeName);
+            return descendants.concat([
+                {
+                    kind: Kind.FIELD,
+                    name: {
+                        kind: Kind.NAME,
+                        value: fieldName,
+                    },
+                    arguments: Array.from(fieldState.args).map(([argName, argState]) => ({
+                        kind: Kind.ARGUMENT,
+                        name: {
+                            kind: Kind.NAME,
+                            value: argName,
+                        },
+                        value: createEmptyValueNode(argState.type, supergraphState),
+                    })),
+                    selectionSet: isObjectSpreadCapable
+                        ?
+                            {
+                                kind: Kind.SELECTION_SET,
+                                selections: [
+                                    {
+                                        kind: Kind.FRAGMENT_SPREAD,
+                                        name: {
+                                            kind: Kind.NAME,
+                                            value: '',
+                                        },
+                                    },
+                                ],
+                            }
+                        : undefined,
+                },
+            ]);
+        }
+        return null;
+    }
+    const tree = visitType(rootType, [], []);
+    let currentField = null;
+    if (!tree) {
+        return null;
+    }
+    tree.reverse();
+    for (const field of tree) {
+        if (!currentField) {
+            currentField = {
+                ...field,
+            };
+        }
+        else {
+            currentField = {
+                ...field,
+                selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: [currentField],
+                },
+            };
+        }
+    }
+    const query = {
+        kind: Kind.DOCUMENT,
+        definitions: [
+            {
+                kind: Kind.OPERATION_DEFINITION,
+                operation: rootTypeName === 'Query'
+                    ? OperationTypeNode.QUERY
+                    : rootTypeName === 'Mutation'
+                        ? OperationTypeNode.MUTATION
+                        : OperationTypeNode.SUBSCRIPTION,
+                selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: [currentField],
+                },
+            },
+        ],
+    };
+    return print(query);
+}
+function createEmptyValueNode(fullType, supergraphState) {
+    if (isList(fullType)) {
+        return {
+            kind: Kind.LIST,
+            values: [],
+        };
+    }
+    if (isNonNull(fullType)) {
+        const innerType = stripNonNull(fullType);
+        return createEmptyValueNode(innerType, supergraphState);
+    }
+    if (supergraphState.enumTypes.has(fullType)) {
+        const enumState = supergraphState.enumTypes.get(fullType);
+        return {
+            kind: Kind.ENUM,
+            value: Array.from(enumState.values.keys())[0],
+        };
+    }
+    if (supergraphState.scalarTypes.has(fullType)) {
+        return {
+            kind: Kind.STRING,
+            value: 'A string value',
+        };
+    }
+    if (supergraphState.inputObjectTypes.has(fullType)) {
+        const inputObjectTypeState = supergraphState.inputObjectTypes.get(fullType);
+        return {
+            kind: Kind.OBJECT,
+            fields: Array.from(inputObjectTypeState.fields)
+                .filter(([_, fieldState]) => isNonNull(fieldState.type))
+                .map(([fieldName, fieldState]) => ({
+                kind: Kind.OBJECT_FIELD,
+                name: {
+                    kind: Kind.NAME,
+                    value: fieldName,
+                },
+                value: createEmptyValueNode(fieldState.type, supergraphState),
+            })),
+        };
+    }
+    const specifiedScalar = specifiedScalarTypes.find(s => s.name === fullType);
+    if (!specifiedScalar) {
+        throw new Error(`Type "${fullType}" is not defined.`);
+    }
+    if (specifiedScalar.name === 'String') {
+        return {
+            kind: Kind.STRING,
+            value: 'A string value',
+        };
+    }
+    if (specifiedScalar.name === 'Int' || specifiedScalar.name === 'Float') {
+        return {
+            kind: Kind.INT,
+            value: '0',
+        };
+    }
+    if (specifiedScalar.name === 'Boolean') {
+        return {
+            kind: Kind.BOOLEAN,
+            value: true,
+        };
+    }
+    if (specifiedScalar.name === 'ID') {
+        return {
+            kind: Kind.STRING,
+            value: '<any id>',
+        };
+    }
+    throw new Error(`Type "${fullType}" is not supported.`);
+}
+function resolveFieldsFromFieldSet(fields, typeName, graphId, supergraphState) {
+    const paths = new Set();
+    const coordinates = new Set();
+    const selectionSet = parseFields(fields);
+    if (!selectionSet) {
+        return {
+            coordinates,
+            paths,
+        };
+    }
+    findFieldPathsFromSelectionSet(paths, coordinates, typeName, selectionSet, typeName, graphId, supergraphState);
+    return {
+        coordinates,
+        paths,
+    };
+}
+function findFieldPathsFromSelectionSet(fieldPaths, coordinates, typeName, selectionSet, currentPath, graphId, supergraphState) {
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === Kind.FIELD) {
+            const innerPath = `${currentPath}.${selection.name.value}`;
+            fieldPaths.add(innerPath);
+            if (Array.isArray(typeName)) {
+                for (const t of typeName) {
+                    coordinates.add(`${t}.${selection.name.value}`);
+                }
+            }
+            else {
+                coordinates.add(`${typeName}.${selection.name.value}`);
+            }
+            if (selection.selectionSet) {
+                const types = (Array.isArray(typeName) ? typeName : [typeName]).map(tName => {
+                    const outputType = supergraphState.objectTypes.get(tName) ?? supergraphState.interfaceTypes.get(tName);
+                    if (!outputType) {
+                        throw new Error(`Type "${tName}" is not defined.`);
+                    }
+                    return outputType;
+                });
+                const typesWithField = types.filter(t => t.fields.has(selection.name.value));
+                if (typesWithField.length === 0) {
+                    throw new Error(`Type "${typeName.toString()}" does not have field "${selection.name.value}".`);
+                }
+                const outputTypes = typesWithField.map(t => stripTypeModifiers(t.fields.get(selection.name.value).type));
+                findFieldPathsFromSelectionSet(fieldPaths, coordinates, outputTypes, selection.selectionSet, innerPath, graphId, supergraphState);
+            }
+        }
+        else if (selection.kind === Kind.INLINE_FRAGMENT) {
+            if (!selection.typeCondition) {
+                throw new Error(`Inline fragment without type condition is not supported.`);
+            }
+            findFieldPathsFromSelectionSet(fieldPaths, coordinates, selection.typeCondition.name.value, selection.selectionSet, `${currentPath}.(${selection.typeCondition.name.value})`, graphId, supergraphState);
+        }
+        else {
+            throw new Error(`Fragment spread is not supported.`);
+        }
+    }
+}