@wundergraph/composition 0.10.1 → 0.11.1

package/dist/normalization/normalization-factory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NormalizationFactory = exports.normalizeSubgraph = exports.normalizeSubgraphFromString = void 0;
+exports.batchNormalize = exports.NormalizationFactory = exports.normalizeSubgraph = exports.normalizeSubgraphFromString = void 0;
 const graphql_1 = require("graphql");
 const utils_1 = require("../ast/utils");
 const utils_2 = require("./utils");
@@ -12,8 +12,9 @@ const string_constants_1 = require("../utils/string-constants");
 const buildASTSchema_1 = require("../buildASTSchema/buildASTSchema");
 const merge_1 = require("@graphql-tools/merge");
 const ast_1 = require("../ast/ast");
-function normalizeSubgraphFromString(subgraph) {
-    const { error, documentNode } = (0, utils_1.safeParse)(subgraph);
+const subgraph_1 = require("../subgraph/subgraph");
+function normalizeSubgraphFromString(subgraphSDL) {
+    const { error, documentNode } = (0, utils_1.safeParse)(subgraphSDL);
     if (error || !documentNode) {
         return { errors: [(0, errors_1.subgraphInvalidSyntaxError)(error)] };
     }
@@ -29,20 +30,25 @@ exports.normalizeSubgraph = normalizeSubgraph;
 class NormalizationFactory {
     abstractToConcreteTypeNames = new Map();
     allDirectiveDefinitions = new Map();
+    argumentName = '';
+    childName = '';
     configurationDataMap = new Map();
     customDirectiveDefinitions = new Map();
     errors = [];
     entities = new Set();
+    extensions = new Map();
+    isCurrentParentExtension = false;
+    isSubgraphVersionTwo = false;
     fieldSetsByParent = new Map();
+    handledRepeatedDirectivesByHostPath = new Map();
+    lastParentNodeKind = graphql_1.Kind.NULL;
+    lastChildNodeKind = graphql_1.Kind.NULL;
     keyFieldsByParentTypeName = new Map();
     operationTypeNames = new Map();
     parents = new Map();
     parentTypeName = '';
     parentsWithChildArguments = new Set();
-    extensions = new Map();
-    isChild = false;
-    isCurrentParentExtension = false;
-    isSubgraphVersionTwo = false;
+    overridesByTargetSubgraphName = new Map();
     schemaDefinition;
     referencedDirectives = new Set();
     referencedTypeNames = new Set();
@@ -472,6 +478,75 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.name.value, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
         }
     }
+    handleOverride(node, fieldName) {
+        if (node.name.value !== string_constants_1.OVERRIDE) {
+            return;
+        }
+        const errorMessages = [];
+        let hostPath = `${this.parentTypeName}.${this.childName}`;
+        let kind = this.lastChildNodeKind === graphql_1.Kind.NULL ? this.lastParentNodeKind : this.lastChildNodeKind;
+        if (this.argumentName) {
+            hostPath += `(${this.argumentName}: ...)`;
+            kind = graphql_1.Kind.ARGUMENT;
+        }
+        if (kind !== graphql_1.Kind.FIELD_DEFINITION) {
+            errorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(hostPath, kind, string_constants_1.OVERRIDE));
+        }
+        let targetSubgraphName = '';
+        if (node.arguments && node.arguments.length > 0) {
+            const observedArguments = new Set();
+            const handledDuplicateArguments = new Set();
+            for (const argumentNode of node.arguments) {
+                const argumentName = argumentNode.name.value;
+                if (argumentName !== string_constants_1.FROM && !observedArguments.has(argumentName)) {
+                    observedArguments.add(argumentName);
+                    errorMessages.push((0, errors_1.unexpectedDirectiveArgumentErrorMessage)(string_constants_1.OVERRIDE, argumentName));
+                    continue;
+                }
+                // If an argument is observed more than once, it is a duplication error.
+                // However, the error should only propagate once.
+                if (observedArguments.has(argumentName)) {
+                    if (!handledDuplicateArguments.has(argumentName)) {
+                        errorMessages.push((0, errors_1.duplicateDirectiveArgumentDefinitionErrorMessage)(string_constants_1.OVERRIDE, hostPath, argumentName));
+                    }
+                    continue;
+                }
+                if (argumentNode.value.kind !== graphql_1.Kind.STRING) {
+                    errorMessages.push((0, errors_1.invalidDirectiveArgumentTypeErrorMessage)(true, string_constants_1.FROM, graphql_1.Kind.STRING, argumentNode.value.kind));
+                }
+                else {
+                    observedArguments.add(string_constants_1.FROM);
+                    targetSubgraphName = argumentNode.value.value;
+                }
+            }
+            if (!observedArguments.has(string_constants_1.FROM)) {
+                errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(string_constants_1.OVERRIDE, hostPath, [string_constants_1.FROM], [string_constants_1.FROM]));
+            }
+        }
+        else {
+            errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(string_constants_1.OVERRIDE, hostPath, [string_constants_1.FROM], []));
+        }
+        if (errorMessages.length > 0) {
+            this.errors.push((0, errors_1.invalidDirectiveError)(string_constants_1.OVERRIDE, hostPath, errorMessages));
+            return;
+        }
+        const overrideDataForSubgraph = (0, utils_3.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
+        const overriddenFieldNamesForParent = (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, this.parentTypeName, () => new Set());
+        if (overriddenFieldNamesForParent.has(this.childName)) {
+            const handledRepeatedDirectives = this.handledRepeatedDirectivesByHostPath.get(hostPath);
+            // If the directive name exists as a value on the host path key, the repeatable error has been handled
+            if (handledRepeatedDirectives && handledRepeatedDirectives.has(string_constants_1.OVERRIDE)) {
+                return;
+            }
+            // Add the directive name to the existing set (if other invalid repeated directives exist) or a new set
+            (0, utils_3.getValueOrDefault)(this.handledRepeatedDirectivesByHostPath, hostPath, () => new Set())
+                .add(string_constants_1.OVERRIDE);
+            // The invalid repeated directive error should propagate only once per directive per host path
+            this.errors.push((0, errors_1.invalidDirectiveError)(string_constants_1.OVERRIDE, hostPath, [(0, errors_1.invalidRepeatedDirectiveErrorMessage)(string_constants_1.OVERRIDE, hostPath)]));
+            return;
+        }
+        overriddenFieldNamesForParent.add(this.childName);
+    }
     normalize(document) {
         const factory = this;
         /* factory.allDirectiveDefinitions is initialized with v1 directive definitions, and v2 definitions are only added
@@ -479,6 +554,42 @@ class NormalizationFactory {
         allDirectiveDefinitions cannot be used to check for duplicate definitions, and another set (below) is required */
         const definedDirectives = new Set();
         let isCurrentParentRootType = false;
+        let fieldName = '';
+        // Collect any renamed root types
+        (0, graphql_1.visit)(document, {
+            OperationTypeDefinition: {
+                enter(node) {
+                    const operationType = node.operation;
+                    const operationPath = `${factory.parentTypeName}.${operationType}`;
+                    const definitionNode = factory.schemaDefinition.operationTypes.get(operationType);
+                    const newTypeName = (0, type_merging_1.getNamedTypeForChild)(operationPath, node.type);
+                    if (definitionNode) {
+                        (0, errors_1.duplicateOperationTypeDefinitionError)(operationType, newTypeName, (0, type_merging_1.getNamedTypeForChild)(operationPath, definitionNode.type));
+                        return false;
+                    }
+                    const existingOperationType = factory.operationTypeNames.get(newTypeName);
+                    if (existingOperationType) {
+                        factory.errors.push((0, errors_1.invalidOperationTypeDefinitionError)(existingOperationType, newTypeName, operationType));
+                    }
+                    else {
+                        factory.operationTypeNames.set(newTypeName, operationType);
+                        factory.schemaDefinition.operationTypes.set(operationType, node);
+                    }
+                    return false;
+                },
+            },
+            SchemaDefinition: {
+                enter(node) {
+                    factory.extractDirectives(node, factory.schemaDefinition.directives);
+                    factory.schemaDefinition.description = node.description;
+                },
+            },
+            SchemaExtension: {
+                enter(node) {
+                    factory.extractDirectives(node, factory.schemaDefinition.directives);
+                },
+            },
+        });
         (0, graphql_1.visit)(document, {
             DirectiveDefinition: {
                 enter(node) {
@@ -507,6 +618,7 @@ class NormalizationFactory {
             Directive: {
                 enter(node) {
                     const name = node.name.value;
+                    factory.handleOverride(node, fieldName);
                     if (constants_1.VERSION_TWO_DIRECTIVES.has(name)) {
                         factory.isSubgraphVersionTwo = true;
                         return false;
@@ -525,6 +637,7 @@ class NormalizationFactory {
                         return false;
                     }
                     factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     factory.parents.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
@@ -535,12 +648,14 @@ class NormalizationFactory {
                 },
                 leave() {
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             EnumTypeExtension: {
                 enter(node) {
                     const name = node.name.value;
                     factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     factory.isCurrentParentExtension = true;
                     const extension = factory.extensions.get(factory.parentTypeName);
                     if (extension) {
@@ -559,13 +674,16 @@ class NormalizationFactory {
                     });
                 },
                 leave() {
-                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                    factory.isCurrentParentExtension = false;
                 },
             },
             EnumValueDefinition: {
                 enter(node) {
                     const name = node.name.value;
+                    factory.childName = name;
+                    factory.lastChildNodeKind = node.kind;
                     const parent = factory.isCurrentParentExtension
                         ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
                         : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName, string_constants_1.PARENTS);
@@ -585,6 +703,10 @@ class NormalizationFactory {
                         node: { ...node, description: (0, utils_1.formatDescription)(node.description) },
                     });
                 },
+                leave() {
+                    factory.childName = '';
+                    factory.lastChildNodeKind = graphql_1.Kind.NULL;
+                },
             },
             FieldDefinition: {
                 enter(node) {
@@ -592,8 +714,10 @@ class NormalizationFactory {
                     if (isCurrentParentRootType && (name === string_constants_1.SERVICE_FIELD || name === string_constants_1.ENTITIES_FIELD)) {
                         return false;
                     }
+                    factory.childName = name;
+                    factory.lastChildNodeKind = node.kind;
                     const fieldPath = `${factory.parentTypeName}.${name}`;
-                    factory.isChild = true;
+                    factory.lastChildNodeKind = node.kind;
                     const fieldNamedTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
                     if (!constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
                         factory.referencedTypeNames.add(fieldNamedTypeName);
@@ -647,7 +771,8 @@ class NormalizationFactory {
                     (0, utils_2.extractFieldSetValue)(name, fieldSetContainer.provides, providesDirectives);
                 },
                 leave() {
-                    factory.isChild = false;
+                    factory.childName = '';
+                    factory.lastChildNodeKind = graphql_1.Kind.NULL;
                 },
             },
             InputObjectTypeDefinition: {
@@ -657,6 +782,7 @@ class NormalizationFactory {
                         factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
+                    factory.lastParentNodeKind = node.kind;
                     factory.parentTypeName = name;
                     factory.parents.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
@@ -667,6 +793,7 @@ class NormalizationFactory {
                     });
                 },
                 leave() {
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                     factory.parentTypeName = '';
                 },
             },
@@ -674,6 +801,7 @@ class NormalizationFactory {
                 enter(node) {
                     const name = node.name.value;
                     factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     factory.isCurrentParentExtension = true;
                     const extension = factory.extensions.get(factory.parentTypeName);
                     if (extension) {
@@ -692,16 +820,22 @@ class NormalizationFactory {
                     });
                 },
                 leave() {
-                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                    factory.isCurrentParentExtension = false;
                 },
             },
             InputValueDefinition: {
                 enter(node) {
-                    if (!factory.parentTypeName || factory.isChild) {
+                    const name = node.name.value;
+                    // If the parent is not an object type definition/extension, this node is an argument
+                    if (factory.lastParentNodeKind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION
+                        && factory.lastParentNodeKind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                        factory.argumentName = name;
                         return;
                     }
-                    const name = node.name.value;
+                    factory.childName = name;
+                    factory.lastChildNodeKind = node.kind;
                     const valueRootTypeName = (0, type_merging_1.getNamedTypeForChild)(`${factory.parentTypeName}.${name}`, node.type);
                     if (!constants_1.BASE_SCALARS.has(valueRootTypeName)) {
                         factory.referencedTypeNames.add(valueRootTypeName);
@@ -722,11 +856,20 @@ class NormalizationFactory {
                         node: { ...node, description: (0, utils_1.formatDescription)(node.description) },
                     });
                 },
+                leave() {
+                    factory.argumentName = '';
+                    // Only reset childName and lastNodeKind if this input value was NOT an argument
+                    if (factory.lastChildNodeKind === graphql_1.Kind.INPUT_VALUE_DEFINITION) {
+                        factory.childName = '';
+                        factory.lastChildNodeKind = graphql_1.Kind.NULL;
+                    }
+                },
             },
             InterfaceTypeDefinition: {
                 enter(node) {
                     const name = node.name.value;
                     factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     if ((0, utils_1.isNodeExtension)(node)) {
                         return factory.handleObjectLikeExtension(node);
                     }
@@ -744,18 +887,21 @@ class NormalizationFactory {
                     });
                 },
                 leave() {
-                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                    factory.isCurrentParentExtension = false;
                 },
             },
             InterfaceTypeExtension: {
                 enter(node) {
                     factory.parentTypeName = node.name.value;
+                    factory.lastParentNodeKind = node.kind;
                     return factory.handleObjectLikeExtension(node);
                 },
                 leave() {
                     factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             ObjectTypeDefinition: {
@@ -764,8 +910,9 @@ class NormalizationFactory {
                     if (name === string_constants_1.SERVICE_OBJECT) {
                         return false;
                     }
-                    isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name);
+                    isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name) || factory.operationTypeNames.has(name);
                     factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
                     // handling for @extends directive
                     if ((0, utils_1.isNodeExtension)(node)) {
@@ -793,9 +940,10 @@ class NormalizationFactory {
                     factory.extractKeyFieldSets(node, fieldSets.keys);
                 },
                 leave() {
-                    factory.isCurrentParentExtension = false;
                     isCurrentParentRootType = false;
+                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             ObjectTypeExtension: {
@@ -804,36 +952,17 @@ class NormalizationFactory {
                     if (name === string_constants_1.SERVICE_OBJECT) {
                         return false;
                     }
-                    isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name);
+                    isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name) || factory.operationTypeNames.has(name);
                     factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
                     return factory.handleObjectLikeExtension(node);
                 },
                 leave() {
-                    factory.isCurrentParentExtension = false;
                     isCurrentParentRootType = false;
+                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
-                },
-            },
-            OperationTypeDefinition: {
-                enter(node) {
-                    const operationType = node.operation;
-                    const operationPath = `${factory.parentTypeName}.${operationType}`;
-                    const definitionNode = factory.schemaDefinition.operationTypes.get(operationType);
-                    const newTypeName = (0, type_merging_1.getNamedTypeForChild)(operationPath, node.type);
-                    if (definitionNode) {
-                        (0, errors_1.duplicateOperationTypeDefinitionError)(operationType, newTypeName, (0, type_merging_1.getNamedTypeForChild)(operationPath, definitionNode.type));
-                        return false;
-                    }
-                    const existingOperationType = factory.operationTypeNames.get(newTypeName);
-                    if (existingOperationType) {
-                        factory.errors.push((0, errors_1.invalidOperationTypeDefinitionError)(existingOperationType, newTypeName, operationType));
-                    }
-                    else {
-                        factory.operationTypeNames.set(newTypeName, operationType);
-                        factory.schemaDefinition.operationTypes.set(operationType, node);
-                    }
-                    return false;
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             ScalarTypeDefinition: {
@@ -847,6 +976,8 @@ class NormalizationFactory {
                         factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
+                    factory.parentTypeName = name;
+                    factory.lastParentNodeKind = node.kind;
                     factory.parents.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
@@ -854,6 +985,10 @@ class NormalizationFactory {
                         name: node.name,
                     });
                 },
+                leave() {
+                    factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                },
             },
             ScalarTypeExtension: {
                 enter(node) {
@@ -870,6 +1005,8 @@ class NormalizationFactory {
                         factory.extractDirectives(node, extension.directives);
                     }
                     else {
+                        factory.parentTypeName = name;
+                        factory.lastParentNodeKind = node.kind;
                         factory.extensions.set(name, {
                             directives: factory.extractDirectives(node, new Map()),
                             kind: node.kind,
@@ -878,16 +1015,9 @@ class NormalizationFactory {
                     }
                     return false;
                 },
-            },
-            SchemaDefinition: {
-                enter(node) {
-                    factory.extractDirectives(node, factory.schemaDefinition.directives);
-                    factory.schemaDefinition.description = node.description;
-                },
-            },
-            SchemaExtension: {
-                enter(node) {
-                    factory.extractDirectives(node, factory.schemaDefinition.directives);
+                leave() {
+                    factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             UnionTypeDefinition: {
@@ -906,6 +1036,7 @@ class NormalizationFactory {
                         factory.errors.push((0, errors_1.noDefinedUnionMembersError)(name));
                         return false;
                     }
+                    factory.lastParentNodeKind = node.kind;
                     (0, utils_1.addConcreteTypesForUnion)(node, factory.abstractToConcreteTypeNames);
                     factory.parents.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
@@ -917,6 +1048,7 @@ class NormalizationFactory {
                 },
                 leave() {
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             UnionTypeExtension: {
@@ -930,6 +1062,7 @@ class NormalizationFactory {
                         factory.errors.push();
                         return false;
                     }
+                    factory.lastParentNodeKind = node.kind;
                     (0, utils_1.addConcreteTypesForUnion)(node, factory.abstractToConcreteTypeNames);
                     if (extension) {
                         if (extension.kind !== graphql_1.Kind.UNION_TYPE_EXTENSION) {
@@ -948,6 +1081,9 @@ class NormalizationFactory {
                     }
                     return false;
                 },
+                leave() {
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                },
             },
         });
         const definitions = [];
@@ -1201,6 +1337,7 @@ class NormalizationFactory {
                 isVersionTwo: this.isSubgraphVersionTwo,
                 keyFieldsByParentTypeName: this.keyFieldsByParentTypeName,
                 operationTypes: this.operationTypeNames,
+                overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
                 subgraphAST: newAST,
                 subgraphString: (0, graphql_1.print)(newAST),
                 schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true }),
@@ -1209,4 +1346,110 @@ class NormalizationFactory {
     }
 }
 exports.NormalizationFactory = NormalizationFactory;
+function batchNormalize(subgraphs) {
+    const internalSubgraphsBySubgraphName = new Map;
+    const allOverridesByTargetSubgraphName = new Map();
+    const overrideSourceSubgraphNamesByFieldPath = new Map();
+    const duplicateOverriddenFieldPaths = new Set();
+    const validationErrors = [];
+    const subgraphNames = new Set();
+    const nonUniqueSubgraphNames = new Set();
+    const invalidNameErrorMessages = [];
+    // Record the subgraph names first, so that subgraph references can be validated
+    for (const subgraph of subgraphs) {
+        if (subgraph.name) {
+            (0, subgraph_1.recordSubgraphName)(subgraph.name, subgraphNames, nonUniqueSubgraphNames);
+        }
+    }
+    for (let i = 0; i < subgraphs.length; i++) {
+        const subgraph = subgraphs[i];
+        const subgraphName = subgraph.name || `subgraph-${i}-${Date.now()}`;
+        if (!subgraph.name) {
+            invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, subgraphName));
+        }
+        const { errors, normalizationResult } = normalizeSubgraph(subgraph.definitions);
+        if (errors) {
+            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, errors));
+            continue;
+        }
+        if (!normalizationResult) {
+            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, [errors_1.subgraphValidationFailureError]));
+            continue;
+        }
+        if (subgraph.name) {
+            internalSubgraphsBySubgraphName.set(subgraphName, {
+                configurationDataMap: normalizationResult.configurationDataMap,
+                definitions: normalizationResult.subgraphAST,
+                keyFieldsByParentTypeName: normalizationResult.keyFieldsByParentTypeName,
+                isVersionTwo: normalizationResult.isVersionTwo,
+                name: subgraphName,
+                operationTypes: normalizationResult.operationTypes,
+                overriddenFieldNamesByParentTypeName: new Map(),
+                schema: normalizationResult.schema,
+                url: subgraph.url,
+            });
+        }
+        if (normalizationResult.overridesByTargetSubgraphName.size < 1) {
+            continue;
+        }
+        const invalidOverrideTargetSubgraphNameErrors = [];
+        for (const [targetSubgraphName, overridesData] of normalizationResult.overridesByTargetSubgraphName) {
+            const isTargetValid = subgraphNames.has(targetSubgraphName);
+            for (const [parentTypeName, fieldNames] of overridesData) {
+                if (!isTargetValid) {
+                    invalidOverrideTargetSubgraphNameErrors.push((0, errors_1.invalidOverrideTargetSubgraphNameError)(targetSubgraphName, parentTypeName, [...fieldNames]));
+                }
+                else {
+                    const overridesData = (0, utils_3.getValueOrDefault)(allOverridesByTargetSubgraphName, targetSubgraphName, () => new Map());
+                    (0, utils_3.getValueOrDefault)(overridesData, parentTypeName, () => new Set(fieldNames));
+                }
+                for (const fieldName of fieldNames) {
+                    const fieldPath = `${parentTypeName}.${fieldName}`;
+                    const sourceSubgraphs = overrideSourceSubgraphNamesByFieldPath.get(fieldPath);
+                    if (!sourceSubgraphs) {
+                        overrideSourceSubgraphNamesByFieldPath.set(fieldPath, [subgraphName]);
+                        continue;
+                    }
+                    sourceSubgraphs.push(subgraphName);
+                    duplicateOverriddenFieldPaths.add(fieldPath);
+                }
+            }
+        }
+        if (invalidOverrideTargetSubgraphNameErrors.length > 0) {
+            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, invalidOverrideTargetSubgraphNameErrors));
+        }
+    }
+    const allErrors = [];
+    if (invalidNameErrorMessages.length > 0 || nonUniqueSubgraphNames.size > 0) {
+        allErrors.push((0, errors_1.invalidSubgraphNamesError)([...nonUniqueSubgraphNames], invalidNameErrorMessages));
+    }
+    if (duplicateOverriddenFieldPaths.size > 0) {
+        const duplicateOverriddenFieldErrorMessages = [];
+        for (const fieldPath of duplicateOverriddenFieldPaths) {
+            const sourceSubgraphNames = (0, utils_3.getOrThrowError)(overrideSourceSubgraphNamesByFieldPath, fieldPath, 'overrideSourceSubgraphNamesByFieldPath');
+            duplicateOverriddenFieldErrorMessages.push((0, errors_1.duplicateOverriddenFieldErrorMessage)(fieldPath, sourceSubgraphNames));
+        }
+        allErrors.push((0, errors_1.duplicateOverriddenFieldsError)(duplicateOverriddenFieldErrorMessages));
+    }
+    allErrors.push(...validationErrors);
+    if (allErrors.length > 0) {
+        return { errors: allErrors, internalSubgraphsBySubgraphName };
+    }
+    for (const [targetSubgraphName, overridesData] of allOverridesByTargetSubgraphName) {
+        const internalSubgraph = (0, utils_3.getOrThrowError)(internalSubgraphsBySubgraphName, targetSubgraphName, 'normalizedSubgraphsByName');
+        internalSubgraph.overriddenFieldNamesByParentTypeName = overridesData;
+        for (const [parentTypeName, fieldNames] of overridesData) {
+            const configurationData = internalSubgraph.configurationDataMap.get(parentTypeName);
+            if (!configurationData) {
+                continue;
+            }
+            (0, utils_3.subtractSourceSetFromTargetSet)(fieldNames, configurationData.fieldNames);
+            if (configurationData.fieldNames.size < 1) {
+                internalSubgraph.configurationDataMap.delete(parentTypeName);
+            }
+        }
+    }
+    return { internalSubgraphsBySubgraphName: internalSubgraphsBySubgraphName };
+}
+exports.batchNormalize = batchNormalize;
 //# sourceMappingURL=normalization-factory.js.map