@wundergraph/composition 0.5.3 → 0.6.0

package/dist/federation/federation-factory.js

@@ -1,74 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FederationFactory = exports.federateSubgraphs = void 0;
+exports.federateSubgraphs = exports.FederationFactory = 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 utils_2 = require("./utils");
 const subgraph_1 = require("../subgraph/subgraph");
 const string_constants_1 = require("../utils/string-constants");
-const utils_2 = require("../utils/utils");
-const normalization_factory_1 = require("../normalization/normalization-factory");
+const utils_3 = require("../utils/utils");
 const merge_1 = require("@graphql-tools/merge");
-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)([...nonUniqueSubgraphNames], invalidNameErrorMessages));
-    }
-    allErrors.push(...validationErrors);
-    if (allErrors.length > 0) {
-        return { errors: allErrors };
-    }
-    const federationFactory = new FederationFactory(normalizedSubgraphs);
-    return federationFactory.federate();
-}
-exports.federateSubgraphs = federateSubgraphs;
+const constants_1 = require("../utils/constants");
+const normalization_factory_1 = require("../normalization/normalization-factory");
 class FederationFactory {
     abstractToConcreteTypeNames = new Map();
     areFieldsShareable = false;
     argumentTypeNameSet = new Set();
+    argumentConfigurations = [];
+    executableDirectives = new Set();
     parentTypeName = '';
+    persistedDirectives = new Set([string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG]);
     currentSubgraphName = '';
     childName = '';
     directiveDefinitions = new Map();
-    entityMap = new Map();
+    entities = new Map();
     errors = [];
     extensions = new Map();
     graph = new graphology_1.MultiGraph();
@@ -82,10 +39,8 @@ class FederationFactory {
     isParentRootType = false;
     isParentInputObject = false;
     outputFieldTypeNameSet = new Set();
-    parentMap = new Map();
-    rootTypeFieldsByResponseTypeName = new Map();
+    parents = new Map();
     rootTypeNames = new Set([string_constants_1.DEFAULT_MUTATION, string_constants_1.DEFAULT_QUERY, string_constants_1.DEFAULT_SUBSCRIPTION]);
-    sharedRootTypeFieldDependentResponses = new Map();
     subgraphs = [];
     shareableErrorTypeNames = new Map();
     constructor(subgraphs) {
@@ -96,28 +51,25 @@ class FederationFactory {
     }
     upsertEntity(node) {
         const typeName = node.name.value;
-        const entity = this.entityMap.get(typeName);
+        const entity = this.entities.get(typeName);
         if (entity) {
-            (0, utils_1.extractEntityKeys)(node, entity.keys);
+            (0, utils_1.extractEntityKeys)(node, entity.keys, this.errors);
             entity.subgraphs.add(this.currentSubgraphName);
             return;
         }
-        this.entityMap.set(typeName, {
+        this.entities.set(typeName, {
             fields: new Set(),
-            keys: (0, utils_1.extractEntityKeys)(node, new Set()),
+            keys: (0, utils_1.extractEntityKeys)(node, new Set(), this.errors),
             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);
+            (0, subgraph_1.walkSubgraphToCollectObjectLikesAndDirectiveDefinitions)(this, subgraph);
+            (0, subgraph_1.walkSubgraphToCollectFields)(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);
@@ -127,11 +79,11 @@ class FederationFactory {
     getEnumMergeMethod(enumName) {
         if (this.inputFieldTypeNameSet.has(enumName) || this.argumentTypeNameSet.has(enumName)) {
             if (this.outputFieldTypeNameSet.has(enumName)) {
-                return utils_1.MergeMethod.CONSISTENT;
+                return utils_2.MergeMethod.CONSISTENT;
             }
-            return utils_1.MergeMethod.INTERSECTION;
+            return utils_2.MergeMethod.INTERSECTION;
         }
-        return utils_1.MergeMethod.UNION;
+        return utils_2.MergeMethod.UNION;
     }
     validateArgumentDefaultValues(argName, existingDefaultValue, newDefaultValue) {
         if (existingDefaultValue.kind !== newDefaultValue.kind) {
@@ -149,6 +101,7 @@ class FederationFactory {
             existingArg.includeDefaultValue = false;
             return;
         }
+        const argumentName = existingArg.node.name.value;
         const existingDefaultValue = existingArg.node.defaultValue;
         switch (existingDefaultValue.kind) {
             case graphql_1.Kind.LIST: // TODO
@@ -163,92 +116,54 @@ class FederationFactory {
             case graphql_1.Kind.FLOAT:
             case graphql_1.Kind.INT:
             case graphql_1.Kind.STRING:
-                this.validateArgumentDefaultValues(existingArg.node.name.value, existingDefaultValue, newDefaultValue);
+                this.validateArgumentDefaultValues(argumentName, existingDefaultValue, newDefaultValue);
                 break;
             default:
-                throw new Error('Unexpected argument type'); // TODO
+                throw (0, errors_1.unexpectedArgumentKindFatalError)(argumentName, this.childName);
         }
     }
-    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,
-            });
+    upsertRequiredSubgraph(set, isRequired) {
+        if (isRequired) {
+            set.add(this.currentSubgraphName);
         }
+        return set;
     }
-    extractArgumentsFromFieldNode(node, args) {
+    // TODO validation of default values
+    upsertArguments(node, argumentMap) {
         if (!node.arguments) {
-            return;
+            return argumentMap;
         }
-        for (const arg of node.arguments) {
-            const argName = arg.name.value;
+        for (const argumentNode of node.arguments) {
+            const argName = argumentNode.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]));
+            this.argumentTypeNameSet.add((0, type_merging_1.getNamedTypeForChild)(argPath, argumentNode.type));
+            const isRequired = (0, type_merging_1.isTypeRequired)(argumentNode.type);
+            const existingArgumentContainer = argumentMap.get(argName);
+            if (!existingArgumentContainer) {
+                argumentMap.set(argName, {
+                    includeDefaultValue: !!argumentNode.defaultValue,
+                    node: (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.childName),
+                    requiredSubgraphs: this.upsertRequiredSubgraph(new Set(), isRequired),
+                    subgraphs: new Set([this.currentSubgraphName]),
+                });
+                continue;
             }
-        }
-    }
-    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);
+            (0, utils_1.setLongestDescriptionForNode)(existingArgumentContainer.node, argumentNode.description);
+            this.upsertRequiredSubgraph(existingArgumentContainer.requiredSubgraphs, isRequired);
+            existingArgumentContainer.subgraphs.add(this.currentSubgraphName);
+            const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(existingArgumentContainer.node.type, argumentNode.type, this.childName, argName);
+            if (typeNode) {
+                existingArgumentContainer.node.type = typeNode;
             }
             else {
-                this.abstractToConcreteTypeNames.set(unionName, new Set([memberName]));
+                if (!typeErrors || typeErrors.length < 2) {
+                    throw (0, errors_1.argumentTypeMergeFatalError)(argName, this.childName);
+                }
+                this.errors.push((0, errors_1.incompatibleArgumentTypesError)(argName, this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
             }
+            this.compareAndValidateArgumentDefaultValues(existingArgumentContainer, argumentNode);
         }
+        return argumentMap;
     }
     isFieldShareable(node, parent) {
         return (!this.isCurrentSubgraphVersionTwo ||
@@ -256,129 +171,66 @@ class FederationFactory {
             (0, utils_1.isNodeShareable)(node) ||
             (this.isCurrentParentEntity && this.isFieldEntityKey(parent)));
     }
-    getAllSimplePaths(responseTypeName) {
-        if (responseTypeName === this.parentTypeName) {
-            return [[this.parentTypeName]];
-        }
-        const responsePaths = this.graphPaths.get(responseTypeName);
-        if (!responsePaths) {
-            const allPaths = (0, graphology_simple_path_1.allSimplePaths)(this.graph, responseTypeName, this.parentTypeName);
-            this.graphPaths.set(responseTypeName, new Map([
-                [this.parentTypeName, allPaths]
-            ]));
-            return allPaths;
-        }
-        const pathsToParent = responsePaths.get(this.parentTypeName);
-        if (pathsToParent) {
-            return pathsToParent;
-        }
-        const allParentPaths = (0, graphology_simple_path_1.allSimplePaths)(this.graph, responseTypeName, this.parentTypeName);
-        responsePaths.set(this.parentTypeName, allParentPaths);
-        return allParentPaths;
-    }
-    addPotentiallyUnresolvableField(parent, fieldName) {
-        const fieldContainer = (0, utils_2.getOrThrowError)(parent.fields, fieldName);
-        for (const [responseTypeName, rootTypeFields] of this.rootTypeFieldsByResponseTypeName) {
-            const paths = this.getAllSimplePaths(responseTypeName);
-            // If the rootTypeFields response type has no path to the parent type, continue
-            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 += string_constants_1.FRAGMENT_REPRESENTATION;
-                }
-                partialResolverPaths.push(resolverPath);
-            }
-            if (partialResolverPaths.length < 1) {
+    upsertDirectiveNode(node) {
+        const directiveName = node.name.value;
+        const directiveDefinition = this.directiveDefinitions.get(directiveName);
+        if (directiveDefinition) {
+            if (!this.executableDirectives.has(directiveName)) {
                 return;
             }
-            // Each of these rootTypeFields returns a type that has a path to the parent
-            for (const [rootTypeFieldPath, rootTypeField] of rootTypeFields) {
-                // If the rootTypeField is defined in a subgraph that the field is defined, it is resolvable
-                if ((0, utils_2.doSetsHaveAnyOverlap)(fieldContainer.subgraphs, rootTypeField.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(`${rootTypeFieldPath}${rootTypeField.inlineFragment}${partialResolverPath}`);
-                }
-                const potentiallyUnresolvableField = {
-                    fieldContainer,
-                    fullResolverPaths,
-                    rootTypeField: rootTypeField,
-                };
-                // The parent might already have unresolvable fields that have already been added
-                const dependentResponsesByFieldName = this.sharedRootTypeFieldDependentResponses.get(this.parentTypeName);
-                if (dependentResponsesByFieldName) {
-                    dependentResponsesByFieldName.push(potentiallyUnresolvableField);
-                    return;
-                }
-                this.sharedRootTypeFieldDependentResponses.set(this.parentTypeName, [potentiallyUnresolvableField]);
+            if ((0, utils_1.mergeExecutableDirectiveLocations)(node.locations, directiveDefinition).size < 1) {
+                this.executableDirectives.delete(directiveName);
+                return;
             }
+            this.upsertArguments(node, directiveDefinition.arguments);
+            (0, utils_1.setLongestDescriptionForNode)(directiveDefinition.node, node.description);
+            directiveDefinition.node.repeatable = directiveDefinition.node.repeatable && node.repeatable;
+            directiveDefinition.subgraphs.add(this.currentSubgraphName);
+            return;
+        }
+        const executableLocations = (0, utils_1.extractExecutableDirectiveLocations)(node.locations, new Set());
+        this.directiveDefinitions.set(directiveName, {
+            arguments: this.upsertArguments(node, new Map()),
+            executableLocations,
+            node: (0, ast_1.directiveDefinitionNodeToMutable)(node),
+            subgraphs: new Set([this.currentSubgraphName]),
+        });
+        if (executableLocations.size > 0) {
+            this.executableDirectives.add(directiveName);
         }
     }
     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) {
+            ? (0, utils_3.getOrThrowError)(this.extensions, this.parentTypeName, string_constants_1.EXTENSIONS)
+            : (0, utils_3.getOrThrowError)(this.parents, this.parentTypeName, string_constants_1.PARENTS);
+        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 (0, errors_1.unexpectedKindFatalError)(this.parentTypeName);
         }
         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);
+        const existingFieldContainer = fieldMap.get(this.childName);
+        if (existingFieldContainer) {
+            this.extractPersistedDirectives(node.directives || [], existingFieldContainer.directives);
+            (0, utils_1.setLongestDescriptionForNode)(existingFieldContainer.node, node.description);
+            existingFieldContainer.subgraphs.add(this.currentSubgraphName);
+            existingFieldContainer.subgraphsByShareable.set(this.currentSubgraphName, isFieldShareable);
+            const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingFieldContainer.node.type, node.type, this.parentTypeName, this.childName);
             if (typeNode) {
-                existingFieldNode.node.type = typeNode;
+                existingFieldContainer.node.type = typeNode;
             }
             else {
                 if (!typeErrors || typeErrors.length < 2) {
-                    throw new Error(''); // TODO this should never happen
+                    throw (0, errors_1.fieldTypeMergeFatalError)(this.childName);
                 }
                 this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
             }
-            this.upsertArgumentsForFieldNode(node, existingFieldNode);
+            this.upsertArguments(node, existingFieldContainer.arguments);
             // If the parent is not an interface and both fields are not shareable, is it is a shareable error
-            if (!this.isCurrentParentInterface && (!existingFieldNode.isShareable || !isFieldShareable)) {
+            if (!this.isCurrentParentInterface && (!existingFieldContainer.isShareable || !isFieldShareable)) {
                 const shareableErrorTypeNames = this.shareableErrorTypeNames.get(this.parentTypeName);
                 if (shareableErrorTypeNames) {
                     shareableErrorTypeNames.add(this.childName);
@@ -389,27 +241,22 @@ class FederationFactory {
             }
             return;
         }
-        const args = new Map();
-        this.extractArgumentsFromFieldNode(node, args);
         this.outputFieldTypeNameSet.add(fieldRootTypeName);
         fieldMap.set(this.childName, {
-            appearances: 1,
-            arguments: args,
+            arguments: this.upsertArguments(node, new Map()),
+            directives: this.extractPersistedDirectives(node.directives || [], {
+                directives: new Map(),
+                tags: new Map(),
+            }),
             isShareable: isFieldShareable,
             node: (0, ast_1.fieldDefinitionNodeToMutable)(node, this.parentTypeName),
-            rootTypeName: fieldRootTypeName,
+            namedTypeName: 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);
+        const parent = this.parents.get(this.parentTypeName);
         switch (node.kind) {
             case graphql_1.Kind.ENUM_VALUE_DEFINITION:
                 if (!parent) {
@@ -420,37 +267,43 @@ class FederationFactory {
                     throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.ENUM_TYPE_DEFINITION, parent.kind);
                 }
                 const enumValues = parent.values;
-                const enumValue = enumValues.get(this.childName);
-                if (enumValue) {
-                    enumValue.node.description = enumValue.node.description || node.description;
-                    enumValue.appearances += 1;
+                const enumValueContainer = enumValues.get(this.childName);
+                if (enumValueContainer) {
+                    this.extractPersistedDirectives(node.directives || [], enumValueContainer.directives);
+                    (0, utils_1.setLongestDescriptionForNode)(enumValueContainer.node, node.description);
+                    enumValueContainer.appearances += 1;
                     return;
                 }
                 enumValues.set(this.childName, {
                     appearances: 1,
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     node: (0, ast_1.enumValueDefinitionNodeToMutable)(node),
                 });
                 return;
             case graphql_1.Kind.INPUT_VALUE_DEFINITION:
                 if (!parent || !this.isParentInputObject) {
-                    // TODO handle directives
+                    // these are arguments to a directive
                     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);
+                const inputValueContainer = inputValues.get(this.childName);
+                if (inputValueContainer) {
+                    this.extractPersistedDirectives(node.directives || [], inputValueContainer.directives);
+                    inputValueContainer.appearances += 1;
+                    (0, utils_1.setLongestDescriptionForNode)(inputValueContainer.node, node.description);
+                    const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(inputValueContainer.node.type, node.type, this.parentTypeName, this.childName);
                     if (typeNode) {
-                        inputValue.node.type = typeNode;
+                        inputValueContainer.node.type = typeNode;
                     }
                     else {
                         if (!typeErrors || typeErrors.length < 2) {
-                            throw new Error(''); // TODO this should never happen
+                            throw (0, errors_1.fieldTypeMergeFatalError)(this.childName);
                         }
                         this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
                     }
@@ -461,6 +314,10 @@ class FederationFactory {
                 this.inputFieldTypeNameSet.add(inputValueNamedType);
                 inputValues.set(this.childName, {
                     appearances: 1,
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     includeDefaultValue: !!node.defaultValue,
                     node: (0, ast_1.inputValueDefinitionNodeToMutable)(node, this.parentTypeName),
                 });
@@ -471,10 +328,10 @@ class FederationFactory {
     }
     upsertParentNode(node) {
         const parentTypeName = node.name.value;
-        const parent = this.parentMap.get(parentTypeName);
+        const parent = this.parents.get(parentTypeName);
         if (parent) {
-            parent.node.description = parent.node.description || node.description;
-            parent.appearances += 1;
+            (0, utils_1.setLongestDescriptionForNode)(parent.node, node.description);
+            this.extractPersistedDirectives(node.directives || [], parent.directives);
         }
         switch (node.kind) {
             case graphql_1.Kind.ENUM_TYPE_DEFINITION:
@@ -482,10 +339,15 @@ class FederationFactory {
                     if (parent.kind !== node.kind) {
                         throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
                     }
+                    parent.appearances += 1;
                     return;
                 }
-                this.parentMap.set(parentTypeName, {
+                this.parents.set(parentTypeName, {
                     appearances: 1,
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     values: new Map(),
                     kind: node.kind,
                     node: (0, ast_1.enumTypeDefinitionNodeToMutable)(node),
@@ -496,10 +358,15 @@ class FederationFactory {
                     if (parent.kind !== node.kind) {
                         throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
                     }
+                    parent.appearances += 1;
                     return;
                 }
-                this.parentMap.set(parentTypeName, {
+                this.parents.set(parentTypeName, {
                     appearances: 1,
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     fields: new Map(),
                     kind: node.kind,
                     node: (0, ast_1.inputObjectTypeDefinitionNodeToMutable)(node),
@@ -516,8 +383,11 @@ class FederationFactory {
                 }
                 const nestedInterfaces = new Set();
                 (0, utils_1.extractInterfaces)(node, nestedInterfaces);
-                this.parentMap.set(parentTypeName, {
-                    appearances: 1,
+                this.parents.set(parentTypeName, {
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     fields: new Map(),
                     interfaces: nestedInterfaces,
                     kind: node.kind,
@@ -532,8 +402,11 @@ class FederationFactory {
                     }
                     return;
                 }
-                this.parentMap.set(parentTypeName, {
-                    appearances: 1,
+                this.parents.set(parentTypeName, {
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     kind: node.kind,
                     node: (0, ast_1.scalarTypeDefinitionNodeToMutable)(node),
                 });
@@ -544,16 +417,19 @@ class FederationFactory {
                         throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
                     }
                     (0, utils_1.extractInterfaces)(node, parent.interfaces);
-                    (0, utils_1.extractEntityKeys)(node, parent.entityKeys);
+                    (0, utils_1.extractEntityKeys)(node, parent.entityKeys, this.errors);
                     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,
+                (0, utils_1.extractEntityKeys)(node, entityKeys, this.errors);
+                this.parents.set(parentTypeName, {
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     fields: new Map(),
                     entityKeys,
                     interfaces,
@@ -575,8 +451,11 @@ class FederationFactory {
                     node.types?.forEach((member) => parent.members.add(member.name.value));
                     return;
                 }
-                this.parentMap.set(parentTypeName, {
-                    appearances: 1,
+                this.parents.set(parentTypeName, {
+                    directives: this.extractPersistedDirectives(node.directives || [], {
+                        directives: new Map(),
+                        tags: new Map(),
+                    }),
                     kind: node.kind,
                     members: new Set(node.types?.map((member) => member.name.value)),
                     node: (0, ast_1.unionTypeDefinitionNodeToMutable)(node),
@@ -584,98 +463,66 @@ class FederationFactory {
                 return;
         }
     }
-    upsertConcreteObjectLikeOperationFieldNode(fieldName, fieldTypeName, operationFieldPath, responseType, concreteTypeName = fieldTypeName, hasAbstractParent = false) {
-        const operationFields = this.rootTypeFieldsByResponseTypeName.get(concreteTypeName);
-        if (!operationFields) {
-            this.rootTypeFieldsByResponseTypeName.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.sharedRootTypeFieldDependentResponses.size < 1) {
-            return;
-        }
-        for (const [parentTypeName, potentiallyUnresolvableFields] of this.sharedRootTypeFieldDependentResponses) {
-            for (const potentiallyUnresolvableField of potentiallyUnresolvableFields) {
-                // There is no issue if the field is resolvable from at least one subgraph
-                const operationField = potentiallyUnresolvableField.rootTypeField;
-                const fieldContainer = potentiallyUnresolvableField.fieldContainer;
-                if ((0, utils_2.doSetsHaveAnyOverlap)(fieldContainer.subgraphs, operationField.subgraphs)) {
-                    continue;
-                }
-                const fieldSubgraphs = [...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);
+            this.extractPersistedDirectives(node.directives || [], extension.directives);
             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);
+        const interfaces = (0, utils_1.extractInterfaces)(node, new Set());
+        const entityKeys = (0, utils_1.extractEntityKeys)(node, new Set(), this.errors);
         this.extensions.set(this.parentTypeName, {
-            appearances: 1,
-            subgraphs: new Set([this.currentSubgraphName]),
+            directives: this.extractPersistedDirectives(node.directives || [], {
+                directives: new Map(),
+                tags: new Map(),
+            }),
+            entityKeys,
+            fields: new Map(),
+            interfaces,
             isRootType: this.isParentRootType,
             kind: graphql_1.Kind.OBJECT_TYPE_EXTENSION,
             node: (0, ast_1.objectTypeExtensionNodeToMutable)(node),
-            fields: new Map(),
-            entityKeys,
-            interfaces,
+            subgraphs: new Set([this.currentSubgraphName]),
         });
     }
+    isTypeValidImplementation(originalType, implementationType) {
+        if (originalType.kind === graphql_1.Kind.NON_NULL_TYPE) {
+            if (implementationType.kind !== graphql_1.Kind.NON_NULL_TYPE) {
+                return false;
+            }
+            return this.isTypeValidImplementation(originalType.type, implementationType.type);
+        }
+        if (implementationType.kind === graphql_1.Kind.NON_NULL_TYPE) {
+            return this.isTypeValidImplementation(originalType, implementationType.type);
+        }
+        switch (originalType.kind) {
+            case graphql_1.Kind.NAMED_TYPE:
+                if (implementationType.kind === graphql_1.Kind.NAMED_TYPE) {
+                    const originalTypeName = originalType.name.value;
+                    const implementationTypeName = implementationType.name.value;
+                    if (originalTypeName === implementationTypeName) {
+                        return true;
+                    }
+                    const concreteTypes = this.abstractToConcreteTypeNames.get(originalTypeName);
+                    if (!concreteTypes) {
+                        return false;
+                    }
+                    return concreteTypes.has(implementationTypeName);
+                }
+                return false;
+            default:
+                if (implementationType.kind === graphql_1.Kind.LIST_TYPE) {
+                    return this.isTypeValidImplementation(originalType.type, implementationType.type);
+                }
+                return false;
+        }
+    }
     getAndValidateImplementedInterfaces(container) {
         const interfaces = [];
         if (container.interfaces.size < 1) {
@@ -684,7 +531,11 @@ class FederationFactory {
         const implementationErrorsMap = new Map();
         for (const interfaceName of container.interfaces) {
             interfaces.push((0, utils_1.stringToNamedTypeNode)(interfaceName));
-            const interfaceContainer = (0, utils_2.getOrThrowError)(this.parentMap, interfaceName);
+            const interfaceContainer = this.parents.get(interfaceName);
+            if (!interfaceContainer) {
+                this.errors.push((0, errors_1.undefinedTypeError)(interfaceName));
+                continue;
+            }
             if (interfaceContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                 throw (0, errors_1.incompatibleParentKindFatalError)(interfaceName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceContainer.kind);
             }
@@ -708,7 +559,7 @@ class FederationFactory {
                     unimplementedArguments: new Set(),
                 };
                 // The implemented field type must be equally or more restrictive than the original interface field type
-                if (!(0, utils_2.isTypeValidImplementation)(interfaceField.node.type, containerField.node.type)) {
+                if (!this.isTypeValidImplementation(interfaceField.node.type, containerField.node.type)) {
                     hasErrors = true;
                     hasNestedErrors = true;
                     invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(containerField.node.type);
@@ -756,10 +607,233 @@ class FederationFactory {
             }
         }
         if (implementationErrorsMap.size) {
-            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.node.name.value, (0, utils_2.kindToTypeString)(container.kind), implementationErrorsMap));
+            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.node.name.value, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
         }
         return interfaces;
     }
+    mergeArguments(container, args, errors, argumentNames) {
+        for (const argumentContainer of container.arguments.values()) {
+            const missingSubgraphs = (0, utils_3.getEntriesNotInHashSet)(container.subgraphs, argumentContainer.subgraphs);
+            const argumentName = argumentContainer.node.name.value;
+            if (missingSubgraphs.length > 0) {
+                // Required arguments must be defined in all subgraphs that define the field
+                if (argumentContainer.requiredSubgraphs.size > 0) {
+                    errors.push({
+                        argumentName,
+                        missingSubgraphs,
+                        requiredSubgraphs: [...argumentContainer.requiredSubgraphs]
+                    });
+                }
+                // If the argument is always optional, but it's not defined in all subgraphs that define the field,
+                // the argument should not be included in the federated graph
+                continue;
+            }
+            argumentContainer.node.defaultValue = argumentContainer.includeDefaultValue
+                ? argumentContainer.node.defaultValue : undefined;
+            args.push(argumentContainer.node);
+            if (argumentNames) {
+                argumentNames.push(argumentName);
+            }
+        }
+    }
+    addValidExecutableDirectiveDefinition(directiveName, directiveContainer, definitions) {
+        if (!this.executableDirectives.has(directiveName)) {
+            return;
+        }
+        if (this.subgraphs.length !== directiveContainer.subgraphs.size) {
+            return;
+        }
+        directiveContainer.node.locations = (0, utils_1.setToNameNodeArray)(directiveContainer.executableLocations);
+        if (!directiveContainer.arguments) {
+            definitions.push(directiveContainer.node);
+            return;
+        }
+        const args = [];
+        const errors = [];
+        this.mergeArguments(directiveContainer, args, errors);
+        if (errors.length > 0) {
+            this.errors.push((0, errors_1.invalidRequiredArgumentsError)(string_constants_1.DIRECTIVE_DEFINITION, directiveName, errors));
+            return;
+        }
+        directiveContainer.node.arguments = args;
+        definitions.push(directiveContainer.node);
+    }
+    getMergedFieldDefinitionNode(fieldContainer, parentTypeName) {
+        if (!fieldContainer.arguments) {
+            return fieldContainer.node;
+        }
+        (0, utils_1.pushPersistedDirectivesToNode)(fieldContainer);
+        const fieldName = fieldContainer.node.name.value;
+        const fieldPath = `${parentTypeName}.${fieldName}`;
+        const args = [];
+        const errors = [];
+        const argumentNames = [];
+        this.mergeArguments(fieldContainer, args, errors, argumentNames);
+        if (errors.length > 0) {
+            this.errors.push((0, errors_1.invalidRequiredArgumentsError)(string_constants_1.FIELD, fieldPath, errors));
+        }
+        else if (argumentNames.length > 0) {
+            this.argumentConfigurations.push({
+                argumentNames,
+                fieldName,
+                typeName: parentTypeName
+            });
+        }
+        fieldContainer.node.arguments = args;
+        return fieldContainer.node;
+    }
+    // tags with the same name string are merged
+    mergeTagDirectives(directive, map) {
+        // the directive has been validated in the normalizer
+        if (!directive.arguments || directive.arguments.length !== 1) {
+            this.errors.push(errors_1.invalidTagDirectiveError); // should never happen
+            return;
+        }
+        const nameArgument = directive.arguments[0].value;
+        if (nameArgument.kind !== graphql_1.Kind.STRING) {
+            this.errors.push(errors_1.invalidTagDirectiveError); // should never happen
+            return;
+        }
+        map.set(nameArgument.value, directive);
+    }
+    extractPersistedDirectives(directives, container) {
+        if (directives.length < 1) {
+            return container;
+        }
+        for (const directive of directives) {
+            const directiveName = directive.name.value;
+            if (!this.persistedDirectives.has(directiveName)) {
+                continue;
+            }
+            if (directiveName === string_constants_1.TAG) {
+                this.mergeTagDirectives(directive, container.tags);
+                continue;
+            }
+            const existingDirectives = container.directives.get(directiveName);
+            if (!existingDirectives) {
+                container.directives.set(directiveName, [directive]);
+                continue;
+            }
+            // Naïvely ignore non-repeatable directives
+            const definition = (0, utils_3.getOrThrowError)(this.directiveDefinitions, directiveName, 'directiveDefinitions');
+            if (!definition.node.repeatable) {
+                continue;
+            }
+            existingDirectives.push(directive);
+        }
+        return container;
+    }
+    entityAncestor(entityAncestors, fieldSubgraphs, parentTypeName) {
+        if (!this.graph.hasNode(parentTypeName)) {
+            return false;
+        }
+        for (const entityAncestorName of entityAncestors) {
+            const path = `${entityAncestorName}.${parentTypeName}`;
+            if (this.graphPaths.get(path)) {
+                return true;
+            }
+            if (entityAncestorName === parentTypeName) {
+                const hasOverlap = (0, utils_3.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entities, entityAncestorName, string_constants_1.ENTITIES).subgraphs);
+                this.graphPaths.set(path, hasOverlap);
+                return hasOverlap;
+            }
+            if ((0, utils_3.hasSimplePath)(this.graph, entityAncestorName, parentTypeName)) {
+                this.graphPaths.set(path, true);
+                return true;
+            }
+            this.graphPaths.set(path, false);
+        }
+        return false;
+    }
+    evaluateResolvabilityOfObject(parentContainer, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, isParentAbstract = false) {
+        const parentTypeName = parentContainer.node.name.value;
+        if (evaluatedObjectLikes.has(parentTypeName)) {
+            return;
+        }
+        for (const [fieldName, fieldContainer] of parentContainer.fields) {
+            const fieldNamedTypeName = fieldContainer.namedTypeName;
+            if (string_constants_1.ROOT_TYPES.has(fieldNamedTypeName)) {
+                continue;
+            }
+            // Avoid an infinite loop with self-referential objects
+            if (evaluatedObjectLikes.has(fieldNamedTypeName)) {
+                continue;
+            }
+            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldContainer.subgraphs);
+            const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
+            const entity = this.entities.get(fieldNamedTypeName);
+            if (isFieldResolvable || this.entityAncestor(entityAncestors, fieldContainer.subgraphs, parentTypeName)) {
+                // The base scalars are not in this.parentMap
+                if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
+                    continue;
+                }
+                const childContainer = (0, utils_3.getOrThrowError)(this.parents, fieldNamedTypeName, string_constants_1.PARENTS);
+                switch (childContainer.kind) {
+                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    // intentional fallthrough
+                    case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                        continue;
+                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, newCurrentFieldPath, new Set([...evaluatedObjectLikes, parentTypeName]), entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors]);
+                        continue;
+                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                    // intentional fallthrough
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                        this.evaluateResolvabilityOfAbstractType(fieldNamedTypeName, childContainer.kind, rootTypeFieldData, newCurrentFieldPath, new Set([...evaluatedObjectLikes, parentTypeName]), entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors], fieldContainer.subgraphs);
+                        continue;
+                    default:
+                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
+                        continue;
+                }
+            }
+            if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
+                this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphs], newCurrentFieldPath, parentTypeName));
+                continue;
+            }
+            const childContainer = (0, utils_3.getOrThrowError)(this.parents, fieldNamedTypeName, string_constants_1.PARENTS);
+            switch (childContainer.kind) {
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                // intentional fallthrough
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphs], newCurrentFieldPath, parentTypeName));
+                    continue;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                // intentional fallthrough
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                // intentional fallthrough
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphs], newCurrentFieldPath + string_constants_1.SELECTION_REPRESENTATION, parentTypeName));
+                    continue;
+                default:
+                    this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
+            }
+        }
+    }
+    evaluateResolvabilityOfAbstractType(fieldNamedTypeName, fieldNamedTypeKind, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, parentSubgraphs) {
+        if (evaluatedObjectLikes.has(fieldNamedTypeName)) {
+            return;
+        }
+        const concreteTypeNames = this.abstractToConcreteTypeNames.get(fieldNamedTypeName);
+        if (!concreteTypeNames) {
+            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_3.kindToTypeString)(fieldNamedTypeKind), fieldNamedTypeName);
+            return;
+        }
+        for (const concreteTypeName of concreteTypeNames) {
+            if (evaluatedObjectLikes.has(concreteTypeName)) {
+                continue;
+            }
+            const concreteParentContainer = (0, utils_3.getOrThrowError)(this.parents, concreteTypeName, string_constants_1.PARENTS);
+            if (concreteParentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                // throw
+                continue;
+            }
+            if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteParentContainer.subgraphs, parentSubgraphs)) {
+                continue;
+            }
+            const entity = this.entities.get(concreteTypeName);
+            this.evaluateResolvabilityOfObject(concreteParentContainer, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, new Set([...evaluatedObjectLikes, fieldNamedTypeName]), entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
+        }
+    }
     federate() {
         this.populateMultiGraphAndRenameOperations(this.subgraphs);
         const factory = this;
@@ -768,16 +842,20 @@ class FederationFactory {
             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 [directiveName, directiveContainer] of this.directiveDefinitions) {
+            if (this.persistedDirectives.has(directiveName)) {
+                definitions.push(directiveContainer.node);
+                continue;
+            }
+            // The definitions must be present in all subgraphs to kept in the federated graph
+            this.addValidExecutableDirectiveDefinition(directiveName, directiveContainer, definitions);
         }
         for (const [typeName, extension] of this.extensions) {
-            if (extension.isRootType && !this.parentMap.has(typeName)) {
+            if (extension.isRootType && !this.parents.has(typeName)) {
                 this.upsertParentNode((0, ast_1.objectTypeExtensionNodeToMutableDefinitionNode)(extension.node));
             }
-            const baseObject = this.parentMap.get(typeName);
+            const baseObject = this.parents.get(typeName);
             if (!baseObject) {
                 this.errors.push((0, errors_1.noBaseTypeExtensionError)(typeName));
                 continue;
@@ -785,152 +863,238 @@ class FederationFactory {
             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);
+            for (const [extensionFieldName, extensionFieldContainer] of extension.fields) {
+                const baseFieldContainer = baseObject.fields.get(extensionFieldName);
+                if (!baseFieldContainer) {
+                    baseObject.fields.set(extensionFieldName, extensionFieldContainer);
                     continue;
                 }
-                if (baseField.isShareable && field.isShareable) {
+                if (baseFieldContainer.isShareable && extensionFieldContainer.isShareable) {
+                    (0, utils_1.setLongestDescriptionForNode)(baseFieldContainer.node, extensionFieldContainer.node.description);
+                    (0, utils_3.addIterableValuesToSet)(extensionFieldContainer.subgraphs, baseFieldContainer.subgraphs);
                     continue;
                 }
                 const parent = this.shareableErrorTypeNames.get(typeName);
                 if (parent) {
-                    parent.add(fieldName);
+                    parent.add(extensionFieldName);
                     continue;
                 }
-                this.shareableErrorTypeNames.set(typeName, new Set([fieldName]));
+                this.shareableErrorTypeNames.set(typeName, new Set([extensionFieldName]));
             }
             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);
+            const parent = (0, utils_3.getOrThrowError)(this.parents, parentTypeName, string_constants_1.PARENTS);
             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) {
+        const objectLikeContainersWithInterfaces = [];
+        for (const parentContainer of this.parents.values()) {
+            const parentTypeName = parentContainer.node.name.value;
+            switch (parentContainer.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     const values = [];
-                    const mergeMethod = this.getEnumMergeMethod(parentName);
-                    for (const value of parent.values.values()) {
+                    const mergeMethod = this.getEnumMergeMethod(parentTypeName);
+                    for (const enumValueContainer of parentContainer.values.values()) {
+                        (0, utils_1.pushPersistedDirectivesToNode)(enumValueContainer);
                         switch (mergeMethod) {
-                            case utils_1.MergeMethod.CONSISTENT:
-                                if (value.appearances < parent.appearances) {
-                                    this.errors.push((0, errors_1.incompatibleSharedEnumError)(parentName));
+                            case utils_2.MergeMethod.CONSISTENT:
+                                if (enumValueContainer.appearances < parentContainer.appearances) {
+                                    this.errors.push((0, errors_1.incompatibleSharedEnumError)(parentTypeName));
                                 }
-                                values.push(value.node);
+                                values.push(enumValueContainer.node);
                                 break;
-                            case utils_1.MergeMethod.INTERSECTION:
-                                if (value.appearances === parent.appearances) {
-                                    values.push(value.node);
+                            case utils_2.MergeMethod.INTERSECTION:
+                                if (enumValueContainer.appearances === parentContainer.appearances) {
+                                    values.push(enumValueContainer.node);
                                 }
                                 break;
                             default:
-                                values.push(value.node);
+                                values.push(enumValueContainer.node);
                                 break;
                         }
                     }
-                    parent.node.values = values;
-                    definitions.push(parent.node);
+                    parentContainer.node.values = values;
+                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
                     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);
+                    for (const inputValueContainer of parentContainer.fields.values()) {
+                        (0, utils_1.pushPersistedDirectivesToNode)(inputValueContainer);
+                        if (parentContainer.appearances === inputValueContainer.appearances) {
+                            inputValues.push(inputValueContainer.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);
+                        else if ((0, type_merging_1.isTypeRequired)(inputValueContainer.node.type)) {
+                            this.errors.push((0, errors_1.federationRequiredInputFieldError)(parentTypeName, inputValueContainer.node.name.value));
+                            break;
                         }
                     }
-                    parent.node.fields = inputValues;
-                    definitions.push(parent.node);
+                    parentContainer.node.fields = inputValues;
+                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
                     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);
+                    for (const fieldContainer of parentContainer.fields.values()) {
+                        interfaceFields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
+                    }
+                    parentContainer.node.fields = interfaceFields;
+                    (0, utils_1.pushPersistedDirectivesToNode)(parentContainer);
+                    // Interface implementations can only be evaluated after they've been fully merged
+                    if (parentContainer.interfaces.size > 0) {
+                        objectLikeContainersWithInterfaces.push(parentContainer);
                     }
-                    const otherInterfaces = [];
-                    for (const iFace of parent.interfaces) {
-                        otherInterfaces.push({
-                            kind: graphql_1.Kind.NAMED_TYPE,
-                            name: {
-                                kind: graphql_1.Kind.NAME,
-                                value: iFace,
-                            },
-                        });
+                    else {
+                        definitions.push(parentContainer.node);
                     }
-                    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);
+                    for (const fieldContainer of parentContainer.fields.values()) {
+                        fields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
+                    }
+                    parentContainer.node.fields = fields;
+                    (0, utils_1.pushPersistedDirectivesToNode)(parentContainer);
+                    // Interface implementations can only be evaluated after they've been fully merged
+                    if (parentContainer.interfaces.size > 0) {
+                        objectLikeContainersWithInterfaces.push(parentContainer);
+                    }
+                    else {
+                        definitions.push(parentContainer.node);
                     }
-                    parent.node.fields = fields;
-                    parent.node.interfaces = this.getAndValidateImplementedInterfaces(parent);
-                    definitions.push(parent.node);
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    definitions.push(parent.node);
+                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
                     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,
-                            },
-                        });
+                    for (const memberName of parentContainer.members) {
+                        types.push((0, utils_1.stringToNamedTypeNode)(memberName));
                     }
-                    parent.node.types = types;
-                    definitions.push(parent.node);
+                    parentContainer.node.types = types;
+                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
                     break;
             }
         }
+        for (const container of objectLikeContainersWithInterfaces) {
+            container.node.interfaces = this.getAndValidateImplementedInterfaces(container);
+            definitions.push(container.node);
+        }
+        if (!this.parents.has(string_constants_1.QUERY)) {
+            this.errors.push(errors_1.noQueryRootTypeError);
+        }
+        // return any composition errors before checking whether all fields are resolvable
         if (this.errors.length > 0) {
-            return {
-                errors: this.errors,
-            };
+            return { errors: this.errors };
+        }
+        for (const rootTypeName of string_constants_1.ROOT_TYPES) {
+            const rootTypeContainer = this.parents.get(rootTypeName);
+            if (!rootTypeContainer || rootTypeContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                continue;
+            }
+            // If a root type field returns a Scalar or Enum, track it so that it is not evaluated it again
+            const evaluatedNamedTypes = new Set(constants_1.BASE_SCALARS);
+            for (const [rootTypeFieldName, rootTypeFieldContainer] of rootTypeContainer.fields) {
+                const rootTypeFieldNamedTypeName = rootTypeFieldContainer.namedTypeName;
+                if (evaluatedNamedTypes.has(rootTypeFieldNamedTypeName)) {
+                    continue;
+                }
+                const childContainer = (0, utils_3.getOrThrowError)(this.parents, rootTypeFieldNamedTypeName, string_constants_1.PARENTS);
+                const fieldPath = `${rootTypeName}.${rootTypeFieldName}`;
+                const rootTypeFieldData = {
+                    fieldName: rootTypeFieldName,
+                    fieldTypeNodeString: (0, merge_1.printTypeNode)(rootTypeFieldContainer.node.type),
+                    path: fieldPath,
+                    typeName: rootTypeName,
+                    subgraphs: rootTypeFieldContainer.subgraphs,
+                };
+                const evaluatedObjectLikes = new Set();
+                switch (childContainer.kind) {
+                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    // intentional fallthrough
+                    case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                        // Root type fields whose response type is an Enums and Scalars will always be resolvable
+                        // Consequently, subsequent checks can be skipped
+                        evaluatedNamedTypes.add(rootTypeFieldNamedTypeName);
+                        continue;
+                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, fieldPath, evaluatedObjectLikes, this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
+                        continue;
+                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                    // intentional fallthrough
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                        this.evaluateResolvabilityOfAbstractType(rootTypeFieldNamedTypeName, childContainer.kind, rootTypeFieldData, fieldPath, evaluatedObjectLikes, this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : [], rootTypeFieldContainer.subgraphs);
+                        continue;
+                    default:
+                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
+                }
+            }
+        }
+        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),
+            federationResult: {
+                argumentConfigurations: this.argumentConfigurations,
+                federatedGraphAST: newAst,
+                federatedGraphSchema: (0, graphql_1.buildASTSchema)(newAst),
+            }
         };
     }
 }
 exports.FederationFactory = FederationFactory;
+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)([...nonUniqueSubgraphNames], invalidNameErrorMessages));
+    }
+    allErrors.push(...validationErrors);
+    if (allErrors.length > 0) {
+        return { errors: allErrors };
+    }
+    const federationFactory = new FederationFactory(normalizedSubgraphs);
+    return federationFactory.federate();
+}
+exports.federateSubgraphs = federateSubgraphs;
 //# sourceMappingURL=federation-factory.js.map