@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/cjs/subgraph/validation/validate-subgraph.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSubgraph = exports.validateSubgraphCore = exports.assertUniqueSubgraphNames = void 0;
+const graphql_1 = require("graphql");
+const type_node_info_js_1 = require("../../graphql/type-node-info.js");
+const federation_js_1 = require("../../specifications/federation.js");
+const link_js_1 = require("../../specifications/link.js");
+const compose_directive_js_1 = require("./rules/elements/compose-directive.js");
+const extends_js_1 = require("./rules/elements/extends.js");
+const external_js_1 = require("./rules/elements/external.js");
+const field_set_js_1 = require("./rules/elements/field-set.js");
+const inaccessible_js_1 = require("./rules/elements/inaccessible.js");
+const key_js_1 = require("./rules/elements/key.js");
+const override_js_1 = require("./rules/elements/override.js");
+const provides_js_1 = require("./rules/elements/provides.js");
+const requires_js_1 = require("./rules/elements/requires.js");
+const shareable_js_1 = require("./rules/elements/shareable.js");
+const tag_js_1 = require("./rules/elements/tag.js");
+const known_argument_names_on_directives_rule_js_1 = require("./rules/known-argument-names-on-directives-rule.js");
+const known_directives_rule_js_1 = require("./rules/known-directives-rule.js");
+const known_federation_directive_rule_js_1 = require("./rules/known-federation-directive-rule.js");
+const known_root_type_rule_js_1 = require("./rules/known-root-type-rule.js");
+const known_type_names_rule_js_1 = require("./rules/known-type-names-rule.js");
+const lone_schema_definition_rule_js_1 = require("./rules/lone-schema-definition-rule.js");
+const provided_arguments_on_directives_rule_js_1 = require("./rules/provided-arguments-on-directives-rule.js");
+const provided_required_arguments_on_directives_rule_js_1 = require("./rules/provided-required-arguments-on-directives-rule.js");
+const query_root_type_inaccessible_rule_js_1 = require("./rules/query-root-type-inaccessible-rule.js");
+const reserved_subgraph_name_rule_js_1 = require("./rules/reserved-subgraph-name-rule.js");
+const root_type_used_rule_js_1 = require("./rules/root-type-used-rule.js");
+const unique_argument_definition_names_rule_js_1 = require("./rules/unique-argument-definition-names-rule.js");
+const unique_argument_names_rule_js_1 = require("./rules/unique-argument-names-rule.js");
+const unique_directive_names_rule_js_1 = require("./rules/unique-directive-names-rule.js");
+const unique_directives_per_location_rule_js_1 = require("./rules/unique-directives-per-location-rule.js");
+const unique_enum_value_names_rule_js_1 = require("./rules/unique-enum-value-names-rule.js");
+const unique_field_definition_names_rule_js_1 = require("./rules/unique-field-definition-names-rule.js");
+const unique_input_field_names_rule_js_1 = require("./rules/unique-input-field-names-rule.js");
+const unique_operation_types_rule_js_1 = require("./rules/unique-operation-types-rule.js");
+const unique_type_names_rule_js_1 = require("./rules/unique-type-names-rule.js");
+const validate_state_js_1 = require("./validate-state.js");
+const validation_context_js_1 = require("./validation-context.js");
+function assertUniqueSubgraphNames(subgraphs) {
+    const names = new Set();
+    for (const subgraph of subgraphs) {
+        if (names.has(subgraph.name)) {
+            throw new Error(`A subgraph named ${subgraph.name} already exists`);
+        }
+        names.add(subgraph.name);
+    }
+}
+exports.assertUniqueSubgraphNames = assertUniqueSubgraphNames;
+function validateSubgraphCore(subgraph) {
+    const extractedLinks = extractLinks(subgraph);
+    if (extractedLinks.errors) {
+        extractedLinks.errors.forEach(error => enrichErrorWithSubgraphName(error, subgraph.name));
+    }
+    return extractedLinks;
+}
+exports.validateSubgraphCore = validateSubgraphCore;
+function validateSubgraph(subgraph, stateBuilder, federation, __internal) {
+    subgraph.typeDefs = cleanSubgraphTypeDefsFromSubgraphSpec(subgraph.typeDefs);
+    const rulesToSkip = __internal?.disableValidationRules ?? [];
+    const typeNodeInfo = new type_node_info_js_1.TypeNodeInfo();
+    const validationContext = (0, validation_context_js_1.createSubgraphValidationContext)(subgraph, federation, typeNodeInfo, stateBuilder);
+    const federationRules = [
+        reserved_subgraph_name_rule_js_1.ReservedSubgraphNameRule,
+        known_federation_directive_rule_js_1.KnownFederationDirectivesRule,
+        field_set_js_1.FieldSetRules,
+        inaccessible_js_1.InaccessibleRules,
+        override_js_1.OverrideRules,
+        extends_js_1.ExtendsRules,
+        query_root_type_inaccessible_rule_js_1.QueryRootTypeInaccessibleRule,
+        known_type_names_rule_js_1.KnownTypeNamesRule,
+        known_root_type_rule_js_1.KnownRootTypeRule,
+        root_type_used_rule_js_1.RootTypeUsedRule,
+        shareable_js_1.ShareableRules,
+        key_js_1.KeyRules,
+        provides_js_1.ProvidesRules,
+        requires_js_1.RequiresRules,
+        external_js_1.ExternalRules,
+        tag_js_1.TagRules,
+        compose_directive_js_1.ComposeDirectiveRules,
+    ];
+    const graphqlRules = [
+        lone_schema_definition_rule_js_1.LoneSchemaDefinitionRule,
+        unique_operation_types_rule_js_1.UniqueOperationTypesRule,
+        unique_type_names_rule_js_1.UniqueTypeNamesRule,
+        unique_enum_value_names_rule_js_1.UniqueEnumValueNamesRule,
+        unique_field_definition_names_rule_js_1.UniqueFieldDefinitionNamesRule,
+        unique_argument_definition_names_rule_js_1.UniqueArgumentDefinitionNamesRule,
+        known_directives_rule_js_1.KnownDirectivesRule,
+        unique_directives_per_location_rule_js_1.UniqueDirectivesPerLocationRule,
+        known_argument_names_on_directives_rule_js_1.KnownArgumentNamesOnDirectivesRule,
+        unique_argument_names_rule_js_1.UniqueArgumentNamesRule,
+        unique_input_field_names_rule_js_1.UniqueInputFieldNamesRule,
+        unique_directive_names_rule_js_1.UniqueDirectiveNamesRule,
+        provided_required_arguments_on_directives_rule_js_1.ProvidedRequiredArgumentsOnDirectivesRule,
+        provided_arguments_on_directives_rule_js_1.ProvidedArgumentsOnDirectivesRule,
+    ];
+    (0, graphql_1.visit)(subgraph.typeDefs, (0, type_node_info_js_1.visitWithTypeNodeInfo)(typeNodeInfo, (0, graphql_1.visitInParallel)([stateBuilder.visitor(typeNodeInfo)].concat(federationRules.map(rule => {
+        if (rulesToSkip.includes(rule.name)) {
+            return {};
+        }
+        return rule(validationContext);
+    })))));
+    const federationDefinitionReplacements = validationContext.collectFederationDefinitionReplacements();
+    const fullTypeDefs = (0, graphql_1.concatAST)([
+        {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: validationContext
+                .getAvailableFederationTypeAndDirectiveDefinitions()
+                .filter(def => !federationDefinitionReplacements.has(def.name.value)),
+        },
+        validationContext.satisfiesVersionRange('> v1.0') && !stateBuilder.state.specs.link
+            ?
+                (0, graphql_1.parse)(`
+            scalar Import
+            enum Purpose {
+              EXECUTION
+              SECURITY
+            }
+
+            directive @link(
+              url: String
+              as: String
+              for: link__Purpose
+              import: [link__Import]
+            ) repeatable on SCHEMA
+
+            scalar link__Import
+
+            enum link__Purpose {
+              """
+              \`SECURITY\` features provide metadata necessary to securely resolve fields.
+              """
+              SECURITY
+
+              """
+              \`EXECUTION\` features provide metadata necessary for operation execution.
+              """
+              EXECUTION
+            }
+          `)
+            : null,
+        subgraph.typeDefs,
+    ].filter(onlyDocumentNode));
+    const subgraphStateErrors = (0, validate_state_js_1.validateSubgraphState)(stateBuilder.state);
+    const simpleValidationContext = (0, validation_context_js_1.createSimpleValidationContext)(fullTypeDefs, typeNodeInfo);
+    (0, graphql_1.visit)(fullTypeDefs, (0, graphql_1.visitInParallel)(graphqlRules.map(rule => {
+        if (rulesToSkip.includes(rule.name)) {
+            return {};
+        }
+        return rule(simpleValidationContext);
+    })));
+    return validationContext
+        .collectReportedErrors()
+        .concat(validationContext.collectUnusedExternal().map(coordinate => enrichErrorWithSubgraphName(new graphql_1.GraphQLError(`Field "${coordinate}" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).`, {
+        extensions: {
+            code: 'EXTERNAL_UNUSED',
+        },
+    }), subgraph.name)))
+        .concat(simpleValidationContext.collectReportedErrors())
+        .concat(subgraphStateErrors)
+        .map(error => enrichErrorWithSubgraphName(error, subgraph.name));
+}
+exports.validateSubgraph = validateSubgraph;
+function enrichErrorWithSubgraphName(error, subgraphName) {
+    if (error.extensions.subgraphName) {
+        return error;
+    }
+    error.message = `[${subgraphName}] ${error.message}`;
+    error.extensions.subgraphName = subgraphName;
+    return error;
+}
+const availableFeatures = {
+    link: ['v1.0'],
+    tag: ['v0.1', 'v0.2'],
+    kotlin_labs: ['v0.1', 'v0.2'],
+    join: ['v0.1', 'v0.2', 'v0.3'],
+    inaccessible: ['v0.1', 'v0.2'],
+    core: ['v0.1', 'v0.2'],
+};
+function extractLinks(subgraph) {
+    const schemaNodes = subgraph.typeDefs.definitions.filter(isSchemaDefinitionOrExtensionNode);
+    if (schemaNodes.length === 0) {
+        return {
+            links: [],
+        };
+    }
+    const linkDirectives = [];
+    for (const schemaNode of schemaNodes) {
+        if (schemaNode.directives?.length) {
+            for (const directiveNode of schemaNode.directives) {
+                if (directiveNode.name.value === 'link') {
+                    linkDirectives.push(directiveNode);
+                }
+            }
+        }
+    }
+    if (!linkDirectives) {
+        return {
+            links: [],
+        };
+    }
+    const errors = [];
+    const links = [];
+    const identities = new Set();
+    const reportedAsDuplicate = new Set();
+    for (let i = 0; i < linkDirectives.length; i++) {
+        const linkDirective = linkDirectives[i];
+        try {
+            const link = (0, link_js_1.parseLinkDirective)(linkDirective);
+            if (!link) {
+                continue;
+            }
+            if (identities.has(link.identity) && !reportedAsDuplicate.has(link.identity)) {
+                errors.push(new graphql_1.GraphQLError(`Duplicate inclusion of feature ${link.identity}`, {
+                    extensions: {
+                        code: 'INVALID_LINK_DIRECTIVE_USAGE',
+                    },
+                }));
+                reportedAsDuplicate.add(link.identity);
+            }
+            identities.add(link.identity);
+            if (link.version && !/^v\d+\.\d+/.test(link.version)) {
+                errors.push(new graphql_1.GraphQLError(`Expected a version string (of the form v1.2), got ${link.version}`, {
+                    extensions: {
+                        code: 'INVALID_LINK_IDENTIFIER',
+                    },
+                }));
+                continue;
+            }
+            if (!link.name) {
+                errors.push(new graphql_1.GraphQLError(`Missing path in feature url '${link.identity}'`, {
+                    extensions: {
+                        code: 'INVALID_LINK_IDENTIFIER',
+                    },
+                }));
+                continue;
+            }
+            if (link.identity.startsWith('https://specs.apollo.dev/')) {
+                if (link.name === 'federation') {
+                    if (!link.version) {
+                        errors.push(new graphql_1.GraphQLError(`Missing version in feature url '${link.identity}'`, {
+                            extensions: {
+                                code: 'TODO',
+                            },
+                        }));
+                        continue;
+                    }
+                    const spec = (0, federation_js_1.createSpecSchema)(link.version);
+                    const availableElements = new Set(spec.directives.map(d => d.name.value).concat(spec.types.map(t => t.name.value)));
+                    let pushedError = false;
+                    for (const im of link.imports) {
+                        if (!availableElements.has(im.name.replace(/^@/, ''))) {
+                            pushedError = true;
+                            errors.push(new graphql_1.GraphQLError(`Cannot import unknown element "${im.name}".`, {
+                                extensions: {
+                                    code: 'INVALID_LINK_DIRECTIVE_USAGE',
+                                },
+                            }));
+                        }
+                    }
+                    if (pushedError) {
+                        continue;
+                    }
+                }
+                else if (link.version && availableFeatures[link.name]) {
+                    if (!availableFeatures[link.name].includes(link.version)) {
+                        errors.push(new graphql_1.GraphQLError(`Schema uses unknown version ${link.version} of the ${link.name} spec`, {
+                            extensions: {
+                                code: 'UNKNOWN_LINK_VERSION',
+                            },
+                        }));
+                        continue;
+                    }
+                }
+            }
+            links.push(link);
+        }
+        catch (error) {
+            errors.push(error instanceof graphql_1.GraphQLError ? error : new graphql_1.GraphQLError(String(error)));
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            errors,
+        };
+    }
+    return {
+        links,
+    };
+}
+function isSchemaDefinitionOrExtensionNode(node) {
+    return (node.kind === graphql_1.Kind.SCHEMA_DEFINITION || node.kind === graphql_1.Kind.SCHEMA_EXTENSION);
+}
+function onlyDocumentNode(item) {
+    return item != null;
+}
+function cleanSubgraphTypeDefsFromSubgraphSpec(typeDefs) {
+    let queryTypes = [];
+    typeDefs.definitions = typeDefs.definitions.filter(def => {
+        if (def.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION && def.name.value === '_Any') {
+            return false;
+        }
+        if (def.kind === graphql_1.Kind.UNION_TYPE_DEFINITION && def.name.value === '_Entity') {
+            return false;
+        }
+        if (def.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION && def.name.value === '_Service') {
+            return false;
+        }
+        if ((def.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || def.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) &&
+            def.name.value === 'Query') {
+            queryTypes.push(def);
+        }
+        return true;
+    });
+    if (queryTypes.length > 0) {
+        for (const queryType of queryTypes) {
+            queryType.fields =
+                queryType.fields?.filter(field => {
+                    if (field.name.value === '_service' || field.name.value === '_entities') {
+                        return false;
+                    }
+                    return true;
+                }) ?? [];
+        }
+    }
+    return typeDefs;
+}

package/cjs/subgraph/validation/validation-context.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubgraphValidationContext = exports.createSimpleValidationContext = void 0;
+const graphql_1 = require("graphql");
+const federation_js_1 = require("../../specifications/federation.js");
+const state_js_1 = require("../../utils/state.js");
+const state_js_2 = require("../state.js");
+function createSimpleValidationContext(typeDefs, typeNodeInfo) {
+    let reportedErrors = [];
+    const directiveDefinitionMap = new Map();
+    const typeDefinitionMap = new Map();
+    for (const definition of typeDefs.definitions) {
+        if (definition.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) {
+            directiveDefinitionMap.set(definition.name.value, definition);
+        }
+        else if ('name' in definition && definition.name && definition.name.kind === graphql_1.Kind.NAME) {
+            typeDefinitionMap.set(definition.name.value, {
+                name: definition.name,
+                kind: definition.kind,
+            });
+        }
+    }
+    return {
+        getDocument() {
+            return typeDefs;
+        },
+        getKnownDirectiveDefinition(name) {
+            return directiveDefinitionMap.get(name);
+        },
+        getKnownTypeDefinition(name) {
+            return typeDefinitionMap.get(name);
+        },
+        getSchemaCoordinate(ancestors) {
+            let coordinate = '';
+            for (let i = 0; i < ancestors.length; i++) {
+                const ancestor = ancestors[i];
+                if ('kind' in ancestor && ancestor.kind !== graphql_1.Kind.DOCUMENT) {
+                    const name = ancestor.kind === graphql_1.Kind.SCHEMA_DEFINITION || ancestor.kind === graphql_1.Kind.SCHEMA_EXTENSION
+                        ? 'schema'
+                        : 'name' in ancestor && ancestor.name
+                            ? ancestor.name.value
+                            : '';
+                    if (coordinate.length > 0) {
+                        coordinate = coordinate + '.' + name;
+                    }
+                    else {
+                        coordinate = name;
+                    }
+                }
+            }
+            return coordinate;
+        },
+        reportError(error) {
+            reportedErrors.push(error);
+        },
+        collectReportedErrors() {
+            const errors = reportedErrors;
+            reportedErrors = [];
+            return errors;
+        },
+    };
+}
+exports.createSimpleValidationContext = createSimpleValidationContext;
+function createSubgraphValidationContext(subgraph, federation, typeNodeInfo, stateBuilder) {
+    const { version, imports } = federation;
+    const availableSpec = (0, federation_js_1.createSpecSchema)(version, imports);
+    const knownSpec = (0, federation_js_1.createSpecSchema)(version);
+    const knownSubgraphEntities = new Map(subgraph.typeDefs.definitions.filter(def => def.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+        def.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION ||
+        def.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+        def.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION).map(def => [def.name.value, def]));
+    const knownSubgraphDirectiveDefinitions = new Map(subgraph.typeDefs.definitions.filter(def => def.kind === graphql_1.Kind.DIRECTIVE_DEFINITION).map(def => [def.name.value, def]));
+    const leafTypeNames = new Set(graphql_1.specifiedScalarTypes.map(type => type.name));
+    for (const def of subgraph.typeDefs.definitions) {
+        if (def.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
+            def.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION ||
+            def.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION ||
+            def.kind === graphql_1.Kind.ENUM_TYPE_EXTENSION) {
+            leafTypeNames.add(def.name.value);
+        }
+    }
+    let reportedErrors = [];
+    const markedAsExternal = new Set();
+    const markedAsUsed = new Set();
+    const markedAsKeyField = new Set();
+    const overwrittenFederationDefinitionNames = new Set();
+    const directiveAlternativeNamesMap = new Map();
+    for (const specDirective of availableSpec.directives) {
+        const isFederationPrefixed = specDirective.name.value.startsWith('federation__');
+        if (isFederationPrefixed) {
+            const normalizedName = specDirective.name.value.replace('federation__', '');
+            const setOfNames = directiveAlternativeNamesMap.get(normalizedName);
+            if (!setOfNames) {
+                directiveAlternativeNamesMap.set(normalizedName, new Set([specDirective.name.value]));
+            }
+        }
+        else {
+            const { alias } = imports.find(i => i.name.replace(/^@/, '') === specDirective.name.value) ?? {
+                alias: undefined,
+            };
+            let setOfNames = directiveAlternativeNamesMap.get(specDirective.name.value);
+            if (!setOfNames) {
+                directiveAlternativeNamesMap.set(specDirective.name.value, new Set());
+                setOfNames = directiveAlternativeNamesMap.get(specDirective.name.value);
+            }
+            setOfNames.add(alias ? alias.replace(/^@/, '') : specDirective.name.value);
+        }
+    }
+    const typeAlternativeNamesMap = new Map();
+    for (const specType of availableSpec.types) {
+        const isFederationPrefixed = specType.name.value.startsWith('federation__');
+        if (isFederationPrefixed) {
+            const normalizedName = specType.name.value.replace('federation__', '');
+            const setOfNames = typeAlternativeNamesMap.get(normalizedName);
+            if (!setOfNames) {
+                typeAlternativeNamesMap.set(normalizedName, new Set([specType.name.value]));
+            }
+        }
+        else {
+            const { alias } = imports.find(i => i.name === specType.name.value) ?? {
+                alias: undefined,
+            };
+            let setOfNames = typeAlternativeNamesMap.get(specType.name.value);
+            if (!setOfNames) {
+                typeAlternativeNamesMap.set(specType.name.value, new Set());
+                setOfNames = typeAlternativeNamesMap.get(specType.name.value);
+            }
+            setOfNames.add(alias ? alias : specType.name.value);
+        }
+    }
+    const importedTypesSet = new Set(availableSpec.types.map(t => t.name.value));
+    if (importedTypesSet.size) {
+        subgraph.typeDefs.definitions.forEach(def => {
+            if ('name' in def && def.name && importedTypesSet.has(def.name.value)) {
+                overwrittenFederationDefinitionNames.add(def.name.value);
+            }
+        });
+    }
+    return {
+        stateBuilder,
+        isAvailableFederationType(name) {
+            const alternativeNames = typeAlternativeNamesMap.get(name);
+            if (alternativeNames) {
+                return alternativeNames.has(name);
+            }
+            return false;
+        },
+        isAvailableFederationDirective(specDirectiveName, directiveNode) {
+            const alternativeNames = directiveAlternativeNamesMap.get(specDirectiveName);
+            if (alternativeNames) {
+                return alternativeNames.has(typeof directiveNode.name === 'string' ? directiveNode.name : directiveNode.name.value);
+            }
+            return false;
+        },
+        satisfiesVersionRange(range) {
+            const [sign, ver] = range.split(' ');
+            const versionInRange = parseFloat(ver.replace('v', ''));
+            const detectedVersion = parseFloat(version.replace('v', ''));
+            if (sign === '<') {
+                return detectedVersion < versionInRange;
+            }
+            if (sign === '>') {
+                return detectedVersion > versionInRange;
+            }
+            return detectedVersion >= versionInRange;
+        },
+        getKnownFederationDirectives() {
+            return knownSpec.directives;
+        },
+        getAvailableFederationDirectives() {
+            return availableSpec.directives;
+        },
+        isLeafType(typeName) {
+            return leafTypeNames.has(typeName);
+        },
+        getSubgraphObjectOrInterfaceTypes() {
+            return knownSubgraphEntities;
+        },
+        getSubgraphDirectiveDefinitions() {
+            return knownSubgraphDirectiveDefinitions;
+        },
+        getAvailableFederationTypeAndDirectiveDefinitions() {
+            return [].concat(availableSpec.directives.map(d => {
+                const alias = imports.find(i => i.name.replace(/^@/, '') === d.name.value)?.alias;
+                if (alias) {
+                    d.name.value = alias.replace(/^@/, '');
+                }
+                return d;
+            }), availableSpec.types.map(t => {
+                const alias = imports.find(i => i.name === t.name.value)?.alias;
+                if (alias) {
+                    t.name.value = alias;
+                }
+                return t;
+            }));
+        },
+        typeNodeInfo,
+        getDocument() {
+            return subgraph.typeDefs;
+        },
+        getSubgraphName() {
+            return subgraph.name;
+        },
+        getSubgraphId() {
+            return subgraph.id;
+        },
+        markAsExternal(coordinate) {
+            markedAsExternal.add(coordinate);
+        },
+        markAsUsed(reason, kind, typeName, fieldName) {
+            if (!fieldName.startsWith('__') && !typeName.startsWith('__') && reason === 'fields') {
+                switch (kind) {
+                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    case graphql_1.Kind.OBJECT_TYPE_EXTENSION: {
+                        stateBuilder.objectType.field.setUsed(typeName, fieldName);
+                        break;
+                    }
+                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                    case graphql_1.Kind.INTERFACE_TYPE_EXTENSION: {
+                        stateBuilder.interfaceType.field.setUsed(typeName, fieldName);
+                        break;
+                    }
+                }
+            }
+            markedAsUsed.add(`${typeName}.${fieldName}`);
+        },
+        markAsKeyField(coordinate) {
+            markedAsKeyField.add(coordinate);
+        },
+        markAsFederationDefinitionReplacement(name) {
+            overwrittenFederationDefinitionNames.add(name);
+        },
+        collectFederationDefinitionReplacements() {
+            return overwrittenFederationDefinitionNames;
+        },
+        collectUnusedExternal() {
+            if (version === 'v1.0') {
+                return Array.from(markedAsExternal).filter(c => !markedAsUsed.has(c) && markedAsKeyField.has(c));
+            }
+            const unused = Array.from(markedAsExternal).filter(c => !markedAsUsed.has(c));
+            return unused.filter(coordinate => {
+                const [typeName, fieldName] = coordinate.split('.');
+                const typeDef = stateBuilder.state.types.get(typeName);
+                if (typeDef && typeDef.kind === state_js_2.TypeKind.OBJECT) {
+                    const fieldDef = typeDef.fields.get(fieldName);
+                    if (fieldDef) {
+                        const outputTypeName = (0, state_js_1.stripTypeModifiers)(fieldDef.type);
+                        const outputType = stateBuilder.state.types.get(outputTypeName);
+                        if (outputType?.kind === state_js_2.TypeKind.OBJECT && outputType.shareable) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            });
+        },
+        reportError(error) {
+            reportedErrors.push(error);
+        },
+        collectReportedErrors() {
+            const errors = reportedErrors;
+            reportedErrors = [];
+            return errors;
+        },
+    };
+}
+exports.createSubgraphValidationContext = createSubgraphValidationContext;