@wundergraph/composition 0.0.1

package/dist/federation/federation-factory.js

@@ -0,0 +1,843 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FederationFactory = exports.federateSubgraphs = void 0;
+const graphology_1 = require("graphology");
+const graphology_simple_path_1 = require("graphology-simple-path");
+const graphql_1 = require("graphql");
+const ast_1 = require("../ast/ast");
+const utils_1 = require("../ast/utils");
+const errors_1 = require("../errors/errors");
+const type_merging_1 = require("../type-merging/type-merging");
+const subgraph_1 = require("./subgraph");
+const string_constants_1 = require("../utils/string-constants");
+const utils_2 = require("../utils/utils");
+const normalization_factory_1 = require("../normalization/normalization-factory");
+function federateSubgraphs(subgraphs) {
+    if (subgraphs.length < 1) {
+        throw errors_1.minimumSubgraphRequirementError;
+    }
+    const normalizedSubgraphs = [];
+    const validationErrors = [];
+    const subgraphNames = new Set();
+    const nonUniqueSubgraphNames = new Set();
+    const invalidNameErrorMessages = [];
+    for (let i = 0; i < subgraphs.length; i++) {
+        const subgraph = subgraphs[i];
+        const name = subgraph.name || `subgraph-${i}-${Date.now()}`;
+        if (!subgraph.name) {
+            invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, name));
+        }
+        else {
+            (0, subgraph_1.validateSubgraphName)(subgraph.name, subgraphNames, nonUniqueSubgraphNames);
+        }
+        const { errors, normalizationResult } = (0, normalization_factory_1.normalizeSubgraph)(subgraph.definitions);
+        if (errors) {
+            validationErrors.push((0, errors_1.subgraphValidationError)(name, errors));
+            continue;
+        }
+        if (!normalizationResult) {
+            validationErrors.push((0, errors_1.subgraphValidationError)(name, [errors_1.subgraphValidationFailureErrorMessage]));
+            continue;
+        }
+        normalizedSubgraphs.push({
+            definitions: normalizationResult.subgraphAST,
+            isVersionTwo: normalizationResult.isVersionTwo,
+            name,
+            operationTypes: normalizationResult.operationTypes,
+            url: subgraph.url,
+        });
+    }
+    const allErrors = [];
+    if (invalidNameErrorMessages.length > 0 || nonUniqueSubgraphNames.size > 0) {
+        allErrors.push((0, errors_1.invalidSubgraphNamesError)(Array.from(nonUniqueSubgraphNames), invalidNameErrorMessages));
+    }
+    allErrors.push(...validationErrors);
+    if (allErrors.length > 0) {
+        return { errors: allErrors };
+    }
+    const federationFactory = new FederationFactory(normalizedSubgraphs);
+    return federationFactory.federate();
+}
+exports.federateSubgraphs = federateSubgraphs;
+class FederationFactory {
+    abstractToConcreteTypeNames = new Map();
+    areFieldsShareable = false;
+    argumentTypeNameSet = new Set();
+    parentTypeName = '';
+    currentSubgraphName = '';
+    childName = '';
+    directiveDefinitions = new Map();
+    entityMap = new Map();
+    errors = [];
+    extensions = new Map();
+    graph = new graphology_1.MultiGraph();
+    graphEdges = new Set();
+    inputFieldTypeNameSet = new Set();
+    isCurrentParentEntity = false;
+    isCurrentParentInterface = false;
+    isCurrentSubgraphVersionTwo = false;
+    isCurrentParentExtensionType = false;
+    isParentRootType = false;
+    isParentInputObject = false;
+    operationFieldsByResponseTypeName = new Map();
+    outputFieldTypeNameSet = new Set();
+    parentMap = new Map();
+    rootTypeNames = new Set([string_constants_1.DEFAULT_MUTATION, string_constants_1.DEFAULT_QUERY, string_constants_1.DEFAULT_SUBSCRIPTION]);
+    sharedOperationDependentResponses = new Map();
+    subgraphs = [];
+    shareableErrorTypeNames = new Map();
+    constructor(subgraphs) {
+        this.subgraphs = subgraphs;
+    }
+    isObjectRootType(node) {
+        return this.rootTypeNames.has(node.name.value);
+    }
+    upsertEntity(node) {
+        const typeName = node.name.value;
+        const entity = this.entityMap.get(typeName);
+        if (entity) {
+            (0, utils_1.extractEntityKeys)(node, entity.keys);
+            entity.subgraphs.add(this.currentSubgraphName);
+            return;
+        }
+        this.entityMap.set(typeName, {
+            fields: new Set(),
+            keys: (0, utils_1.extractEntityKeys)(node, new Set()),
+            subgraphs: new Set([this.currentSubgraphName]),
+        });
+    }
+    populateMultiGraphAndRenameOperations(subgraphs) {
+        for (const subgraph of subgraphs) {
+            this.currentSubgraphName = subgraph.name;
+            (0, subgraph_1.walkSubgraphToCollectObjects)(this, subgraph);
+            (0, subgraph_1.walkSubgraphToCollectOperationsAndFields)(this, subgraph);
+        }
+    }
+    isParentInterface(parent) {
+        return parent.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
+    }
+    isFieldEntityKey(parent) {
+        if (parent.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || parent.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            return parent.entityKeys.has(this.childName);
+        }
+        return false;
+    }
+    getEnumMergeMethod(enumName) {
+        if (this.inputFieldTypeNameSet.has(enumName) || this.argumentTypeNameSet.has(enumName)) {
+            if (this.outputFieldTypeNameSet.has(enumName)) {
+                return utils_1.MergeMethod.CONSISTENT;
+            }
+            return utils_1.MergeMethod.INTERSECTION;
+        }
+        return utils_1.MergeMethod.UNION;
+    }
+    validateArgumentDefaultValues(argName, existingDefaultValue, newDefaultValue) {
+        if (existingDefaultValue.kind !== newDefaultValue.kind) {
+            // This should be caught by subgraph validation
+            this.errors.push((0, errors_1.incompatibleArgumentDefaultValueTypeError)(argName, this.parentTypeName, this.childName, existingDefaultValue.kind, newDefaultValue.kind));
+        }
+        if ('value' in newDefaultValue && existingDefaultValue.value !== newDefaultValue.value) {
+            this.errors.push((0, errors_1.incompatibleArgumentDefaultValueError)(argName, this.parentTypeName, this.childName, existingDefaultValue.value, newDefaultValue.value));
+        }
+    }
+    compareAndValidateArgumentDefaultValues(existingArg, newArg) {
+        const newDefaultValue = newArg.defaultValue;
+        existingArg.node.defaultValue = existingArg.node.defaultValue || newDefaultValue;
+        if (!existingArg.node.defaultValue || !newDefaultValue) {
+            existingArg.includeDefaultValue = false;
+            return;
+        }
+        const existingDefaultValue = existingArg.node.defaultValue;
+        switch (existingDefaultValue.kind) {
+            case graphql_1.Kind.LIST: // TODO
+                break;
+            case graphql_1.Kind.NULL:
+                break;
+            case graphql_1.Kind.OBJECT:
+                break;
+            // BOOLEAN, ENUM, FLOAT, INT, and STRING purposely fall through
+            case graphql_1.Kind.BOOLEAN:
+            case graphql_1.Kind.ENUM:
+            case graphql_1.Kind.FLOAT:
+            case graphql_1.Kind.INT:
+            case graphql_1.Kind.STRING:
+                this.validateArgumentDefaultValues(existingArg.node.name.value, existingDefaultValue, newDefaultValue);
+                break;
+            default:
+                throw new Error('Unexpected argument type'); // TODO
+        }
+    }
+    upsertArgumentsForFieldNode(node, existingFieldNode) {
+        if (!node.arguments) {
+            return;
+        }
+        for (const arg of node.arguments) {
+            const argName = arg.name.value;
+            const argPath = `${node.name.value}(${argName}...)`;
+            this.argumentTypeNameSet.add((0, type_merging_1.getNamedTypeForChild)(argPath, arg.type));
+            const existingArg = existingFieldNode.arguments.get(argName);
+            if (existingArg) {
+                existingArg.appearances += 1;
+                existingArg.node.description = existingArg.node.description || arg.description;
+                const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(existingArg.node.type, arg.type, this.childName, argName);
+                if (typeNode) {
+                    existingArg.node.type = typeNode;
+                }
+                else {
+                    if (!typeErrors || typeErrors.length < 2) {
+                        throw new Error(''); // TODO this should never happen
+                    }
+                    this.errors.push((0, errors_1.incompatibleArgumentTypesError)(argName, this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
+                }
+                this.compareAndValidateArgumentDefaultValues(existingArg, arg);
+                return;
+            }
+            const newNode = (0, ast_1.inputValueDefinitionNodeToMutable)(arg, this.childName);
+            // TODO validation of default values
+            existingFieldNode.arguments.set(argName, {
+                appearances: 1,
+                includeDefaultValue: !!arg.defaultValue,
+                node: newNode,
+            });
+        }
+    }
+    extractArgumentsFromFieldNode(node, args) {
+        if (!node.arguments) {
+            return;
+        }
+        for (const arg of node.arguments) {
+            const argName = arg.name.value;
+            const argPath = `${node.name.value}(${argName}...)`;
+            args.set(argName, {
+                appearances: 1,
+                includeDefaultValue: !!arg.defaultValue,
+                node: (0, ast_1.inputValueDefinitionNodeToMutable)(arg, this.childName),
+            });
+            this.argumentTypeNameSet.add((0, type_merging_1.getNamedTypeForChild)(argPath, arg.type));
+        }
+    }
+    addConcreteTypesForInterface(node) {
+        if (!node.interfaces || node.interfaces.length < 1) {
+            return;
+        }
+        const concreteTypeName = node.name.value;
+        for (const iFace of node.interfaces) {
+            const interfaceName = iFace.name.value;
+            const concreteTypes = this.abstractToConcreteTypeNames.get(interfaceName);
+            if (concreteTypes) {
+                concreteTypes.add(concreteTypeName);
+            }
+            else {
+                this.abstractToConcreteTypeNames.set(interfaceName, new Set([concreteTypeName]));
+            }
+        }
+    }
+    addConcreteTypesForUnion(node) {
+        if (!node.types || node.types.length < 1) {
+            return;
+        }
+        const unionName = node.name.value;
+        for (const member of node.types) {
+            const memberName = member.name.value;
+            const concreteTypes = this.abstractToConcreteTypeNames.get(memberName);
+            if (concreteTypes) {
+                concreteTypes.add(memberName);
+            }
+            else {
+                this.abstractToConcreteTypeNames.set(unionName, new Set([memberName]));
+            }
+        }
+    }
+    isFieldShareable(node, parent) {
+        return (!this.isCurrentSubgraphVersionTwo ||
+            this.areFieldsShareable ||
+            (0, utils_1.isNodeShareable)(node) ||
+            (this.isCurrentParentEntity && this.isFieldEntityKey(parent)));
+    }
+    addPotentiallyUnresolvableField(parent, fieldName) {
+        const fieldContainer = (0, utils_2.getOrThrowError)(parent.fields, fieldName);
+        for (const [responseTypeName, operation] of this.operationFieldsByResponseTypeName) {
+            // If the operation response type has no path to the parent type, continue
+            const paths = (0, graphology_simple_path_1.allSimplePaths)(this.graph, responseTypeName, this.parentTypeName);
+            if (responseTypeName === this.parentTypeName) {
+                paths.push([this.parentTypeName]);
+            }
+            else if (paths.length < 1) {
+                continue;
+            }
+            // Construct all possible paths to the unresolvable field but with the fieldName relationship between nodes
+            const partialResolverPaths = [];
+            for (const path of paths) {
+                let hasEntityAncestor = false;
+                let resolverPath = '';
+                for (let i = 0; i < path.length - 1; i++) {
+                    const pathParent = path[i];
+                    // The field in question is resolvable if it has an entity ancestor within the same subgraph
+                    // Unresolvable fields further up the chain will be handled elsewhere
+                    const entity = this.entityMap.get(pathParent);
+                    if (entity && entity.subgraphs.has(this.currentSubgraphName)) {
+                        hasEntityAncestor = true;
+                        break;
+                    }
+                    const edges = this.graph.edges(pathParent, path[i + 1]);
+                    // If there are multiple edges, pick the first one
+                    const inlineFragment = this.graph.getEdgeAttribute(edges[0], string_constants_1.INLINE_FRAGMENT);
+                    const edgeName = this.graph.getEdgeAttribute(edges[0], string_constants_1.FIELD_NAME);
+                    // If the parent field is an abstract type, the child should be proceeded by an inline fragment
+                    resolverPath += edgeName + (inlineFragment || '.');
+                }
+                if (hasEntityAncestor) {
+                    continue;
+                }
+                // Add the unresolvable field to each path
+                resolverPath += fieldName;
+                // If the field could have fields itself, add ellipsis
+                if (this.graph.hasNode(fieldContainer.rootTypeName)) {
+                    resolverPath += ' { ... }';
+                }
+                partialResolverPaths.push(resolverPath);
+            }
+            if (partialResolverPaths.length < 1) {
+                return;
+            }
+            // Each of these operations returns a type that has a path to the parent
+            for (const [operationFieldPath, operationField] of operation) {
+                // If the operation is defined in a subgraph that the field is defined, it is resolvable
+                if ((0, utils_2.doSetsHaveAnyOverlap)(fieldContainer.subgraphs, operationField.subgraphs)) {
+                    continue;
+                }
+                const fullResolverPaths = [];
+                // The field is still resolvable if it's defined and resolved in another graph (but that isn't yet known)
+                // Consequently, the subgraphs must be compared later to determine that the field is always resolvable
+                for (const partialResolverPath of partialResolverPaths) {
+                    fullResolverPaths.push(`${operationFieldPath}${operationField.inlineFragment}${partialResolverPath}`);
+                }
+                const potentiallyUnresolvableField = {
+                    fieldContainer,
+                    fullResolverPaths,
+                    operationField,
+                };
+                // The parent might already have unresolvable fields that have already been added
+                const dependentResponsesByFieldName = this.sharedOperationDependentResponses.get(this.parentTypeName);
+                if (dependentResponsesByFieldName) {
+                    dependentResponsesByFieldName.push(potentiallyUnresolvableField);
+                    return;
+                }
+                this.sharedOperationDependentResponses.set(this.parentTypeName, [potentiallyUnresolvableField]);
+            }
+        }
+    }
+    upsertFieldNode(node) {
+        const parent = this.isCurrentParentExtensionType
+            ? (0, utils_2.getOrThrowError)(this.extensions, this.parentTypeName)
+            : (0, utils_2.getOrThrowError)(this.parentMap, this.parentTypeName);
+        if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+            parent.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
+            parent.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            throw new Error(''); // TODO
+        }
+        const fieldMap = parent.fields;
+        const isFieldShareable = this.isFieldShareable(node, parent);
+        const fieldPath = `${this.parentTypeName}.${this.childName}`;
+        const fieldRootTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
+        const existingFieldNode = fieldMap.get(this.childName);
+        const entityParent = this.entityMap.get(this.parentTypeName);
+        if (existingFieldNode) {
+            existingFieldNode.appearances += 1;
+            existingFieldNode.node.description = existingFieldNode.node.description || node.description;
+            existingFieldNode.subgraphs.add(this.currentSubgraphName);
+            existingFieldNode.subgraphsByShareable.set(this.currentSubgraphName, isFieldShareable);
+            const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingFieldNode.node.type, node.type, this.parentTypeName, this.childName);
+            if (typeNode) {
+                existingFieldNode.node.type = typeNode;
+            }
+            else {
+                if (!typeErrors || typeErrors.length < 2) {
+                    throw new Error(''); // TODO this should never happen
+                }
+                this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
+            }
+            this.upsertArgumentsForFieldNode(node, existingFieldNode);
+            if (!this.isCurrentParentInterface && !(existingFieldNode.isShareable || isFieldShareable)) {
+                // TODO
+                const shareableErrorTypeNames = this.shareableErrorTypeNames.get(this.parentTypeName);
+                if (shareableErrorTypeNames) {
+                    shareableErrorTypeNames.add(this.childName);
+                }
+                else {
+                    this.shareableErrorTypeNames.set(this.parentTypeName, new Set([this.childName]));
+                }
+            }
+            return;
+        }
+        const args = new Map();
+        this.extractArgumentsFromFieldNode(node, args);
+        this.outputFieldTypeNameSet.add(fieldRootTypeName);
+        fieldMap.set(this.childName, {
+            appearances: 1,
+            arguments: args,
+            isShareable: isFieldShareable,
+            node: (0, ast_1.fieldDefinitionNodeToMutable)(node, this.parentTypeName),
+            rootTypeName: fieldRootTypeName,
+            subgraphs: new Set([this.currentSubgraphName]),
+            subgraphsByShareable: new Map([[this.currentSubgraphName, isFieldShareable]]),
+        });
+        if (this.isParentRootType ||
+            entityParent?.fields.has(this.childName) ||
+            parent.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+            return;
+        }
+        this.addPotentiallyUnresolvableField(parent, this.childName);
+    }
+    upsertValueNode(node) {
+        const parent = this.parentMap.get(this.parentTypeName);
+        switch (node.kind) {
+            case graphql_1.Kind.ENUM_VALUE_DEFINITION:
+                if (!parent) {
+                    // This should never happen
+                    throw (0, errors_1.federationInvalidParentTypeError)(this.parentTypeName, this.childName);
+                }
+                if (parent.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION) {
+                    throw new Error(''); // TODO
+                }
+                const enumValues = parent.values;
+                const enumValue = enumValues.get(this.childName);
+                if (enumValue) {
+                    enumValue.node.description = enumValue.node.description || node.description;
+                    enumValue.appearances += 1;
+                    return;
+                }
+                enumValues.set(this.childName, {
+                    appearances: 1,
+                    node: (0, ast_1.enumValueDefinitionNodeToMutable)(node),
+                });
+                return;
+            case graphql_1.Kind.INPUT_VALUE_DEFINITION:
+                if (!parent || !this.isParentInputObject) {
+                    // TODO handle directives
+                    return;
+                }
+                if (parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+                    throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION, parent.kind);
+                }
+                const inputValues = parent.fields;
+                const inputValue = inputValues.get(this.childName);
+                if (inputValue) {
+                    inputValue.appearances += 1;
+                    inputValue.node.description = inputValue.node.description || node.description;
+                    const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(inputValue.node.type, node.type, this.parentTypeName, this.childName);
+                    if (typeNode) {
+                        inputValue.node.type = typeNode;
+                    }
+                    else {
+                        if (!typeErrors || typeErrors.length < 2) {
+                            throw new Error(''); // TODO this should never happen
+                        }
+                        this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
+                    }
+                    return;
+                }
+                const valuePath = `${this.parentTypeName}.${this.childName}`;
+                const inputValueNamedType = (0, type_merging_1.getNamedTypeForChild)(valuePath, node.type);
+                this.inputFieldTypeNameSet.add(inputValueNamedType);
+                inputValues.set(this.childName, {
+                    appearances: 1,
+                    includeDefaultValue: !!node.defaultValue,
+                    node: (0, ast_1.inputValueDefinitionNodeToMutable)(node, this.parentTypeName),
+                });
+                return;
+            default:
+                throw (0, errors_1.unexpectedKindFatalError)(this.childName);
+        }
+    }
+    upsertParentNode(node) {
+        const parentTypeName = node.name.value;
+        const parent = this.parentMap.get(parentTypeName);
+        if (parent) {
+            parent.node.description = parent.node.description || node.description;
+            parent.appearances += 1;
+        }
+        switch (node.kind) {
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                if (parent) {
+                    if (parent.kind !== node.kind) {
+                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
+                    }
+                    return;
+                }
+                this.parentMap.set(parentTypeName, {
+                    appearances: 1,
+                    values: new Map(),
+                    kind: node.kind,
+                    node: (0, ast_1.enumTypeDefinitionNodeToMutable)(node),
+                });
+                return;
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                if (parent) {
+                    if (parent.kind !== node.kind) {
+                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
+                    }
+                    return;
+                }
+                this.parentMap.set(parentTypeName, {
+                    appearances: 1,
+                    fields: new Map(),
+                    kind: node.kind,
+                    node: (0, ast_1.inputObjectTypeDefinitionNodeToMutable)(node),
+                });
+                return;
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                if (parent) {
+                    if (parent.kind !== node.kind) {
+                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
+                    }
+                    (0, utils_1.extractInterfaces)(node, parent.interfaces);
+                    parent.subgraphs.add(this.currentSubgraphName);
+                    return;
+                }
+                const nestedInterfaces = new Set();
+                (0, utils_1.extractInterfaces)(node, nestedInterfaces);
+                this.parentMap.set(parentTypeName, {
+                    appearances: 1,
+                    fields: new Map(),
+                    interfaces: nestedInterfaces,
+                    kind: node.kind,
+                    node: (0, ast_1.interfaceTypeDefinitionNodeToMutable)(node),
+                    subgraphs: new Set([this.currentSubgraphName]),
+                });
+                return;
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                if (parent) {
+                    if (parent.kind !== node.kind) {
+                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
+                    }
+                    return;
+                }
+                this.parentMap.set(parentTypeName, {
+                    appearances: 1,
+                    kind: node.kind,
+                    node: (0, ast_1.scalarTypeDefinitionNodeToMutable)(node),
+                });
+                return;
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                if (parent) {
+                    if (parent.kind !== node.kind) {
+                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
+                    }
+                    (0, utils_1.extractInterfaces)(node, parent.interfaces);
+                    (0, utils_1.extractEntityKeys)(node, parent.entityKeys);
+                    parent.subgraphs.add(this.currentSubgraphName);
+                    return;
+                }
+                const interfaces = new Set();
+                (0, utils_1.extractInterfaces)(node, interfaces);
+                const entityKeys = new Set();
+                (0, utils_1.extractEntityKeys)(node, entityKeys);
+                this.parentMap.set(parentTypeName, {
+                    appearances: 1,
+                    fields: new Map(),
+                    entityKeys,
+                    interfaces,
+                    isRootType: this.isParentRootType,
+                    kind: node.kind,
+                    node: (0, ast_1.objectTypeDefinitionNodeToMutable)(node),
+                    subgraphs: new Set([this.currentSubgraphName]),
+                });
+                return;
+            case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                if (parent) {
+                    if (parent.kind !== node.kind) {
+                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
+                    }
+                    if (!node.types || node.types.length < 1) {
+                        this.errors.push((0, errors_1.invalidUnionError)(parent.node.name.value));
+                        return;
+                    }
+                    node.types?.forEach((member) => parent.members.add(member.name.value));
+                    return;
+                }
+                this.parentMap.set(parentTypeName, {
+                    appearances: 1,
+                    kind: node.kind,
+                    members: new Set(node.types?.map((member) => member.name.value)),
+                    node: (0, ast_1.unionTypeDefinitionNodeToMutable)(node),
+                });
+                return;
+        }
+    }
+    upsertConcreteObjectLikeOperationFieldNode(fieldName, fieldTypeName, operationFieldPath, responseType, concreteTypeName = fieldTypeName, hasAbstractParent = false) {
+        const operationFields = this.operationFieldsByResponseTypeName.get(concreteTypeName);
+        if (!operationFields) {
+            this.operationFieldsByResponseTypeName.set(concreteTypeName, new Map([
+                [
+                    operationFieldPath,
+                    {
+                        inlineFragment: hasAbstractParent ? (0, utils_1.getInlineFragmentString)(concreteTypeName) : '.',
+                        name: fieldName,
+                        parentTypeName: this.parentTypeName,
+                        path: operationFieldPath,
+                        responseType,
+                        rootTypeName: fieldTypeName,
+                        subgraphs: new Set([this.currentSubgraphName]),
+                    },
+                ],
+            ]));
+            return;
+        }
+        const operationField = operationFields.get(operationFieldPath);
+        if (operationField) {
+            operationField.subgraphs.add(this.currentSubgraphName);
+            return;
+        }
+        operationFields.set(operationFieldPath, {
+            inlineFragment: hasAbstractParent ? (0, utils_1.getInlineFragmentString)(concreteTypeName) : '.',
+            name: fieldName,
+            parentTypeName: this.parentTypeName,
+            path: operationFieldPath,
+            responseType,
+            rootTypeName: fieldTypeName,
+            subgraphs: new Set([this.currentSubgraphName]),
+        });
+    }
+    upsertAbstractObjectLikeOperationFieldNode(fieldName, fieldTypeName, operationFieldPath, responseType, concreteTypeNames) {
+        for (const concreteTypeName of concreteTypeNames) {
+            if (!this.graph.hasNode(concreteTypeName)) {
+                throw (0, errors_1.invalidMultiGraphNodeFatalError)(concreteTypeName); // should never happen
+            }
+            if (!this.graphEdges.has(operationFieldPath)) {
+                this.graph.addEdge(this.parentTypeName, concreteTypeName, { fieldName });
+            }
+            // Always upsert the operation field node to record subgraph appearances
+            this.upsertConcreteObjectLikeOperationFieldNode(fieldName, fieldTypeName, operationFieldPath, responseType, concreteTypeName, true);
+        }
+        // Add the path so the edges are not added again
+        this.graphEdges.add(operationFieldPath);
+    }
+    validatePotentiallyUnresolvableFields() {
+        if (this.sharedOperationDependentResponses.size < 1) {
+            return;
+        }
+        for (const [parentTypeName, potentiallyUnresolvableFields] of this.sharedOperationDependentResponses) {
+            for (const potentiallyUnresolvableField of potentiallyUnresolvableFields) {
+                // There is no issue if the field is resolvable from at least one subgraph
+                const operationField = potentiallyUnresolvableField.operationField;
+                const fieldContainer = potentiallyUnresolvableField.fieldContainer;
+                if ((0, utils_2.doSetsHaveAnyOverlap)(fieldContainer.subgraphs, operationField.subgraphs)) {
+                    continue;
+                }
+                const fieldSubgraphs = Array.from(fieldContainer.subgraphs).join('", "');
+                this.errors.push((0, errors_1.unresolvableFieldError)(operationField, fieldContainer.node.name.value, potentiallyUnresolvableField.fullResolverPaths, fieldSubgraphs, parentTypeName));
+            }
+        }
+    }
+    upsertExtensionNode(node) {
+        const extension = this.extensions.get(this.parentTypeName);
+        if (extension) {
+            if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.OBJECT_TYPE_EXTENSION, extension.kind);
+            }
+            extension.appearances += 1;
+            extension.subgraphs.add(this.currentSubgraphName);
+            (0, utils_1.extractInterfaces)(node, extension.interfaces);
+            return;
+        }
+        // build a new extension
+        const interfaces = new Set();
+        (0, utils_1.extractInterfaces)(node, interfaces);
+        const entityKeys = new Set();
+        (0, utils_1.extractEntityKeys)(node, entityKeys);
+        this.extensions.set(this.parentTypeName, {
+            appearances: 1,
+            subgraphs: new Set([this.currentSubgraphName]),
+            isRootType: this.isParentRootType,
+            kind: graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+            node: (0, ast_1.objectTypeExtensionNodeToMutable)(node),
+            fields: new Map(),
+            entityKeys,
+            interfaces,
+        });
+    }
+    federate() {
+        this.populateMultiGraphAndRenameOperations(this.subgraphs);
+        const factory = this;
+        for (const subgraph of this.subgraphs) {
+            this.isCurrentSubgraphVersionTwo = subgraph.isVersionTwo;
+            this.currentSubgraphName = subgraph.name;
+            (0, subgraph_1.walkSubgraphToFederate)(subgraph.definitions, factory);
+        }
+        this.validatePotentiallyUnresolvableFields();
+        const definitions = [];
+        for (const definition of this.directiveDefinitions.values()) {
+            definitions.push(definition);
+        }
+        for (const [typeName, extension] of this.extensions) {
+            if (extension.isRootType && !this.parentMap.has(typeName)) {
+                this.upsertParentNode((0, ast_1.objectTypeExtensionNodeToMutableDefinitionNode)(extension.node));
+            }
+            const baseObject = this.parentMap.get(typeName);
+            if (!baseObject) {
+                this.errors.push((0, errors_1.noBaseTypeExtensionError)(typeName));
+                continue;
+            }
+            if (baseObject.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                throw (0, errors_1.incompatibleParentKindFatalError)(typeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, baseObject.kind);
+            }
+            // TODO check directives
+            for (const [fieldName, field] of extension.fields) {
+                const baseField = baseObject.fields.get(fieldName);
+                if (!baseField) {
+                    baseObject.fields.set(fieldName, field);
+                    continue;
+                }
+                if (baseField.isShareable && field.isShareable) {
+                    continue;
+                }
+                const parent = this.shareableErrorTypeNames.get(typeName);
+                if (parent) {
+                    parent.add(fieldName);
+                    continue;
+                }
+                this.shareableErrorTypeNames.set(typeName, new Set([fieldName]));
+            }
+            for (const interfaceName of extension.interfaces) {
+                baseObject.interfaces.add(interfaceName);
+            }
+        }
+        for (const [parentTypeName, children] of this.shareableErrorTypeNames) {
+            const parent = (0, utils_2.getOrThrowError)(this.parentMap, parentTypeName);
+            if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, parent.kind);
+            }
+            this.errors.push((0, errors_1.shareableFieldDefinitionsError)(parent, children));
+        }
+        for (const parent of this.parentMap.values()) {
+            const parentName = parent.node.name.value;
+            switch (parent.kind) {
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    const values = [];
+                    const mergeMethod = this.getEnumMergeMethod(parentName);
+                    for (const value of parent.values.values()) {
+                        switch (mergeMethod) {
+                            case utils_1.MergeMethod.CONSISTENT:
+                                if (value.appearances < parent.appearances) {
+                                    this.errors.push((0, errors_1.incompatibleSharedEnumError)(parentName));
+                                }
+                                values.push(value.node);
+                                break;
+                            case utils_1.MergeMethod.INTERSECTION:
+                                if (value.appearances === parent.appearances) {
+                                    values.push(value.node);
+                                }
+                                break;
+                            case utils_1.MergeMethod.UNION:
+                                values.push(value.node);
+                                break;
+                        }
+                    }
+                    parent.node.values = values;
+                    definitions.push(parent.node);
+                    break;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    const inputValues = [];
+                    for (const value of parent.fields.values()) {
+                        if (parent.appearances === value.appearances) {
+                            inputValues.push(value.node);
+                        }
+                        else if ((0, type_merging_1.isTypeRequired)(value.node.type)) {
+                            // TODO append to errors
+                            throw (0, errors_1.federationRequiredInputFieldError)(parentName, value.node.name.value);
+                        }
+                    }
+                    parent.node.fields = inputValues;
+                    definitions.push(parent.node);
+                    break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                    const interfaceFields = [];
+                    for (const field of parent.fields.values()) {
+                        if (field.arguments) {
+                            const args = [];
+                            for (const arg of field.arguments.values()) {
+                                arg.node.defaultValue = arg.includeDefaultValue ? arg.node.defaultValue : undefined;
+                                args.push(arg.node);
+                            }
+                            field.node.arguments = args;
+                        }
+                        interfaceFields.push(field.node);
+                    }
+                    const otherInterfaces = [];
+                    for (const iFace of parent.interfaces) {
+                        otherInterfaces.push({
+                            kind: graphql_1.Kind.NAMED_TYPE,
+                            name: {
+                                kind: graphql_1.Kind.NAME,
+                                value: iFace,
+                            },
+                        });
+                    }
+                    parent.node.interfaces = otherInterfaces;
+                    parent.node.fields = interfaceFields;
+                    definitions.push(parent.node);
+                    break;
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    const fields = [];
+                    for (const field of parent.fields.values()) {
+                        if (field.arguments) {
+                            const args = [];
+                            for (const arg of field.arguments.values()) {
+                                arg.node.defaultValue = arg.includeDefaultValue ? arg.node.defaultValue : undefined;
+                                args.push(arg.node);
+                            }
+                            field.node.arguments = args;
+                        }
+                        fields.push(field.node);
+                    }
+                    const interfaces = [];
+                    for (const iFace of parent.interfaces) {
+                        interfaces.push({
+                            kind: graphql_1.Kind.NAMED_TYPE,
+                            name: {
+                                kind: graphql_1.Kind.NAME,
+                                value: iFace,
+                            },
+                        });
+                    }
+                    parent.node.fields = fields;
+                    parent.node.interfaces = interfaces;
+                    definitions.push(parent.node);
+                    break;
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                    definitions.push(parent.node);
+                    break;
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                    const types = [];
+                    for (const member of parent.members) {
+                        types.push({
+                            kind: graphql_1.Kind.NAMED_TYPE,
+                            name: {
+                                kind: graphql_1.Kind.NAME,
+                                value: member,
+                            },
+                        });
+                    }
+                    parent.node.types = types;
+                    definitions.push(parent.node);
+                    break;
+            }
+        }
+        if (this.errors.length > 0) {
+            return {
+                errors: this.errors,
+            };
+        }
+        const newAst = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions,
+        };
+        return {
+            federatedGraphAST: newAst,
+            federatedGraphSchema: (0, graphql_1.buildASTSchema)(newAst),
+        };
+    }
+}
+exports.FederationFactory = FederationFactory;
+//# sourceMappingURL=federation-factory.js.map