@wundergraph/composition 0.58.0 → 0.58.2

package/dist/v1/federation/federation-factory.js

@@ -13,9 +13,8 @@ const strings_1 = require("../constants/strings");
 const utils_3 = require("../utils/utils");
 const merge_1 = require("@graphql-tools/merge");
 const constants_1 = require("../constants/constants");
-const normalization_factory_1 = require("../normalization/normalization-factory");
 const utils_4 = require("../normalization/utils");
-const types_1 = require("../../schema-building/types");
+const types_1 = require("../../schema-building/types/types");
 const utils_5 = require("../../schema-building/utils");
 const walkers_1 = require("./walkers");
 const lodash_1 = require("lodash");
@@ -25,6 +24,7 @@ const integer_constants_1 = require("../../utils/integer-constants");
 const utils_6 = require("../../utils/utils");
 const warnings_1 = require("../warnings/warnings");
 const directive_definitions_1 = require("../constants/directive-definitions");
+const batch_normalizer_1 = require("../normalization/batch-normalization/batch-normalizer");
 class FederationFactory {
     authorizationDataByParentTypeName;
     coordsByNamedTypeName = new Map();
@@ -35,7 +35,9 @@ class FederationFactory {
     subgraphNamesByNamedTypeNameByFieldCoords = new Map();
     entityDataByTypeName;
     entityInterfaceFederationDataByTypeName;
+    executableDirectiveDatasByName;
     errors = [];
+    federatedDirectiveDataByName;
     fieldConfigurationByFieldCoords = new Map();
     fieldCoordsByNamedTypeName;
     inaccessibleCoords = new Set();
@@ -51,41 +53,36 @@ class FederationFactory {
     options;
     parentDefinitionDataByTypeName = new Map();
     parentTagDataByTypeName = new Map();
-    persistedDirectiveDefinitionByDirectiveName = new Map([
-        [string_constants_1.AUTHENTICATED, directive_definitions_1.AUTHENTICATED_DEFINITION],
-        [string_constants_1.DEPRECATED, directive_definitions_1.DEPRECATED_DEFINITION],
-        [string_constants_1.INACCESSIBLE, directive_definitions_1.INACCESSIBLE_DEFINITION],
-        [string_constants_1.ONE_OF, directive_definitions_1.ONE_OF_DEFINITION],
-        [string_constants_1.REQUIRES_SCOPES, directive_definitions_1.REQUIRES_SCOPES_DEFINITION],
-        [string_constants_1.SEMANTIC_NON_NULL, directive_definitions_1.SEMANTIC_NON_NULL_DEFINITION],
-        [string_constants_1.TAG, directive_definitions_1.TAG_DEFINITION],
-    ]);
-    potentialPersistedDirectiveDefinitionDataByDirectiveName = new Map();
-    referencedPersistedDirectiveNames = new Set();
+    referencedFederatedDirectiveNames = new Set();
     routerDefinitions = [];
     subscriptionFilterDataByFieldPath = new Map();
     tagNamesByCoords = new Map();
     warnings;
-    constructor({ authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityDataByTypeName, entityInterfaceFederationDataByTypeName, fieldCoordsByNamedTypeName, interfaceImplementationTypeNamesByInterfaceTypeName, internalGraph, internalSubgraphBySubgraphName, options, warnings, }) {
+    constructor({ authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityDataByTypeName, entityInterfaceFederationDataByTypeName, executableDirectiveDatasByName, federatedDirectiveDataByName, fieldCoordsByNamedTypeName, interfaceImplementationTypeNamesByInterfaceTypeName, internalGraph, internalSubgraphBySubgraphName, options, warnings, }) {
         this.authorizationDataByParentTypeName = authorizationDataByParentTypeName;
         this.options = options ?? {};
         this.concreteTypeNamesByAbstractTypeName = concreteTypeNamesByAbstractTypeName;
+        this.executableDirectiveDatasByName = executableDirectiveDatasByName;
         this.entityDataByTypeName = entityDataByTypeName;
         this.entityInterfaceFederationDataByTypeName = entityInterfaceFederationDataByTypeName;
+        this.federatedDirectiveDataByName = federatedDirectiveDataByName;
+        for (const data of utils_4.FEDERATED_DIRECTIVE_DATAS) {
+            this.federatedDirectiveDataByName.set(data.name, data);
+        }
         this.fieldCoordsByNamedTypeName = fieldCoordsByNamedTypeName;
         this.interfaceImplementationTypeNamesByInterfaceTypeName = interfaceImplementationTypeNamesByInterfaceTypeName;
         this.internalGraph = internalGraph;
         this.internalSubgraphBySubgraphName = internalSubgraphBySubgraphName;
         this.warnings = warnings;
     }
-    extractPersistedDirectives({ data, directivesByName }) {
+    extractFederatedDirectives({ data, directivesByName }) {
         for (const [directiveName, directiveNodes] of directivesByName) {
-            const definition = this.persistedDirectiveDefinitionByDirectiveName.get(directiveName);
-            // @authenticated and @requiresScopes are handled differently
-            if (!definition) {
+            const federatedData = this.federatedDirectiveDataByName.get(directiveName);
+            if (!federatedData) {
                 continue;
             }
-            this.referencedPersistedDirectiveNames.add(directiveName);
+            this.referencedFederatedDirectiveNames.add(directiveName);
+            // @authenticated and @requiresScopes are handled differently
             if (string_constants_1.AUTHORIZATION_DIRECTIVES.has(directiveName) || directiveNodes.length < 1) {
                 continue;
             }
@@ -106,7 +103,7 @@ class FederationFactory {
                         break;
                     }
                     // Only add one instance of certain directives.
-                    if (string_constants_1.NON_REPEATABLE_PERSISTED_DIRECTIVES.has(directiveName)) {
+                    if (string_constants_1.NON_REPEATABLE_FEDERATED_DIRECTIVES.has(directiveName)) {
                         break;
                     }
                     existingDirectives.push(...directiveNodes);
@@ -236,7 +233,7 @@ class FederationFactory {
         const graphNode = this.internalGraph.nodeByNodeName.get(`${this.currentSubgraphName}.${entityData.typeName}`);
         // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
         (0, utils_2.validateImplicitFieldSets)({
-            conditionalFieldDataByCoords: internalSubgraph.conditionalFieldDataByCoordinates,
+            conditionalFieldDataByCoords: internalSubgraph.conditionalFieldDataByCoords,
             currentSubgraphName: this.currentSubgraphName,
             entityData,
             implicitKeys,
@@ -253,7 +250,7 @@ class FederationFactory {
                 continue;
             }
             (0, utils_2.validateImplicitFieldSets)({
-                conditionalFieldDataByCoords: internalSubgraph.conditionalFieldDataByCoordinates,
+                conditionalFieldDataByCoords: internalSubgraph.conditionalFieldDataByCoords,
                 currentSubgraphName: this.currentSubgraphName,
                 entityData: interfaceObjectEntityData,
                 implicitKeys,
@@ -289,7 +286,7 @@ class FederationFactory {
         const implicitKeys = [];
         // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
         (0, utils_2.validateImplicitFieldSets)({
-            conditionalFieldDataByCoords: internalSubgraph.conditionalFieldDataByCoordinates,
+            conditionalFieldDataByCoords: internalSubgraph.conditionalFieldDataByCoords,
             currentSubgraphName: internalSubgraph.name,
             entityData,
             implicitKeys,
@@ -360,8 +357,8 @@ class FederationFactory {
     upsertEnumValueData(enumValueDataByName, incomingData, isParentInaccessible) {
         const existingData = enumValueDataByName.get(incomingData.name);
         const targetData = existingData || this.copyEnumValueData(incomingData);
-        this.extractPersistedDirectives({
-            data: targetData.persistedDirectivesData,
+        this.extractFederatedDirectives({
+            data: targetData.federatedDirectivesData,
             directivesByName: incomingData.directivesByName,
         });
         const isValueInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
@@ -381,18 +378,61 @@ class FederationFactory {
             target: targetData.subgraphNames,
         });
     }
+    upsertDirectiveArgumentData({ argumentDataByName, incomingData }) {
+        const existingData = argumentDataByName.get(incomingData.name);
+        const targetData = existingData || this.copyDirectiveArgumentData(incomingData);
+        this.extractFederatedDirectives({
+            data: targetData.federatedDirectivesData,
+            directivesByName: incomingData.directivesByName,
+        });
+        if (!existingData) {
+            this.namedInputValueTypeNames.add(targetData.namedTypeName);
+            argumentDataByName.set(targetData.name, targetData);
+            return;
+        }
+        if (!incomingData.defaultValue) {
+            existingData.includeDefaultValue = false;
+        }
+        (0, utils_6.addNewObjectValueMapEntries)(incomingData.configureDescriptionDataBySubgraphName, targetData.configureDescriptionDataBySubgraphName);
+        (0, utils_5.setLongestDescription)(targetData, incomingData);
+        (0, utils_6.addIterableToSet)({
+            source: incomingData.subgraphNames,
+            target: targetData.subgraphNames,
+        });
+        (0, utils_6.addIterableToSet)({
+            source: incomingData.requiredSubgraphNames,
+            target: targetData.requiredSubgraphNames,
+        });
+        // TODO refactor type merging
+        const mergeResult = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(targetData.type, incomingData.type, incomingData.federatedCoords, this.errors);
+        if (mergeResult.success) {
+            targetData.type = mergeResult.typeNode;
+        }
+        else {
+            this.errors.push((0, errors_1.incompatibleMergedTypesError)({
+                actualType: mergeResult.actualType,
+                isArgument: true,
+                coords: incomingData.federatedCoords,
+                expectedType: mergeResult.expectedType,
+            }));
+        }
+        const validationResult = (0, utils_5.compareAndValidateInputDefaultValues)({ existingData, incomingData });
+        if (!validationResult.success) {
+            this.errors.push(validationResult.error);
+        }
+    }
     // To facilitate the splitting of tag paths, field arguments do not use the renamedPath property for tagNamesByPath
     upsertInputValueData(inputValueDataByValueName, incomingData, parentCoords, isParentInaccessible) {
         const existingData = inputValueDataByValueName.get(incomingData.name);
         const targetData = existingData || this.copyInputValueData(incomingData);
-        this.extractPersistedDirectives({
-            data: targetData.persistedDirectivesData,
+        this.extractFederatedDirectives({
+            data: targetData.federatedDirectivesData,
             directivesByName: incomingData.directivesByName,
         });
         this.recordTagNamesByCoords(targetData, `${parentCoords}.${targetData.name}`);
-        this.namedInputValueTypeNames.add(targetData.namedTypeName);
         (0, utils_6.getValueOrDefault)(this.coordsByNamedTypeName, targetData.namedTypeName, () => new Set()).add(targetData.federatedCoords);
         if (!existingData) {
+            this.namedInputValueTypeNames.add(targetData.namedTypeName);
             inputValueDataByValueName.set(targetData.name, targetData);
             return;
         }
@@ -420,7 +460,10 @@ class FederationFactory {
                 expectedType: mergeResult.expectedType,
             }));
         }
-        (0, utils_5.compareAndValidateInputValueDefaultValues)(targetData, incomingData, this.errors);
+        const validationResult = (0, utils_5.compareAndValidateInputDefaultValues)({ existingData, incomingData });
+        if (!validationResult.success) {
+            this.errors.push(validationResult.error);
+        }
     }
     handleInputValueInaccessibility(isParentInaccessible, inputValueData, parentCoords) {
         /* If an ancestor (Input Object for field; Composite type or field for argument) of the input value is
@@ -545,8 +588,8 @@ class FederationFactory {
         (0, utils_6.getValueOrDefault)(this.coordsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(targetData.federatedCoords);
         this.namedOutputTypeNames.add(incomingData.namedTypeName);
         this.handleSubscriptionFilterDirective(incomingData, targetData);
-        this.extractPersistedDirectives({
-            data: targetData.persistedDirectivesData,
+        this.extractFederatedDirectives({
+            data: targetData.federatedDirectivesData,
             directivesByName: incomingData.directivesByName,
         });
         const isFieldInaccessible = isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(targetData);
@@ -623,11 +666,11 @@ class FederationFactory {
     }
     recordTagNamesByCoords(data, coords) {
         const path = coords || data.name;
-        if (data.persistedDirectivesData.tagDirectiveByName.size < 1) {
+        if (data.federatedDirectivesData.tagDirectiveByName.size < 1) {
             return;
         }
         const tagNames = (0, utils_6.getValueOrDefault)(this.tagNamesByCoords, path, () => new Set());
-        for (const tagName of data.persistedDirectivesData.tagDirectiveByName.keys()) {
+        for (const tagName of data.federatedDirectivesData.tagDirectiveByName.keys()) {
             tagNames.add(tagName);
         }
     }
@@ -637,13 +680,41 @@ class FederationFactory {
             directivesByName: (0, utils_6.copyArrayValueMap)(sourceData.directivesByName),
             extensionType: sourceData.extensionType,
             name: sourceData.name,
-            persistedDirectivesData: this.extractPersistedDirectives({
-                data: (0, utils_5.newPersistedDirectivesData)(),
+            federatedDirectivesData: this.extractFederatedDirectives({
+                data: (0, utils_5.newFederatedDirectivesData)(),
                 directivesByName: sourceData.directivesByName,
             }),
             description: (0, utils_5.getInitialFederatedDescription)(sourceData),
         };
     }
+    copyDirectiveArgumentData(sourceData) {
+        return {
+            configureDescriptionDataBySubgraphName: (0, utils_6.copyObjectValueMap)(sourceData.configureDescriptionDataBySubgraphName),
+            directivesByName: (0, utils_6.copyArrayValueMap)(sourceData.directivesByName),
+            defaultValue: sourceData.defaultValue,
+            description: (0, utils_5.getInitialFederatedDescription)(sourceData),
+            federatedCoords: sourceData.federatedCoords,
+            federatedDirectivesData: this.extractFederatedDirectives({
+                data: (0, utils_5.newFederatedDirectivesData)(),
+                directivesByName: sourceData.directivesByName,
+            }),
+            includeDefaultValue: sourceData.includeDefaultValue,
+            kind: sourceData.kind,
+            name: sourceData.name,
+            namedTypeKind: sourceData.namedTypeKind,
+            namedTypeName: sourceData.namedTypeName,
+            node: {
+                directives: [],
+                kind: graphql_1.Kind.INPUT_VALUE_DEFINITION,
+                name: (0, utils_1.stringToNameNode)(sourceData.name),
+                type: sourceData.type,
+            },
+            originalCoords: sourceData.originalCoords,
+            requiredSubgraphNames: new Set(sourceData.requiredSubgraphNames),
+            subgraphNames: new Set(sourceData.subgraphNames),
+            type: sourceData.type,
+        };
+    }
     copyEnumValueData(sourceData) {
         return {
             appearances: sourceData.appearances,
@@ -658,8 +729,8 @@ class FederationFactory {
                 name: (0, utils_1.stringToNameNode)(sourceData.name),
             },
             parentTypeName: sourceData.parentTypeName,
-            persistedDirectivesData: this.extractPersistedDirectives({
-                data: (0, utils_5.newPersistedDirectivesData)(),
+            federatedDirectivesData: this.extractFederatedDirectives({
+                data: (0, utils_5.newFederatedDirectivesData)(),
                 directivesByName: sourceData.directivesByName,
             }),
             subgraphNames: new Set(sourceData.subgraphNames),
@@ -686,8 +757,8 @@ class FederationFactory {
             },
             originalCoords: sourceData.originalCoords,
             originalParentTypeName: sourceData.originalParentTypeName,
-            persistedDirectivesData: this.extractPersistedDirectives({
-                data: (0, utils_5.newPersistedDirectivesData)(),
+            federatedDirectivesData: this.extractFederatedDirectives({
+                data: (0, utils_5.newFederatedDirectivesData)(),
                 directivesByName: sourceData.directivesByName,
             }),
             renamedParentTypeName: sourceData.renamedParentTypeName,
@@ -734,8 +805,8 @@ class FederationFactory {
             },
             nullLevelsBySubgraphName: sourceData.nullLevelsBySubgraphName,
             originalParentTypeName: sourceData.originalParentTypeName,
-            persistedDirectivesData: this.extractPersistedDirectives({
-                data: (0, utils_5.newPersistedDirectivesData)(),
+            federatedDirectivesData: this.extractFederatedDirectives({
+                data: (0, utils_5.newFederatedDirectivesData)(),
                 directivesByName: sourceData.directivesByName,
             }),
             renamedParentTypeName: sourceData.renamedParentTypeName,
@@ -871,8 +942,8 @@ class FederationFactory {
             }
             return targetData;
         }
-        this.extractPersistedDirectives({
-            data: existingData.persistedDirectivesData,
+        this.extractFederatedDirectives({
+            data: existingData.federatedDirectivesData,
             directivesByName: incomingData.directivesByName,
         });
         return existingData;
@@ -1009,51 +1080,6 @@ class FederationFactory {
                 }
         }
     }
-    upsertPersistedDirectiveDefinitionData(incomingData, subgraphNumber) {
-        const name = incomingData.name;
-        const existingData = this.potentialPersistedDirectiveDefinitionDataByDirectiveName.get(name);
-        if (!existingData) {
-            // The executable directive must be defined in all subgraphs to be persisted.
-            if (subgraphNumber > 1) {
-                return;
-            }
-            const argumentDataByArgumentName = new Map();
-            for (const inputValueData of incomingData.argumentDataByName.values()) {
-                this.namedInputValueTypeNames.add(inputValueData.namedTypeName);
-                this.upsertInputValueData(argumentDataByArgumentName, inputValueData, `@${incomingData.name}`, false);
-            }
-            this.potentialPersistedDirectiveDefinitionDataByDirectiveName.set(name, {
-                argumentDataByName: argumentDataByArgumentName,
-                executableLocations: new Set(incomingData.executableLocations),
-                name,
-                repeatable: incomingData.repeatable,
-                subgraphNames: new Set(incomingData.subgraphNames),
-                description: incomingData.description,
-            });
-            return;
-        }
-        // If the executable directive has not been defined in at least one graph, the definition should not be persisted
-        if (existingData.subgraphNames.size + 1 !== subgraphNumber) {
-            this.potentialPersistedDirectiveDefinitionDataByDirectiveName.delete(name);
-            return;
-        }
-        (0, utils_5.setMutualExecutableLocations)(existingData, incomingData.executableLocations);
-        // If there are no mutually defined executable locations, the definition should not be persisted
-        if (existingData.executableLocations.size < 1) {
-            this.potentialPersistedDirectiveDefinitionDataByDirectiveName.delete(name);
-            return;
-        }
-        for (const inputValueData of incomingData.argumentDataByName.values()) {
-            this.namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
-            this.upsertInputValueData(existingData.argumentDataByName, inputValueData, `@${existingData.name}`, false);
-        }
-        (0, utils_5.setLongestDescription)(existingData, incomingData);
-        existingData.repeatable &&= incomingData.repeatable;
-        (0, utils_6.addIterableToSet)({
-            source: incomingData.subgraphNames,
-            target: existingData.subgraphNames,
-        });
-    }
     shouldUpdateFederatedFieldAbstractNamedType(abstractTypeName, objectTypeNames) {
         if (!abstractTypeName) {
             return false;
@@ -1194,38 +1220,72 @@ class FederationFactory {
             this.updateTypeNodeNamedType(fieldData.type, abstractTypeName);
         }
     }
+    upsertExecutableDirectiveDatas() {
+        for (const [directiveName, definitionDatas] of this.executableDirectiveDatasByName) {
+            for (const data of definitionDatas) {
+                const existingData = this.federatedDirectiveDataByName.get(directiveName);
+                if (!existingData) {
+                    const argumentDataByName = new Map();
+                    for (const argumentData of data.argumentDataByName.values()) {
+                        this.upsertDirectiveArgumentData({
+                            argumentDataByName,
+                            incomingData: argumentData,
+                        });
+                    }
+                    // Shared set between locations and executable locations because type-system locations are removed.
+                    const locations = new Set(data.executableLocations);
+                    this.federatedDirectiveDataByName.set(directiveName, {
+                        argumentDataByName,
+                        isComposed: false,
+                        isRepeatable: data.isRepeatable,
+                        isReferenced: data.isReferenced,
+                        executableLocations: locations,
+                        locations,
+                        majorVersion: -1,
+                        minorVersion: -1,
+                        name: directiveName,
+                        description: data.description,
+                        node: data.node,
+                        optionalArgumentNames: new Set(data.optionalArgumentNames),
+                        requiredArgumentNames: new Set(data.requiredArgumentNames),
+                        subgraphNames: new Set(data.subgraphNames),
+                    });
+                    continue;
+                }
+                for (const argumentData of data.argumentDataByName.values()) {
+                    this.upsertDirectiveArgumentData({
+                        argumentDataByName: existingData.argumentDataByName,
+                        incomingData: argumentData,
+                    });
+                }
+                for (const executableLocation of existingData.executableLocations) {
+                    if (!data.executableLocations.has(executableLocation)) {
+                        existingData.executableLocations.delete(executableLocation);
+                    }
+                }
+                if (existingData.executableLocations.size < 1) {
+                    this.federatedDirectiveDataByName.delete(directiveName);
+                    break;
+                }
+                (0, utils_5.setLongestDescription)(existingData, data);
+                (0, utils_6.addIterableToSet)({ source: data.subgraphNames, target: existingData.subgraphNames });
+                existingData.isRepeatable &&= data.isRepeatable;
+            }
+        }
+    }
     /* federateInternalSubgraphData is responsible for merging each subgraph TypeScript representation of a GraphQL type
      * into a single representation.
      * This method is always necessary, regardless of whether federating a source graph or contract graph.
      * */
     federateInternalSubgraphData() {
-        let subgraphNumber = 0;
-        let shouldSkipPersistedExecutableDirectives = false;
+        this.upsertExecutableDirectiveDatas();
         for (const internalSubgraph of this.internalSubgraphBySubgraphName.values()) {
-            subgraphNumber += 1;
             this.currentSubgraphName = internalSubgraph.name;
             this.isVersionTwo ||= internalSubgraph.isVersionTwo;
             (0, walkers_1.renameRootTypes)(this, internalSubgraph);
             for (const parentDefinitionData of internalSubgraph.parentDefinitionDataByTypeName.values()) {
                 this.upsertParentDefinitionData(parentDefinitionData, internalSubgraph.name);
             }
-            if (shouldSkipPersistedExecutableDirectives) {
-                continue;
-            }
-            /* If a subgraph defines no executable directives, it is not possible for any definition to be in all subgraphs.
-               Consequently, it is no longer necessary to check for any persisted executable directives. */
-            if (!internalSubgraph.persistedDirectiveDefinitionDataByDirectiveName.size) {
-                shouldSkipPersistedExecutableDirectives = true;
-                continue;
-            }
-            for (const persistedDirectiveDefinitionData of internalSubgraph.persistedDirectiveDefinitionDataByDirectiveName.values()) {
-                this.upsertPersistedDirectiveDefinitionData(persistedDirectiveDefinitionData, subgraphNumber);
-            }
-            /* Invalid directive keys are deleted; if there are no entries left, it is no longer necessary to evaluate more
-               executable directives. */
-            if (this.potentialPersistedDirectiveDefinitionDataByDirectiveName.size < 1) {
-                shouldSkipPersistedExecutableDirectives = true;
-            }
         }
         this.handleDisparateFieldNamedTypes();
     }
@@ -1362,38 +1422,6 @@ class FederationFactory {
             subgraphNames: fieldData.subgraphNames,
         };
     }
-    getValidFlattenedPersistedDirectiveNodeArray(data) {
-        const coords = (0, utils_3.getNodeCoords)(data);
-        const persistedDirectiveNodes = [];
-        for (const [directiveName, directiveNodes] of data.persistedDirectivesData.directivesByName) {
-            if (directiveName === string_constants_1.SEMANTIC_NON_NULL && (0, utils_5.isFieldData)(data)) {
-                persistedDirectiveNodes.push((0, utils_6.generateSemanticNonNullDirective)((0, utils_6.getFirstEntry)(data.nullLevelsBySubgraphName) ?? new Set([0])));
-                continue;
-            }
-            const persistedDirectiveDefinition = this.persistedDirectiveDefinitionByDirectiveName.get(directiveName);
-            if (!persistedDirectiveDefinition) {
-                continue;
-            }
-            if (directiveNodes.length < 2) {
-                persistedDirectiveNodes.push(...directiveNodes);
-                continue;
-            }
-            if (!persistedDirectiveDefinition.repeatable) {
-                this.errors.push((0, errors_1.invalidRepeatedFederatedDirectiveErrorMessage)(directiveName, coords));
-                continue;
-            }
-            persistedDirectiveNodes.push(...directiveNodes);
-        }
-        return persistedDirectiveNodes;
-    }
-    getRouterPersistedDirectiveNodes(nodeData) {
-        const persistedDirectiveNodes = [...nodeData.persistedDirectivesData.tagDirectiveByName.values()];
-        if (nodeData.persistedDirectivesData.isDeprecated) {
-            persistedDirectiveNodes.push((0, utils_5.generateDeprecatedDirective)(nodeData.persistedDirectivesData.deprecatedReason));
-        }
-        persistedDirectiveNodes.push(...this.getValidFlattenedPersistedDirectiveNodeArray(nodeData));
-        return persistedDirectiveNodes;
-    }
     getFederatedGraphNodeDescription(data) {
         if (data.configureDescriptionDataBySubgraphName.size < 1) {
             return data.description;
@@ -1416,31 +1444,27 @@ class FederationFactory {
         }
         this.errors.push((0, errors_1.configureDescriptionPropagationError)((0, utils_5.getDefinitionDataCoords)(data, true), subgraphNames));
     }
-    getNodeForRouterSchemaByData(data) {
-        data.node.name = (0, utils_1.stringToNameNode)(data.name);
-        data.node.description = this.getFederatedGraphNodeDescription(data);
-        data.node.directives = this.getRouterPersistedDirectiveNodes(data);
-        return data.node;
-    }
-    getNodeWithPersistedDirectivesByInputValueData(inputValueData) {
-        inputValueData.node.name = (0, utils_1.stringToNameNode)(inputValueData.name);
-        inputValueData.node.type = inputValueData.type;
-        inputValueData.node.description = this.getFederatedGraphNodeDescription(inputValueData);
-        inputValueData.node.directives = this.getRouterPersistedDirectiveNodes(inputValueData);
-        if (inputValueData.includeDefaultValue) {
-            inputValueData.node.defaultValue = inputValueData.defaultValue;
-        }
-        return inputValueData.node;
-    }
     getValidFieldArgumentNodes(fieldData) {
         const argumentNodes = [];
         const argumentNames = [];
         const invalidRequiredArguments = [];
-        const fieldPath = `${fieldData.renamedParentTypeName}.${fieldData.name}`;
+        const fieldCoords = `${fieldData.renamedParentTypeName}.${fieldData.name}`;
         for (const [argumentName, inputValueData] of fieldData.argumentDataByName) {
             if (fieldData.subgraphNames.size === inputValueData.subgraphNames.size) {
                 argumentNames.push(argumentName);
-                argumentNodes.push(this.getNodeWithPersistedDirectivesByInputValueData(inputValueData));
+                const argumentNodeResult = (0, utils_5.routerSchemaInputValueNodeFromData)({
+                    data: inputValueData,
+                    description: this.getFederatedGraphNodeDescription(inputValueData),
+                    federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                    parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                });
+                if (argumentNodeResult.success) {
+                    argumentNodes.push(argumentNodeResult.node);
+                    this.warnings.push(...argumentNodeResult.warnings);
+                }
+                else {
+                    this.errors.push(...argumentNodeResult.errors);
+                }
             }
             else if ((0, utils_5.isTypeRequired)(inputValueData.type)) {
                 invalidRequiredArguments.push({
@@ -1451,11 +1475,11 @@ class FederationFactory {
             }
         }
         if (invalidRequiredArguments.length > 0) {
-            this.errors.push((0, errors_1.invalidRequiredInputValueError)(string_constants_1.FIELD, fieldPath, invalidRequiredArguments));
+            this.errors.push((0, errors_1.invalidRequiredInputValueError)(string_constants_1.FIELD, fieldCoords, invalidRequiredArguments));
         }
         else if (argumentNames.length > 0) {
             // fieldConfiguration might already exist through subscriptionFilter
-            (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldCoords, fieldPath, () => ({
+            (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldCoords, fieldCoords, () => ({
                 argumentNames,
                 fieldName: fieldData.name,
                 typeName: fieldData.renamedParentTypeName,
@@ -1463,14 +1487,6 @@ class FederationFactory {
         }
         return argumentNodes;
     }
-    getNodeWithPersistedDirectivesByFieldData(fieldData, argumentNodes) {
-        fieldData.node.arguments = argumentNodes;
-        fieldData.node.name = (0, utils_1.stringToNameNode)(fieldData.name);
-        fieldData.node.type = fieldData.type;
-        fieldData.node.description = this.getFederatedGraphNodeDescription(fieldData);
-        fieldData.node.directives = this.getRouterPersistedDirectiveNodes(fieldData);
-        return fieldData.node;
-    }
     validateSemanticNonNull(data) {
         let comparison;
         for (const levels of data.nullLevelsBySubgraphName.values()) {
@@ -1525,32 +1541,41 @@ class FederationFactory {
                     const mergeMethod = this.getEnumValueMergeMethod(parentTypeName);
                     (0, utils_5.propagateAuthDirectives)(parentDefinitionData, this.authorizationDataByParentTypeName.get(parentTypeName));
                     for (const enumValueData of parentDefinitionData.enumValueDataByName.values()) {
-                        const enumValueNode = this.getNodeForRouterSchemaByData(enumValueData);
                         const isValueInaccessible = (0, utils_5.isNodeDataInaccessible)(enumValueData);
                         const clientEnumValueNode = {
                             ...enumValueData.node,
-                            directives: (0, utils_5.getClientPersistedDirectiveNodes)(enumValueData),
+                            directives: (0, utils_5.getClientFederatedDirectiveNodes)(enumValueData),
                         };
+                        const enumValueNodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                            data: enumValueData,
+                            description: this.getFederatedGraphNodeDescription(enumValueData),
+                            federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                            parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                        });
+                        if (!enumValueNodeResult.success) {
+                            this.errors.push(...enumValueNodeResult.errors);
+                            continue;
+                        }
                         switch (mergeMethod) {
                             case utils_5.MergeMethod.CONSISTENT:
                                 if (!isValueInaccessible && parentDefinitionData.appearances > enumValueData.appearances) {
                                     this.errors.push((0, errors_1.incompatibleSharedEnumError)(parentTypeName));
                                 }
-                                enumValueNodes.push(enumValueNode);
+                                enumValueNodes.push(enumValueNodeResult.node);
                                 if (!isValueInaccessible) {
                                     clientEnumValueNodes.push(clientEnumValueNode);
                                 }
                                 break;
                             case utils_5.MergeMethod.INTERSECTION:
                                 if (parentDefinitionData.appearances === enumValueData.appearances) {
-                                    enumValueNodes.push(enumValueNode);
+                                    enumValueNodes.push(enumValueNodeResult.node);
                                     if (!isValueInaccessible) {
                                         clientEnumValueNodes.push(clientEnumValueNode);
                                     }
                                 }
                                 break;
                             default:
-                                enumValueNodes.push(enumValueNode);
+                                enumValueNodes.push(enumValueNodeResult.node);
                                 if (!isValueInaccessible) {
                                     clientEnumValueNodes.push(clientEnumValueNode);
                                 }
@@ -1558,7 +1583,18 @@ class FederationFactory {
                         }
                     }
                     parentDefinitionData.node.values = enumValueNodes;
-                    this.routerDefinitions.push(this.getNodeForRouterSchemaByData(parentDefinitionData));
+                    const nodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                        data: parentDefinitionData,
+                        description: this.getFederatedGraphNodeDescription(parentDefinitionData),
+                        federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                        parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                    });
+                    if (nodeResult.success) {
+                        this.routerDefinitions.push(nodeResult.node);
+                    }
+                    else {
+                        this.errors.push(...nodeResult.errors);
+                    }
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
                         this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
@@ -1570,7 +1606,7 @@ class FederationFactory {
                     }
                     this.clientDefinitions.push({
                         ...parentDefinitionData.node,
-                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        directives: (0, utils_5.getClientFederatedDirectiveNodes)(parentDefinitionData),
                         values: clientEnumValueNodes,
                     });
                     break;
@@ -1588,13 +1624,25 @@ class FederationFactory {
                             requiredFieldNames.add(inputValueName);
                         }
                         if (parentDefinitionData.subgraphNames.size === inputValueData.subgraphNames.size) {
-                            inputValueNodes.push(this.getNodeWithPersistedDirectivesByInputValueData(inputValueData));
+                            const inputValueNodeResult = (0, utils_5.routerSchemaInputValueNodeFromData)({
+                                data: inputValueData,
+                                description: this.getFederatedGraphNodeDescription(inputValueData),
+                                federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                                parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                            });
+                            if (inputValueNodeResult.success) {
+                                inputValueNodes.push(inputValueNodeResult.node);
+                                this.warnings.push(...inputValueNodeResult.warnings);
+                            }
+                            else {
+                                this.errors.push(...inputValueNodeResult.errors);
+                            }
                             if ((0, utils_5.isNodeDataInaccessible)(inputValueData)) {
                                 continue;
                             }
                             clientInputValueNodes.push({
                                 ...inputValueData.node,
-                                directives: (0, utils_5.getClientPersistedDirectiveNodes)(inputValueData),
+                                directives: (0, utils_5.getClientFederatedDirectiveNodes)(inputValueData),
                             });
                         }
                         else if ((0, utils_5.isTypeRequired)(inputValueData.type)) {
@@ -1617,7 +1665,18 @@ class FederationFactory {
                         break;
                     }
                     parentDefinitionData.node.fields = inputValueNodes;
-                    this.routerDefinitions.push(this.getNodeForRouterSchemaByData(parentDefinitionData));
+                    const inputObjectNodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                        data: parentDefinitionData,
+                        description: this.getFederatedGraphNodeDescription(parentDefinitionData),
+                        federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                        parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                    });
+                    if (inputObjectNodeResult.success) {
+                        this.routerDefinitions.push(inputObjectNodeResult.node);
+                    }
+                    else {
+                        this.errors.push(...inputObjectNodeResult.errors);
+                    }
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
                         break;
@@ -1628,7 +1687,7 @@ class FederationFactory {
                     }
                     this.clientDefinitions.push({
                         ...parentDefinitionData.node,
-                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        directives: (0, utils_5.getClientFederatedDirectiveNodes)(parentDefinitionData),
                         fields: clientInputValueNodes,
                     });
                     break;
@@ -1650,7 +1709,20 @@ class FederationFactory {
                             (0, utils_5.validateExternalAndShareable)(fieldData, invalidFieldNames);
                         }
                         this.validateSemanticNonNull(fieldData);
-                        fieldNodes.push(this.getNodeWithPersistedDirectivesByFieldData(fieldData, argumentNodes));
+                        const fieldNodeResult = (0, utils_5.routerSchemaFieldNodeFromData)({
+                            argumentNodes,
+                            data: fieldData,
+                            description: this.getFederatedGraphNodeDescription(fieldData),
+                            federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                            parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                        });
+                        if (!fieldNodeResult.success) {
+                            this.errors.push(...fieldNodeResult.errors);
+                        }
+                        else {
+                            fieldNodes.push(fieldNodeResult.node);
+                            this.warnings.push(...fieldNodeResult.warnings);
+                        }
                         if ((0, utils_5.isNodeDataInaccessible)(fieldData)) {
                             continue;
                         }
@@ -1672,7 +1744,18 @@ class FederationFactory {
                         interfaceImplementations.push({ data: parentDefinitionData, clientSchemaFieldNodes });
                         break;
                     }
-                    this.routerDefinitions.push(this.getNodeForRouterSchemaByData(parentDefinitionData));
+                    const nodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                        data: parentDefinitionData,
+                        description: this.getFederatedGraphNodeDescription(parentDefinitionData),
+                        federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                        parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                    });
+                    if (nodeResult.success) {
+                        this.routerDefinitions.push(nodeResult.node);
+                    }
+                    else {
+                        this.errors.push(...nodeResult.errors);
+                    }
                     const isQuery = (0, utils_4.isNodeQuery)(parentTypeName);
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         if (isQuery) {
@@ -1692,7 +1775,7 @@ class FederationFactory {
                     }
                     this.clientDefinitions.push({
                         ...parentDefinitionData.node,
-                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        directives: (0, utils_5.getClientFederatedDirectiveNodes)(parentDefinitionData),
                         fields: clientSchemaFieldNodes,
                     });
                     break;
@@ -1702,7 +1785,18 @@ class FederationFactory {
                         break;
                     }
                     (0, utils_5.propagateAuthDirectives)(parentDefinitionData, this.authorizationDataByParentTypeName.get(parentTypeName));
-                    this.routerDefinitions.push(this.getNodeForRouterSchemaByData(parentDefinitionData));
+                    const nodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                        data: parentDefinitionData,
+                        description: this.getFederatedGraphNodeDescription(parentDefinitionData),
+                        federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                        parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                    });
+                    if (nodeResult.success) {
+                        this.routerDefinitions.push(nodeResult.node);
+                    }
+                    else {
+                        this.errors.push(...nodeResult.errors);
+                    }
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
                         this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
@@ -1710,13 +1804,24 @@ class FederationFactory {
                     }
                     this.clientDefinitions.push({
                         ...parentDefinitionData.node,
-                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        directives: (0, utils_5.getClientFederatedDirectiveNodes)(parentDefinitionData),
                     });
                     break;
                 }
                 case graphql_1.Kind.UNION_TYPE_DEFINITION: {
                     parentDefinitionData.node.types = (0, utils_3.mapToArrayOfValues)(parentDefinitionData.memberByMemberTypeName);
-                    this.routerDefinitions.push(this.getNodeForRouterSchemaByData(parentDefinitionData));
+                    const nodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                        data: parentDefinitionData,
+                        description: this.getFederatedGraphNodeDescription(parentDefinitionData),
+                        federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                        parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                    });
+                    if (nodeResult.success) {
+                        this.routerDefinitions.push(nodeResult.node);
+                    }
+                    else {
+                        this.errors.push(...nodeResult.errors);
+                    }
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
                         this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
@@ -1729,7 +1834,7 @@ class FederationFactory {
                     }
                     this.clientDefinitions.push({
                         ...parentDefinitionData.node,
-                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        directives: (0, utils_5.getClientFederatedDirectiveNodes)(parentDefinitionData),
                         types: clientMembers,
                     });
                     break;
@@ -1783,7 +1888,18 @@ class FederationFactory {
     validateInterfaceImplementationsAndPushToDocumentDefinitions(interfaceImplementations) {
         for (const { data, clientSchemaFieldNodes } of interfaceImplementations) {
             data.node.interfaces = this.getValidImplementedInterfaces(data);
-            this.routerDefinitions.push(this.getNodeForRouterSchemaByData(data));
+            const nodeResult = (0, utils_5.routerSchemaNodeFromData)({
+                data,
+                description: this.getFederatedGraphNodeDescription(data),
+                federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+            });
+            if (nodeResult.success) {
+                this.routerDefinitions.push(nodeResult.node);
+            }
+            else {
+                this.errors.push(...nodeResult.errors);
+            }
             if ((0, utils_5.isNodeDataInaccessible)(data)) {
                 this.validateReferencesOfInaccessibleType(data);
                 this.internalGraph.setNodeInaccessible(data.name);
@@ -1800,7 +1916,7 @@ class FederationFactory {
              * */
             this.clientDefinitions.push({
                 ...data.node,
-                directives: (0, utils_5.getClientPersistedDirectiveNodes)(data),
+                directives: (0, utils_5.getClientFederatedDirectiveNodes)(data),
                 fields: clientSchemaFieldNodes,
                 interfaces: clientInterfaces,
             });
@@ -1809,14 +1925,14 @@ class FederationFactory {
     #addDirectiveDefinitionsAndDepsToRouterAndClientSchemas() {
         const clientDependencies = new Set();
         const routerDependencies = new Set();
-        for (const directiveName of this.referencedPersistedDirectiveNames) {
+        for (const directiveName of this.referencedFederatedDirectiveNames) {
             const definition = constants_1.DIRECTIVE_DEFINITION_BY_NAME.get(directiveName);
             if (!definition) {
                 continue;
             }
             const dependencies = strings_1.DEPENDENCIES_BY_DIRECTIVE_NAME.get(directiveName) ?? [];
             this.directiveDefinitionByName.set(directiveName, definition);
-            if (strings_1.CLIENT_PERSISTED_DIRECTIVE_NAMES.has(directiveName)) {
+            if (strings_1.CLIENT_FEDERATED_DIRECTIVE_NAMES.has(directiveName)) {
                 this.clientDefinitions.push(definition);
                 (0, utils_6.addIterableToSet)({
                     source: dependencies,
@@ -2158,9 +2274,7 @@ class FederationFactory {
         if (this.invalidORScopesCoords.size > 0) {
             this.errors.push((0, errors_1.orScopesLimitError)(constants_1.MAX_OR_SCOPES, [...this.invalidORScopesCoords]));
         }
-        for (const data of this.potentialPersistedDirectiveDefinitionDataByDirectiveName.values()) {
-            (0, utils_5.addValidPersistedDirectiveDefinitionNodeByData)(this.routerDefinitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
-        }
+        this.handleCustomDirectiveDefinitionNodes();
         const definitionsWithInterfaces = [];
         this.pushParentDefinitionDataToDocumentDefinitions(definitionsWithInterfaces);
         this.validateInterfaceImplementationsAndPushToDocumentDefinitions(definitionsWithInterfaces);
@@ -2242,7 +2356,7 @@ class FederationFactory {
                 continue;
             }
             if (!tagNames.isDisjointFrom(childTagData.tagNames)) {
-                (0, utils_6.getValueOrDefault)(childData.persistedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
+                (0, utils_6.getValueOrDefault)(childData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                     (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                 ]);
                 this.inaccessibleCoords.add(`${parentDefinitionData.name}.${childName}`);
@@ -2250,7 +2364,7 @@ class FederationFactory {
             }
         }
         if (accessibleChildren < 1) {
-            parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+            parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                 (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
             ]);
             this.inaccessibleCoords.add(parentDefinitionData.name);
@@ -2265,7 +2379,7 @@ class FederationFactory {
             }
             const childTagData = childTagDataByChildName.get(childName);
             if (!childTagData || tagNames.isDisjointFrom(childTagData.tagNames)) {
-                (0, utils_6.getValueOrDefault)(childData.persistedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
+                (0, utils_6.getValueOrDefault)(childData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                     (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                 ]);
                 this.inaccessibleCoords.add(`${parentDefinitionData.name}.${childName}`);
@@ -2273,12 +2387,29 @@ class FederationFactory {
             }
         }
         if (accessibleChildren < 1) {
-            parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+            parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                 (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
             ]);
             this.inaccessibleCoords.add(parentDefinitionData.name);
         }
     }
+    handleCustomDirectiveDefinitionNodes() {
+        for (const data of this.federatedDirectiveDataByName.values()) {
+            if (!data.isComposed && data.executableLocations.size < 1) {
+                continue;
+            }
+            const directiveNodeResult = (0, utils_5.propagateDirectiveDefinitionNodeFromData)({
+                data,
+                federatedDirectiveDataByName: this.federatedDirectiveDataByName,
+                parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+            });
+            if (!directiveNodeResult.success) {
+                this.errors.push(...directiveNodeResult.errors);
+                continue;
+            }
+            this.routerDefinitions.push(data.node);
+        }
+    }
     buildFederationContractResult(contractTagOptions) {
         if (!this.isVersionTwo) {
             /* If all the subgraphs are version one, the @inaccessible directive won't be present.
@@ -2292,7 +2423,7 @@ class FederationFactory {
                     continue;
                 }
                 if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(parentTagData.tagNames)) {
-                    parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+                    parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                     ]);
                     this.inaccessibleCoords.add(parentTypeName);
@@ -2325,7 +2456,7 @@ class FederationFactory {
                                 continue;
                             }
                             if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(childTagData.tagNames)) {
-                                (0, utils_6.getValueOrDefault)(fieldData.persistedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
+                                (0, utils_6.getValueOrDefault)(fieldData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                                     (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                                 ]);
                                 this.inaccessibleCoords.add(fieldData.federatedCoords);
@@ -2338,7 +2469,7 @@ class FederationFactory {
                                     continue;
                                 }
                                 if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(argTagNames)) {
-                                    (0, utils_6.getValueOrDefault)(inputValueData.persistedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
+                                    (0, utils_6.getValueOrDefault)(inputValueData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                                         (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                                     ]);
                                     this.inaccessibleCoords.add(inputValueData.federatedCoords);
@@ -2346,7 +2477,7 @@ class FederationFactory {
                             }
                         }
                         if (accessibleFields < 1) {
-                            parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+                            parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                                 (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                             ]);
                             this.inaccessibleCoords.add(parentTypeName);
@@ -2362,7 +2493,7 @@ class FederationFactory {
                 }
                 const parentTagData = this.parentTagDataByTypeName.get(parentTypeName);
                 if (!parentTagData) {
-                    parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+                    parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                     ]);
                     this.inaccessibleCoords.add(parentTypeName);
@@ -2373,7 +2504,7 @@ class FederationFactory {
                     continue;
                 }
                 if (parentTagData.childTagDataByChildName.size < 1) {
-                    parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+                    parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                     ]);
                     this.inaccessibleCoords.add(parentTypeName);
@@ -2400,7 +2531,7 @@ class FederationFactory {
                             }
                             const childTagData = parentTagData.childTagDataByChildName.get(fieldName);
                             if (!childTagData || contractTagOptions.tagNamesToInclude.isDisjointFrom(childTagData.tagNames)) {
-                                (0, utils_6.getValueOrDefault)(fieldData.persistedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
+                                (0, utils_6.getValueOrDefault)(fieldData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                                     (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                                 ]);
                                 this.inaccessibleCoords.add(fieldData.federatedCoords);
@@ -2408,7 +2539,7 @@ class FederationFactory {
                             }
                         }
                         if (accessibleFields < 1) {
-                            parentDefinitionData.persistedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+                            parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                                 (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                             ]);
                             this.inaccessibleCoords.add(parentTypeName);
@@ -2419,9 +2550,7 @@ class FederationFactory {
         if (this.subscriptionFilterDataByFieldPath.size > 0) {
             this.validateSubscriptionFiltersAndGenerateConfiguration();
         }
-        for (const data of this.potentialPersistedDirectiveDefinitionDataByDirectiveName.values()) {
-            (0, utils_5.addValidPersistedDirectiveDefinitionNodeByData)(this.routerDefinitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
-        }
+        this.handleCustomDirectiveDefinitionNodes();
         const interfaceImplementations = [];
         this.pushParentDefinitionDataToDocumentDefinitions(interfaceImplementations);
         this.validateInterfaceImplementationsAndPushToDocumentDefinitions(interfaceImplementations);
@@ -2475,14 +2604,14 @@ function initializeFederationFactory({ options, subgraphs }) {
     if (subgraphs.length < 1) {
         return { errors: [errors_1.minimumSubgraphRequirementError], success: false, warnings: [] };
     }
-    const result = (0, normalization_factory_1.batchNormalize)({ subgraphs, options });
+    const result = new batch_normalizer_1.BatchNormalizer({ subgraphs, options }).batchNormalize();
     if (!result.success) {
         return { errors: result.errors, success: false, warnings: result.warnings };
     }
     const entityInterfaceFederationDataByTypeName = new Map();
     const invalidEntityInterfacesByTypeName = new Map();
-    for (const [subgraphName, internalSubgraph] of result.internalSubgraphBySubgraphName) {
-        for (const [typeName, entityInterfaceData] of internalSubgraph.entityInterfaces) {
+    for (const [subgraphName, internalSubgraph] of result.internalSubgraphByName) {
+        for (const [typeName, entityInterfaceData] of internalSubgraph.entityInterfaceSubgraphDataByTypeName) {
             const existingData = entityInterfaceFederationDataByTypeName.get(typeName);
             if (!existingData) {
                 entityInterfaceFederationDataByTypeName.set(typeName, (0, utils_3.newEntityInterfaceFederationData)(entityInterfaceData, subgraphName));
@@ -2515,7 +2644,7 @@ function initializeFederationFactory({ options, subgraphs }) {
                 source: entityInterfaceData.concreteTypeNames,
                 target: definedConcreteTypeNames,
             });
-            const { parentDefinitionDataByTypeName } = (0, utils_6.getOrThrowError)(result.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName');
+            const { parentDefinitionDataByTypeName } = (0, utils_6.getOrThrowError)(result.internalSubgraphByName, subgraphName, 'internalSubgraphBySubgraphName');
             const invalidTypeNames = [];
             for (const concreteTypeName of entityInterfaceData.concreteTypeNames) {
                 if (parentDefinitionDataByTypeName.has(concreteTypeName)) {
@@ -2563,9 +2692,11 @@ function initializeFederationFactory({ options, subgraphs }) {
             concreteTypeNamesByAbstractTypeName: result.concreteTypeNamesByAbstractTypeName,
             entityDataByTypeName: result.entityDataByTypeName,
             entityInterfaceFederationDataByTypeName,
+            executableDirectiveDatasByName: result.executableDirectiveDatasByName,
+            federatedDirectiveDataByName: result.federatedDirectiveDataByName,
             fieldCoordsByNamedTypeName: result.fieldCoordsByNamedTypeName,
             interfaceImplementationTypeNamesByInterfaceTypeName: result.interfaceImplementationTypeNamesByInterfaceTypeName,
-            internalSubgraphBySubgraphName: result.internalSubgraphBySubgraphName,
+            internalSubgraphBySubgraphName: result.internalSubgraphByName,
             internalGraph: result.internalGraph,
             options,
             warnings: result.warnings,