@wundergraph/composition 0.0.1

package/dist/normalization/normalization-factory.js

@@ -0,0 +1,882 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizationFactory = exports.normalizeSubgraph = exports.normalizeSubgraphFromString = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("../ast/utils");
+const utils_2 = require("./utils");
+const constants_1 = require("../utils/constants");
+const type_merging_1 = require("../type-merging/type-merging");
+const utils_3 = require("../utils/utils");
+const errors_1 = require("../errors/errors");
+const string_constants_1 = require("../utils/string-constants");
+const buildASTSchema_1 = require("../buildASTSchema/buildASTSchema");
+function normalizeSubgraphFromString(subgraph) {
+    let document;
+    try {
+        document = (0, graphql_1.parse)(subgraph);
+    }
+    catch (err) {
+        return { errors: [(0, errors_1.subgraphInvalidSyntaxError)(err)] };
+    }
+    const normalizationFactory = new NormalizationFactory();
+    return normalizationFactory.normalize(document);
+}
+exports.normalizeSubgraphFromString = normalizeSubgraphFromString;
+function normalizeSubgraph(document) {
+    const normalizationFactory = new NormalizationFactory();
+    return normalizationFactory.normalize(document);
+}
+exports.normalizeSubgraph = normalizeSubgraph;
+class NormalizationFactory {
+    allDirectiveDefinitions = new Map();
+    customDirectiveDefinitions = new Map();
+    errors = [];
+    entityMap = new Map();
+    operationTypeNames = new Map();
+    parents = new Map();
+    parentTypeName = '';
+    extensions = new Map();
+    isChild = false;
+    isCurrentParentExtension = false;
+    isSubgraphVersionTwo = false;
+    schemaDefinition;
+    referencedDirectives = new Set();
+    referencedTypeNames = new Set();
+    constructor() {
+        for (const baseDirectiveDefinition of constants_1.BASE_DIRECTIVE_DEFINITIONS) {
+            this.allDirectiveDefinitions.set(baseDirectiveDefinition.name.value, baseDirectiveDefinition);
+        }
+        this.schemaDefinition = {
+            directives: new Map(),
+            kind: graphql_1.Kind.SCHEMA_DEFINITION,
+            name: (0, utils_1.stringToNameNode)(string_constants_1.SCHEMA),
+            operationTypes: new Map(),
+        };
+    }
+    extractDirectives(node, map) {
+        if (!node.directives) {
+            return map;
+        }
+        for (const directive of node.directives) {
+            const directiveName = directive.name.value;
+            const existingDirectives = map.get(directiveName);
+            if (existingDirectives) {
+                existingDirectives.push(directive);
+                continue;
+            }
+            map.set(directiveName, [directive]);
+        }
+        return map;
+    }
+    extractUniqueInterfaces(node, interfaces) {
+        if (!node.interfaces) {
+            return interfaces;
+        }
+        for (const face of node.interfaces) {
+            const name = face.name.value;
+            if (interfaces.has(name)) {
+                this.errors.push(new Error(`Interface "${name}" can only be defined on type "${this.parentTypeName}" once.`)); // TODO
+                continue;
+            }
+            interfaces.add(name);
+        }
+        return interfaces;
+    }
+    extractUniqueUnionMembers(members, map) {
+        for (const member of members) {
+            const name = member.name.value;
+            if (map.has(name)) {
+                this.errors.push(new Error(`Member "${name} can only be defined on union "${this.parentTypeName}" once.`));
+                continue;
+            }
+            if (!constants_1.BASE_SCALARS.has(name)) {
+                this.referencedTypeNames.add(name);
+            }
+            map.set(name, member);
+        }
+        return map;
+    }
+    mergeUniqueInterfaces(extensionInterfaces, interfaces, typeName) {
+        for (const interfaceName of extensionInterfaces) {
+            if (!interfaces.has(interfaceName)) {
+                interfaces.add(interfaceName);
+                continue;
+            }
+            this.errors.push((0, errors_1.duplicateInterfaceError)(interfaceName, typeName)); // TODO
+        }
+    }
+    mergeUniqueUnionMembers(baseUnion, extensionUnion) {
+        if (!extensionUnion) {
+            return;
+        }
+        const extensionMembers = extensionUnion.types;
+        const members = baseUnion.types;
+        const typeName = baseUnion.name.value;
+        for (const [memberName, namedTypeNode] of extensionMembers) {
+            if (!members.has(memberName)) {
+                members.set(memberName, namedTypeNode);
+                continue;
+            }
+            this.errors.push((0, errors_1.duplicateUnionMemberError)(memberName, typeName));
+        }
+    }
+    mergeDirectives(baseTypeDirectives, extension) {
+        if (!extension) {
+            return;
+        }
+        for (const [directiveName, directives] of extension.directives) {
+            const existingDirectives = baseTypeDirectives.get(directiveName);
+            if (existingDirectives) {
+                existingDirectives.push(...directives);
+                continue;
+            }
+            baseTypeDirectives.set(directiveName, [...directives]);
+        }
+    }
+    getValidatedAndNormalizedParentDirectives(parent) {
+        const parentTypeName = parent.name.value;
+        const normalizedDirectives = [];
+        for (const [directiveName, directives] of parent.directives) {
+            const definition = this.allDirectiveDefinitions.get(directiveName);
+            if (!definition) {
+                this.errors.push((0, errors_1.undefinedDirectiveError)(parentTypeName, directiveName));
+                continue;
+            }
+            const allArguments = new Set();
+            const requiredArguments = new Set();
+            (0, utils_2.getDirectiveDefinitionArgumentSets)(definition.arguments || [], allArguments, requiredArguments);
+            const entityKeys = new Set();
+            const errorMessages = [];
+            for (const directive of directives) {
+                if (!(0, utils_2.areNodeKindAndDirectiveLocationCompatible)(parent.kind, definition)) {
+                    errorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(parentTypeName, parent.kind, directiveName));
+                }
+                if (!definition.repeatable && directives.length > 1) {
+                    errorMessages.push((0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName, parentTypeName));
+                }
+                if (!definition.arguments || definition.arguments.length < 1) {
+                    if (directive.arguments && directive.arguments.length > 0) {
+                        errorMessages.push((0, errors_1.unexpectedDirectiveArgumentsErrorMessage)(directive, parentTypeName));
+                    }
+                    else {
+                        normalizedDirectives.push(directive);
+                    }
+                    continue;
+                }
+                if (!directive.arguments || directive.arguments.length < 1) {
+                    if (requiredArguments.size > 0) {
+                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, Array.from(requiredArguments)));
+                    }
+                    else {
+                        normalizedDirectives.push(directive);
+                    }
+                    continue;
+                }
+                const definedArguments = (0, utils_2.getDefinedArgumentsForDirective)(directive.arguments, allArguments, directiveName, parentTypeName, errorMessages);
+                const missingRequiredArguments = (0, utils_3.getEntriesNotInSet)(requiredArguments, definedArguments);
+                if (missingRequiredArguments.length > 0) {
+                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, Array.from(requiredArguments), missingRequiredArguments));
+                }
+                // Only add unique entity keys
+                if (directiveName === string_constants_1.KEY) {
+                    const directiveKind = directive.arguments[0].value.kind;
+                    if (directiveKind !== graphql_1.Kind.STRING) {
+                        errorMessages.push((0, errors_1.invalidKeyDirectiveArgumentErrorMessage)(directiveKind));
+                        continue;
+                    }
+                    const entityKey = directive.arguments[0].value.value;
+                    if (entityKeys.has(entityKey)) {
+                        continue;
+                    }
+                    entityKeys.add(entityKey);
+                }
+                normalizedDirectives.push(directive);
+            }
+            if (errorMessages.length > 0) {
+                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, parentTypeName, errorMessages));
+            }
+        }
+        return normalizedDirectives;
+    }
+    validateChildDirectives(child, hostPath) {
+        const childKind = child.node.kind;
+        for (const [directiveName, directives] of child.directives) {
+            const definition = this.allDirectiveDefinitions.get(directiveName);
+            if (!definition) {
+                this.errors.push((0, errors_1.undefinedDirectiveError)(hostPath, directiveName));
+                continue;
+            }
+            const allArguments = new Set();
+            const requiredArguments = new Set();
+            (0, utils_2.getDirectiveDefinitionArgumentSets)(definition.arguments || [], allArguments, requiredArguments);
+            const errorMessages = [];
+            for (const directive of directives) {
+                if (!(0, utils_2.areNodeKindAndDirectiveLocationCompatible)(childKind, definition)) {
+                    errorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(hostPath, childKind, directiveName));
+                }
+                if (!definition.repeatable && directives.length > 1) {
+                    errorMessages.push((0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName, hostPath));
+                }
+                if (!definition.arguments || definition.arguments.length < 1) {
+                    if (directive.arguments && directive.arguments.length > 0) {
+                        errorMessages.push((0, errors_1.unexpectedDirectiveArgumentsErrorMessage)(directive, hostPath));
+                    }
+                    continue;
+                }
+                if (!directive.arguments || directive.arguments.length < 1) {
+                    if (requiredArguments.size > 0) {
+                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, Array.from(requiredArguments)));
+                    }
+                    continue;
+                }
+                const definedArguments = (0, utils_2.getDefinedArgumentsForDirective)(directive.arguments, allArguments, directiveName, hostPath, errorMessages);
+                const missingRequiredArguments = (0, utils_3.getEntriesNotInSet)(requiredArguments, definedArguments);
+                if (missingRequiredArguments.length > 0) {
+                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, Array.from(requiredArguments), missingRequiredArguments));
+                }
+            }
+            if (errorMessages.length > 0) {
+                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
+            }
+        }
+    }
+    normalize(document) {
+        const factory = this;
+        (0, graphql_1.visit)(document, {
+            DirectiveDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    // TODO These sets would potentially allow the user to define these directives more than once
+                    // Add our definitions rather than the existing ones
+                    if (constants_1.VERSION_TWO_DIRECTIVES.has(name)) {
+                        factory.isSubgraphVersionTwo = true;
+                        return false;
+                    }
+                    if (constants_1.VERSION_ONE_DIRECTIVES.has(name)) {
+                        return false;
+                    }
+                    const directiveDefinition = factory.allDirectiveDefinitions.get(name);
+                    if (directiveDefinition) {
+                        factory.errors.push((0, errors_1.duplicateDirectiveDefinitionError)(name));
+                        return false;
+                    }
+                    factory.allDirectiveDefinitions.set(name, node);
+                    factory.customDirectiveDefinitions.set(name, node);
+                    return false;
+                },
+            },
+            Directive: {
+                enter(node) {
+                    const name = node.name.value;
+                    if (constants_1.VERSION_TWO_DIRECTIVES.has(name)) {
+                        factory.isSubgraphVersionTwo = true;
+                        return false;
+                    }
+                    if (constants_1.VERSION_ONE_DIRECTIVES.has(name)) {
+                        return false;
+                    }
+                    factory.referencedDirectives.add(name);
+                },
+            },
+            EnumTypeDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    if (factory.parents.has(name)) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('enum', name));
+                        return false;
+                    }
+                    factory.parentTypeName = name;
+                    factory.parents.set(name, {
+                        description: node.description,
+                        directives: factory.extractDirectives(node, new Map()),
+                        kind: node.kind,
+                        name: node.name,
+                        values: new Map(),
+                    });
+                },
+                leave() {
+                    factory.parentTypeName = '';
+                },
+            },
+            EnumTypeExtension: {
+                enter(node) {
+                    const name = node.name.value;
+                    factory.parentTypeName = name;
+                    factory.isCurrentParentExtension = true;
+                    const extension = factory.extensions.get(factory.parentTypeName);
+                    if (extension) {
+                        if (extension.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
+                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                            return false;
+                        }
+                        factory.extractDirectives(node, extension.directives);
+                        return;
+                    }
+                    factory.extensions.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        kind: node.kind,
+                        name: node.name,
+                        values: new Map(),
+                    });
+                },
+                leave() {
+                    factory.isCurrentParentExtension = false;
+                    factory.parentTypeName = '';
+                },
+            },
+            EnumValueDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    const parent = factory.isCurrentParentExtension
+                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
+                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
+                    if (parent.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
+                        throw new Error(''); // TODO
+                    }
+                    if (parent.values.has(name)) {
+                        const error = factory.isCurrentParentExtension
+                            ? (0, errors_1.duplicateValueExtensionError)('enum', factory.parentTypeName, name)
+                            : (0, errors_1.duplicateEnumValueDefinitionError)(name, factory.parentTypeName);
+                        factory.errors.push(error);
+                        return;
+                    }
+                    parent.values.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        name,
+                        node,
+                    });
+                },
+            },
+            FieldDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    const fieldPath = `${factory.parentTypeName}.${name}`;
+                    factory.isChild = true;
+                    const fieldRootType = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
+                    if (!constants_1.BASE_SCALARS.has(fieldRootType)) {
+                        factory.referencedTypeNames.add(fieldRootType);
+                    }
+                    const parent = factory.isCurrentParentExtension
+                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
+                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
+                    if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                        parent.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
+                        parent.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
+                        parent.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
+                        throw new Error(''); // TODO
+                    }
+                    if (parent.fields.has(name)) {
+                        const error = factory.isCurrentParentExtension
+                            ? (0, errors_1.duplicateFieldExtensionError)(factory.parentTypeName, name)
+                            : (0, errors_1.duplicateFieldDefinitionError)(name, factory.parentTypeName);
+                        factory.errors.push(error);
+                        return;
+                    }
+                    parent.fields.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        name,
+                        node,
+                    });
+                },
+                leave() {
+                    factory.isChild = false;
+                },
+            },
+            InputObjectTypeDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    if (factory.parents.has(name)) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('input object', name));
+                        return false;
+                    }
+                    factory.parentTypeName = name;
+                    factory.parents.set(name, {
+                        description: node.description,
+                        directives: factory.extractDirectives(node, new Map()),
+                        fields: new Map(),
+                        kind: node.kind,
+                        name: node.name,
+                    });
+                },
+                leave() {
+                    factory.parentTypeName = '';
+                },
+            },
+            InputObjectTypeExtension: {
+                enter(node) {
+                    const name = node.name.value;
+                    factory.parentTypeName = name;
+                    factory.isCurrentParentExtension = true;
+                    const extension = factory.extensions.get(factory.parentTypeName);
+                    if (extension) {
+                        if (extension.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                            return false;
+                        }
+                        factory.extractDirectives(node, extension.directives);
+                        return;
+                    }
+                    factory.extensions.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        fields: new Map(),
+                        kind: node.kind,
+                        name: node.name,
+                    });
+                },
+                leave() {
+                    factory.isCurrentParentExtension = false;
+                    factory.parentTypeName = '';
+                },
+            },
+            InputValueDefinition: {
+                enter(node) {
+                    if (!factory.parentTypeName || factory.isChild) {
+                        return;
+                    }
+                    const name = node.name.value;
+                    const parent = factory.isCurrentParentExtension
+                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
+                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
+                    if (parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                        throw new Error(''); // TODO
+                    }
+                    if (parent.fields.has(name)) {
+                        factory.errors.push((0, errors_1.duplicateValueExtensionError)('input', factory.parentTypeName, name));
+                        return;
+                    }
+                    parent.fields.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        name,
+                        node,
+                    });
+                },
+            },
+            InterfaceTypeDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    if (factory.parents.has(name)) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('interface', name));
+                        return false;
+                    }
+                    factory.parentTypeName = name;
+                    factory.parents.set(name, {
+                        description: node.description,
+                        directives: factory.extractDirectives(node, new Map()),
+                        fields: new Map(),
+                        interfaces: (0, utils_1.extractInterfaces)(node, new Set()),
+                        kind: node.kind,
+                        name: node.name,
+                    });
+                },
+                leave() {
+                    factory.parentTypeName = '';
+                },
+            },
+            InterfaceTypeExtension: {
+                enter(node) {
+                    const name = node.name.value;
+                    factory.parentTypeName = name;
+                    factory.isCurrentParentExtension = true;
+                    const extension = factory.extensions.get(factory.parentTypeName);
+                    if (extension) {
+                        if (extension.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
+                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                            return false;
+                        }
+                        factory.extractDirectives(node, extension.directives);
+                        factory.extractUniqueInterfaces(node, extension.interfaces);
+                        return;
+                    }
+                    const interfaces = new Set();
+                    factory.extensions.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        fields: new Map(),
+                        interfaces: (0, utils_1.extractInterfaces)(node, interfaces),
+                        kind: node.kind,
+                        name: node.name,
+                    });
+                },
+                leave() {
+                    factory.isCurrentParentExtension = false;
+                    factory.parentTypeName = '';
+                },
+            },
+            ObjectTypeDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    if (factory.parents.has(name)) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('object', name));
+                        return false;
+                    }
+                    factory.parentTypeName = name;
+                    factory.parents.set(name, {
+                        description: node.description,
+                        directives: factory.extractDirectives(node, new Map()),
+                        fields: new Map(),
+                        interfaces: factory.extractUniqueInterfaces(node, new Set()),
+                        kind: node.kind,
+                        name: node.name,
+                    });
+                    if (!(0, utils_1.isObjectNodeEntity)(node)) {
+                        return;
+                    }
+                    const existingEntityKeyMap = factory.entityMap.get(name);
+                    const { entityKeyMap, errors } = (0, utils_1.getEntityKeyExtractionResults)(node, existingEntityKeyMap || new Map());
+                    if (errors.length > 0) {
+                        factory.errors.push(...errors);
+                    }
+                    if (!existingEntityKeyMap) {
+                        factory.entityMap.set(name, entityKeyMap);
+                    }
+                },
+                leave() {
+                    factory.parentTypeName = '';
+                },
+            },
+            ObjectTypeExtension: {
+                enter(node) {
+                    const name = node.name.value;
+                    factory.parentTypeName = name;
+                    factory.isCurrentParentExtension = true;
+                    const extension = factory.extensions.get(factory.parentTypeName);
+                    if (extension) {
+                        if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                            return false;
+                        }
+                        factory.extractDirectives(node, extension.directives);
+                        factory.extractUniqueInterfaces(node, extension.interfaces);
+                        return;
+                    }
+                    const interfaces = new Set();
+                    factory.extensions.set(name, {
+                        directives: factory.extractDirectives(node, new Map()),
+                        fields: new Map(),
+                        interfaces: (0, utils_1.extractInterfaces)(node, interfaces),
+                        kind: node.kind,
+                        name: node.name,
+                    });
+                    if (!(0, utils_1.isObjectNodeEntity)(node)) {
+                        return;
+                    }
+                    const existingEntityKeyMap = factory.entityMap.get(name);
+                    const { entityKeyMap, errors } = (0, utils_1.getEntityKeyExtractionResults)(node, existingEntityKeyMap || new Map());
+                    if (errors.length > 0) {
+                        factory.errors.push(...errors);
+                    }
+                    if (!existingEntityKeyMap) {
+                        factory.entityMap.set(name, entityKeyMap);
+                    }
+                },
+                leave() {
+                    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;
+                },
+            },
+            ScalarTypeDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    const parent = factory.parents.get(name);
+                    if (parent) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('scalar', name));
+                        return false;
+                    }
+                    factory.parents.set(name, {
+                        description: node.description,
+                        directives: factory.extractDirectives(node, new Map()),
+                        kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
+                        name: node.name,
+                    });
+                },
+            },
+            ScalarTypeExtension: {
+                enter(node) {
+                    const name = node.name.value;
+                    const extension = factory.extensions.get(name);
+                    if (extension) {
+                        if (extension.kind !== graphql_1.Kind.SCALAR_TYPE_EXTENSION) {
+                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                            return false;
+                        }
+                        factory.extractDirectives(node, extension.directives);
+                    }
+                    else {
+                        factory.extensions.set(name, {
+                            directives: factory.extractDirectives(node, new Map()),
+                            kind: node.kind,
+                            name: node.name,
+                        });
+                    }
+                    return false;
+                },
+            },
+            SchemaDefinition: {
+                enter(node) {
+                    // Apollo allows multiple schema definitions
+                    factory.extractDirectives(node, factory.schemaDefinition.directives);
+                    factory.schemaDefinition.description = factory.schemaDefinition.description || node.description;
+                },
+            },
+            SchemaExtension: {
+                enter(node) {
+                    factory.extractDirectives(node, factory.schemaDefinition.directives);
+                },
+            },
+            UnionTypeDefinition: {
+                enter(node) {
+                    const name = node.name.value;
+                    factory.parentTypeName = name;
+                    const parent = factory.parents.get(name);
+                    if (parent) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('union', name));
+                        return false;
+                    }
+                    if (!node.types) {
+                        factory.errors.push((0, errors_1.noDefinedUnionMembersError)(name));
+                        return false;
+                    }
+                    factory.parents.set(name, {
+                        description: node.description,
+                        directives: factory.extractDirectives(node, new Map()),
+                        kind: node.kind,
+                        name: node.name,
+                        types: factory.extractUniqueUnionMembers([...node.types], new Map()),
+                    });
+                },
+                leave() {
+                    factory.parentTypeName = '';
+                },
+            },
+            UnionTypeExtension: {
+                enter(node) {
+                    const name = node.name.value;
+                    const extension = factory.extensions.get(name);
+                    if (!node.types) {
+                        factory.errors.push();
+                        return false;
+                    }
+                    if (extension) {
+                        if (extension.kind !== graphql_1.Kind.UNION_TYPE_EXTENSION) {
+                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                            return false;
+                        }
+                        factory.extractDirectives(node, extension.directives);
+                    }
+                    else {
+                        factory.extensions.set(name, {
+                            directives: factory.extractDirectives(node, new Map()),
+                            kind: node.kind,
+                            name: node.name,
+                            types: factory.extractUniqueUnionMembers([...node.types], new Map()),
+                        });
+                    }
+                    return false;
+                },
+            },
+        });
+        const definitions = [];
+        for (const directiveDefinition of constants_1.BASE_DIRECTIVE_DEFINITIONS) {
+            definitions.push(directiveDefinition);
+        }
+        if (factory.isSubgraphVersionTwo) {
+            for (const directiveDefinition of constants_1.VERSION_TWO_DIRECTIVE_DEFINITIONS) {
+                definitions.push(directiveDefinition);
+                this.allDirectiveDefinitions.set(directiveDefinition.name.value, directiveDefinition);
+            }
+        }
+        for (const directiveDefinition of this.customDirectiveDefinitions.values()) {
+            definitions.push(directiveDefinition);
+        }
+        if (this.schemaDefinition.operationTypes.size > 0) {
+            definitions.push((0, utils_2.schemaContainerToNode)(this, this.schemaDefinition));
+        }
+        const validExtensionOrphans = new Set();
+        const parentsToIgnore = new Set();
+        for (const [typeName, extension] of this.extensions) {
+            const baseType = this.parents.get(typeName);
+            if (!baseType) {
+                if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                    this.errors.push((0, errors_1.noBaseTypeExtensionError)(typeName));
+                }
+                else {
+                    (0, utils_2.validateEntityKeys)(this, typeName, true);
+                    validExtensionOrphans.add(typeName);
+                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, extension));
+                }
+                continue;
+            }
+            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(baseType.kind, extension.kind)) {
+                this.errors.push(new Error(`Extension error:\n Incompatible types: ` +
+                    `"${typeName}" is type "${baseType.kind}", but an extension of the same name is type "${extension.kind}.`));
+                continue;
+            }
+            switch (baseType.kind) {
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    const enumExtension = extension;
+                    for (const [valueName, enumValueDefinitionNode] of enumExtension.values) {
+                        if (!baseType.values.has(valueName)) {
+                            baseType.values.set(valueName, enumValueDefinitionNode);
+                            continue;
+                        }
+                        this.errors.push((0, errors_1.duplicateEnumValueDefinitionError)(valueName, typeName));
+                    }
+                    definitions.push((0, utils_2.enumContainerToNode)(this, baseType, enumExtension));
+                    break;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    const inputExtension = extension;
+                    for (const [fieldName, inputValueDefinitionNode] of inputExtension.fields) {
+                        if (!baseType.fields.has(fieldName)) {
+                            baseType.fields.set(fieldName, inputValueDefinitionNode);
+                            continue;
+                        }
+                        this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, typeName));
+                    }
+                    definitions.push((0, utils_2.inputObjectContainerToNode)(this, baseType, inputExtension));
+                    break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                // intentional fallthrough
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    const objectExtension = extension;
+                    for (const [fieldName, fieldDefinitionNode] of objectExtension.fields) {
+                        if (!baseType.fields.has(fieldName)) {
+                            baseType.fields.set(fieldName, fieldDefinitionNode);
+                            continue;
+                        }
+                        this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, typeName));
+                    }
+                    (0, utils_2.validateEntityKeys)(this, typeName);
+                    this.mergeUniqueInterfaces(objectExtension.interfaces, baseType.interfaces, typeName);
+                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, baseType, objectExtension));
+                    break;
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                    definitions.push((0, utils_2.scalarContainerToNode)(this, baseType, extension));
+                    break;
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                    const unionExtension = extension;
+                    definitions.push((0, utils_2.unionContainerToNode)(this, baseType, unionExtension));
+                    break;
+                default:
+                    throw new Error('Unexpected kind'); // TODO
+            }
+            // At this point, the base type has been dealt with, so it doesn't need to be dealt with again
+            parentsToIgnore.add(typeName);
+        }
+        for (const [typeName, parentContainer] of this.parents) {
+            if (parentsToIgnore.has(typeName)) {
+                continue;
+            }
+            switch (parentContainer.kind) {
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    definitions.push((0, utils_2.enumContainerToNode)(this, parentContainer));
+                    break;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    definitions.push((0, utils_2.inputObjectContainerToNode)(this, parentContainer));
+                    break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                // Intentional fallthrough
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    (0, utils_2.validateEntityKeys)(this, typeName);
+                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, parentContainer));
+                    break;
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                    definitions.push((0, utils_2.scalarContainerToNode)(this, parentContainer));
+                    break;
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                    definitions.push((0, utils_2.unionContainerToNode)(this, parentContainer));
+                    break;
+                default:
+                    throw (0, errors_1.unexpectedKindFatalError)(typeName);
+            }
+        }
+        // Check that explicitly defined operations types are valid objects and that their fields are also valid
+        for (const operationType of Object.values(graphql_1.OperationTypeNode)) {
+            const node = this.schemaDefinition.operationTypes.get(operationType);
+            const defaultTypeName = (0, utils_3.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationType);
+            // If an operation type name was not declared, use the default
+            const operationTypeName = node ? (0, type_merging_1.getNamedTypeForChild)(`schema.${operationType}`, node.type) : defaultTypeName;
+            // If a custom type is used, the default type should not be defined
+            if (operationTypeName !== defaultTypeName &&
+                (this.parents.has(defaultTypeName) || this.extensions.has(defaultTypeName))) {
+                this.errors.push((0, errors_1.invalidRootTypeDefinitionError)(operationType, operationTypeName, defaultTypeName));
+                continue;
+            }
+            const object = this.parents.get(operationTypeName);
+            const extension = this.extensions.get(operationTypeName);
+            // Node is truthy of an operation type was explicitly declared
+            if (node) {
+                // If the type is not defined in the schema, it's always an error
+                if (!object && !extension) {
+                    this.errors.push((0, errors_1.undefinedTypeError)(operationTypeName));
+                    continue;
+                }
+                // Add the explicitly defined type to the map for the federation-factory
+                this.operationTypeNames.set(operationTypeName, operationType);
+            }
+            const containers = [object, extension];
+            for (const container of containers) {
+                if (!container) {
+                    continue;
+                }
+                if (container.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && container.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                    this.errors.push((0, errors_1.operationDefinitionError)(operationTypeName, operationType, container.kind));
+                    continue;
+                }
+                // Operations whose response type is an extension orphan could be valid through a federated graph
+                // However, the field would have to be shareable to ever be valid TODO
+                for (const fieldContainer of container.fields.values()) {
+                    const fieldPath = `${operationTypeName}.${fieldContainer.name}`;
+                    const fieldTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldContainer.node.type);
+                    if (!constants_1.BASE_SCALARS.has(fieldTypeName) &&
+                        !this.parents.has(fieldTypeName) &&
+                        !validExtensionOrphans.has(fieldTypeName)) {
+                        this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
+                    }
+                }
+            }
+        }
+        for (const referencedTypeName of this.referencedTypeNames) {
+            if (!this.parents.has(referencedTypeName) && !this.entityMap.has(referencedTypeName)) {
+                this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
+            }
+        }
+        if (this.errors.length > 0) {
+            return { errors: this.errors };
+        }
+        const newAST = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions,
+        };
+        return {
+            normalizationResult: {
+                isVersionTwo: this.isSubgraphVersionTwo,
+                operationTypes: this.operationTypeNames,
+                subgraphAST: newAST,
+                subgraphString: (0, graphql_1.print)(newAST),
+                schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true }),
+            },
+        };
+    }
+}
+exports.NormalizationFactory = NormalizationFactory;
+//# sourceMappingURL=normalization-factory.js.map