@wundergraph/composition 0.10.0 → 0.11.0

package/dist/federation/utils.d.ts

@@ -1,6 +1,7 @@
 import { ConstDirectiveNode, DocumentNode, GraphQLSchema, Kind } from 'graphql';
 import { ArgumentConfigurationData } from '../subgraph/field-configuration';
 import { MutableDirectiveDefinitionNode, MutableEnumTypeDefinitionNode, MutableEnumValueDefinitionNode, MutableFieldDefinitionNode, MutableInputObjectTypeDefinitionNode, MutableInputValueDefinitionNode, MutableInterfaceTypeDefinitionNode, MutableObjectTypeDefinitionNode, MutableObjectTypeExtensionNode, MutableScalarTypeDefinitionNode, MutableUnionTypeDefinitionNode } from '../ast/ast';
+import { SubgraphConfig } from '../subgraph/subgraph';
 export type FederationResultContainer = {
     errors?: Error[];
     federationResult?: FederationResult;
@@ -9,6 +10,7 @@ export type FederationResult = {
     argumentConfigurations: ArgumentConfigurationData[];
     federatedGraphAST: DocumentNode;
     federatedGraphSchema: GraphQLSchema;
+    subgraphConfigBySubgraphName: Map<string, SubgraphConfig>;
 };
 export type RootTypeFieldData = {
     fieldName: string;

package/dist/federation/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/federation/utils.ts"],"names":[],"mappings":";;;AAeA,gEAQmC;AAqBtB,QAAA,8BAA8B,GAAG,IAAI,GAAG,CAAS;IAC5D,8BAAW,EAAE,4CAAyB,EAAE,wCAAqB;IAC7D,wCAAqB,EAAE,iCAAc,EAAE,8BAAW,EAAE,qCAAkB;CACvE,CAAC,CAAC;AAEH,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,+CAAK,CAAA;IACL,6DAAY,CAAA;IACZ,yDAAU,CAAA;AACZ,CAAC,EAJW,WAAW,2BAAX,WAAW,QAItB;AAaD,SAAgB,+BAA+B;IAC7C,OAAO;QACL,UAAU,EAAE,EAAE;QACd,UAAU,EAAE,IAAI,GAAG,EAAgC;QACjD,IAAI,EAAE,IAAI,GAAG,EAA8B;KAC9C,CAAC;AACJ,CAAC;AAND,0EAMC"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/federation/utils.ts"],"names":[],"mappings":";;;AAeA,gEAQmC;AAuBtB,QAAA,8BAA8B,GAAG,IAAI,GAAG,CAAS;IAC5D,8BAAW,EAAE,4CAAyB,EAAE,wCAAqB;IAC7D,wCAAqB,EAAE,iCAAc,EAAE,8BAAW,EAAE,qCAAkB;CACvE,CAAC,CAAC;AAEH,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,+CAAK,CAAA;IACL,6DAAY,CAAA;IACZ,yDAAU,CAAA;AACZ,CAAC,EAJW,WAAW,2BAAX,WAAW,QAItB;AAaD,SAAgB,+BAA+B;IAC7C,OAAO;QACL,UAAU,EAAE,EAAE;QACd,UAAU,EAAE,IAAI,GAAG,EAAgC;QACnD,IAAI,EAAE,IAAI,GAAG,EAA8B;KAC5C,CAAC;AACJ,CAAC;AAND,0EAMC"}

package/dist/normalization/normalization-factory.d.ts

@@ -1,12 +1,14 @@
-import { ConstDirectiveNode, DirectiveDefinitionNode, DocumentNode, EnumValueDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputValueDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, Kind, NamedTypeNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, OperationTypeNode, SchemaDefinitionNode, SchemaExtensionNode, TypeDefinitionNode, TypeExtensionNode, TypeNode } from 'graphql';
+import { ConstDirectiveNode, DirectiveDefinitionNode, DirectiveNode, DocumentNode, EnumValueDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputValueDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, Kind, NamedTypeNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, OperationTypeNode, SchemaDefinitionNode, SchemaExtensionNode, TypeDefinitionNode, TypeExtensionNode, TypeNode } from 'graphql';
 import { ChildContainer, ExtensionContainer, ExtensionMap, FieldContainer, FieldSetContainer, InputValidationContainer, ObjectExtensionContainer, ObjectLikeContainer, ParentContainer, ParentMap, SchemaContainer, UnionContainer, UnionExtensionContainer } from './utils';
 import { ConfigurationData, ConfigurationDataMap } from '../subgraph/field-configuration';
 import { MutableInputValueDefinitionNode } from '../ast/ast';
+import { InternalSubgraph, Subgraph } from '../subgraph/subgraph';
 export type NormalizationResult = {
     configurationDataMap: ConfigurationDataMap;
     isVersionTwo: boolean;
     keyFieldsByParentTypeName: Map<string, Set<string>>;
     operationTypes: Map<string, OperationTypeNode>;
+    overridesByTargetSubgraphName: Map<string, Map<string, Set<string>>>;
     schema: GraphQLSchema;
     subgraphAST: DocumentNode;
     subgraphString: string;
@@ -15,25 +17,34 @@ export type NormalizationResultContainer = {
     errors?: Error[];
     normalizationResult?: NormalizationResult;
 };
-export declare function normalizeSubgraphFromString(subgraph: string): NormalizationResultContainer;
+export type BatchNormalizationContainer = {
+    errors?: Error[];
+    internalSubgraphsBySubgraphName: Map<string, InternalSubgraph>;
+};
+export declare function normalizeSubgraphFromString(subgraphSDL: string): NormalizationResultContainer;
 export declare function normalizeSubgraph(document: DocumentNode): NormalizationResultContainer;
 export declare class NormalizationFactory {
     abstractToConcreteTypeNames: Map<string, Set<string>>;
     allDirectiveDefinitions: Map<string, DirectiveDefinitionNode>;
+    argumentName: string;
+    childName: string;
     configurationDataMap: Map<string, ConfigurationData>;
     customDirectiveDefinitions: Map<string, DirectiveDefinitionNode>;
     errors: Error[];
     entities: Set<string>;
+    extensions: ExtensionMap;
+    isCurrentParentExtension: boolean;
+    isSubgraphVersionTwo: boolean;
     fieldSetsByParent: Map<string, FieldSetContainer>;
+    handledRepeatedDirectivesByHostPath: Map<string, Set<string>>;
+    lastParentNodeKind: Kind;
+    lastChildNodeKind: Kind;
     keyFieldsByParentTypeName: Map<string, Set<string>>;
     operationTypeNames: Map<string, OperationTypeNode>;
     parents: ParentMap;
     parentTypeName: string;
     parentsWithChildArguments: Set<string>;
-    extensions: ExtensionMap;
-    isChild: boolean;
-    isCurrentParentExtension: boolean;
-    isSubgraphVersionTwo: boolean;
+    overridesByTargetSubgraphName: Map<string, Map<string, Set<string>>>;
     schemaDefinition: SchemaContainer;
     referencedDirectives: Set<string>;
     referencedTypeNames: Set<string>;
@@ -53,6 +64,7 @@ export declare class NormalizationFactory {
     isTypeValidImplementation(originalType: TypeNode, implementationType: TypeNode): boolean;
     extractKeyFieldSets(node: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, rawFieldSets: Set<string>): void;
     validateInterfaceImplementations(container: ObjectLikeContainer): void;
+    handleOverride(node: DirectiveNode, fieldName: string): void;
     normalize(document: DocumentNode): {
         errors: Error[];
         normalizationResult?: undefined;
@@ -62,6 +74,7 @@ export declare class NormalizationFactory {
             isVersionTwo: boolean;
             keyFieldsByParentTypeName: Map<string, Set<string>>;
             operationTypes: Map<string, OperationTypeNode>;
+            overridesByTargetSubgraphName: Map<string, Map<string, Set<string>>>;
             subgraphAST: DocumentNode;
             subgraphString: string;
             schema: GraphQLSchema;
@@ -69,3 +82,4 @@ export declare class NormalizationFactory {
         errors?: undefined;
     };
 }
+export declare function batchNormalize(subgraphs: Subgraph[]): BatchNormalizationContainer;

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,7 @@ 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 = '';
         (0, graphql_1.visit)(document, {
             DirectiveDefinition: {
                 enter(node) {
@@ -507,6 +583,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 +602,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 +613,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 +639,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 +668,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 +679,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 +736,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 +747,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 +758,7 @@ class NormalizationFactory {
                     });
                 },
                 leave() {
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                     factory.parentTypeName = '';
                 },
             },
@@ -674,6 +766,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 +785,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 +821,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 +852,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: {
@@ -766,6 +877,7 @@ class NormalizationFactory {
                     }
                     isCurrentParentRootType = string_constants_1.ROOT_TYPES.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 +905,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: {
@@ -806,13 +919,15 @@ class NormalizationFactory {
                     }
                     isCurrentParentRootType = string_constants_1.ROOT_TYPES.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 = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             OperationTypeDefinition: {
@@ -847,6 +962,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 +971,10 @@ class NormalizationFactory {
                         name: node.name,
                     });
                 },
+                leave() {
+                    factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                },
             },
             ScalarTypeExtension: {
                 enter(node) {
@@ -870,6 +991,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,6 +1001,10 @@ class NormalizationFactory {
                     }
                     return false;
                 },
+                leave() {
+                    factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                },
             },
             SchemaDefinition: {
                 enter(node) {
@@ -906,6 +1033,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 +1045,7 @@ class NormalizationFactory {
                 },
                 leave() {
                     factory.parentTypeName = '';
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
                 },
             },
             UnionTypeExtension: {
@@ -930,6 +1059,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 +1078,9 @@ class NormalizationFactory {
                     }
                     return false;
                 },
+                leave() {
+                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
+                },
             },
         });
         const definitions = [];
@@ -1201,6 +1334,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 +1343,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