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

package/esm/subgraph/validation/rules/elements/compose-directive.js

@@ -0,0 +1,37 @@
+import { GraphQLError, Kind } from 'graphql';
+import { isDirectiveDefinitionNode, validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function ComposeDirectiveRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'composeDirective', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('composeDirective', node)) {
+                return;
+            }
+            if (!context.satisfiesVersionRange('>= v2.1')) {
+                return;
+            }
+            const nameArg = node.arguments?.find(arg => arg.name.value === 'name');
+            if (!nameArg || nameArg.value.kind !== Kind.STRING) {
+                return;
+            }
+            const name = nameArg.value.value.replace(/^@/, '');
+            const definedDirectives = context.getDocument().definitions.filter(isDirectiveDefinitionNode);
+            const matchingDirective = definedDirectives.find(directive => directive.name.value === name);
+            if (matchingDirective) {
+                context.stateBuilder.directive.setComposed(matchingDirective.name.value);
+                context.stateBuilder.composedDirectives.add(matchingDirective.name.value);
+            }
+            else {
+                context.reportError(new GraphQLError(`Could not find matching directive definition for argument to @composeDirective "@${name}" in subgraph "${context.getSubgraphName()}".`, {
+                    nodes: node,
+                    extensions: {
+                        code: 'DIRECTIVE_COMPOSITION_ERROR',
+                        subgraphName: context.getSubgraphName(),
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/extends.js

@@ -0,0 +1,30 @@
+import { Kind } from 'graphql';
+import { validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function ExtendsRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'extends', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('extends', node)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!typeDef ||
+                !(typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                    typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION)) {
+                return;
+            }
+            if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION) {
+                context.stateBuilder.objectType.setExtension(typeDef.name.value, '@extends');
+            }
+            else {
+                context.stateBuilder.interfaceType.setExtension(typeDef.name.value);
+            }
+            const fields = typeDef.fields;
+            for (const field of fields ?? []) {
+                context.markAsUsed('@extends', typeDef.kind, typeDef.name.value, field.name.value);
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/external.js

@@ -0,0 +1,53 @@
+import { GraphQLError, Kind } from 'graphql';
+import { print } from '../../../../graphql/printer.js';
+import { validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function ExternalRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'external', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('external', node)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            const fieldDef = context.typeNodeInfo.getFieldDef();
+            if (!typeDef ||
+                !(typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                    typeDef.kind === Kind.OBJECT_TYPE_EXTENSION)) {
+                return;
+            }
+            const fieldDefinitions = [];
+            if (fieldDef) {
+                if (fieldDef.kind !== Kind.FIELD_DEFINITION) {
+                    return;
+                }
+                fieldDefinitions.push(fieldDef);
+            }
+            else {
+                const fields = typeDef.fields;
+                if (fields) {
+                    if (context.satisfiesVersionRange('>= v2.0')) {
+                        fieldDefinitions.push(...fields);
+                    }
+                }
+            }
+            for (const field of fieldDefinitions) {
+                context.markAsExternal(`${typeDef.name.value}.${field.name.value}`);
+                const conflictingDirectives = field.directives?.filter(directive => context.isAvailableFederationDirective('tag', directive) ||
+                    context.isAvailableFederationDirective('inaccessible', directive));
+                if (conflictingDirectives?.length && context.satisfiesVersionRange('>= v2.0')) {
+                    for (const directive of conflictingDirectives) {
+                        context.reportError(new GraphQLError(`Cannot apply merged directive ${print(directive).trim()} to external field "${typeDef.name.value}.${field.name.value}"`, {
+                            nodes: node,
+                            extensions: { code: 'MERGED_DIRECTIVE_APPLICATION_ON_EXTERNAL' },
+                        }));
+                    }
+                }
+                else {
+                    context.stateBuilder.objectType.field.setExternal(typeDef.name.value, field.name.value);
+                }
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/field-set.js

@@ -0,0 +1,33 @@
+import { GraphQLError } from 'graphql';
+export function FieldSetRules(context) {
+    function validateFieldSet(node, receivedType) {
+        if (node.name.value === 'FieldSet' && context.isAvailableFederationType('FieldSet')) {
+            context.reportError(new GraphQLError(`Invalid definition for type FieldSet: FieldSet should be a ScalarType but is defined as a ${receivedType}`, {
+                nodes: node,
+                extensions: { code: 'TYPE_DEFINITION_INVALID' },
+            }));
+        }
+    }
+    return {
+        ScalarTypeDefinition(node) {
+            if (node.name.value === 'FieldSet' && context.isAvailableFederationType('FieldSet')) {
+                context.markAsFederationDefinitionReplacement('FieldSet');
+            }
+        },
+        ObjectTypeDefinition(node) {
+            validateFieldSet(node, 'ObjectType');
+        },
+        InterfaceTypeDefinition(node) {
+            validateFieldSet(node, 'InterfaceType');
+        },
+        UnionTypeDefinition(node) {
+            validateFieldSet(node, 'UnionType');
+        },
+        EnumTypeDefinition(node) {
+            validateFieldSet(node, 'EnumType');
+        },
+        InputObjectTypeDefinition(node) {
+            validateFieldSet(node, 'InputObjectType');
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/inaccessible.js

@@ -0,0 +1,108 @@
+import { Kind } from 'graphql';
+import { validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function InaccessibleRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'inaccessible', context);
+        },
+        Directive(node, _key, _parent, paths, ancestors) {
+            if (!context.isAvailableFederationDirective('inaccessible', node)) {
+                return;
+            }
+            const directivesKeyAt = paths.findIndex(path => path === 'directives');
+            if (directivesKeyAt === -1) {
+                throw new Error('Could not find "directives" key in ancestors');
+            }
+            const parent = ancestors[directivesKeyAt];
+            if (!parent) {
+                throw new Error('Could not find the node annotated with @inaccessible');
+            }
+            if (Array.isArray(parent)) {
+                throw new Error('Expected parent to be a single node');
+            }
+            if (!('kind' in parent)) {
+                throw new Error('Expected parent to be a node');
+            }
+            switch (parent.kind) {
+                case Kind.SCALAR_TYPE_DEFINITION:
+                case Kind.SCALAR_TYPE_EXTENSION:
+                    context.stateBuilder.scalarType.setInaccessible(parent.name.value);
+                    break;
+                case Kind.FIELD_DEFINITION: {
+                    const typeDef = context.typeNodeInfo.getTypeDef();
+                    if (!typeDef) {
+                        throw new Error('Could not find the parent type of the field annotated with @inaccessible');
+                    }
+                    if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+                        context.stateBuilder.interfaceType.field.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    else {
+                        context.stateBuilder.objectType.field.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    break;
+                }
+                case Kind.INPUT_VALUE_DEFINITION: {
+                    const typeDef = context.typeNodeInfo.getTypeDef();
+                    if (!typeDef) {
+                        throw new Error('Could not find the parent type of the field annotated with @inaccessible');
+                    }
+                    if (typeDef.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                        context.stateBuilder.inputObjectType.field.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    else if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
+                        const fieldDef = context.typeNodeInfo.getFieldDef();
+                        if (!fieldDef) {
+                            throw new Error('Could not find the parent field of the input value annotated with @inaccessible');
+                        }
+                        context.stateBuilder.objectType.field.arg.setInaccessible(typeDef.name.value, fieldDef.name.value, parent.name.value);
+                    }
+                    else if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+                        const fieldDef = context.typeNodeInfo.getFieldDef();
+                        if (!fieldDef) {
+                            throw new Error('Could not find the parent field of the input value annotated with @inaccessible');
+                        }
+                        context.stateBuilder.interfaceType.field.arg.setInaccessible(typeDef.name.value, fieldDef.name.value, parent.name.value);
+                    }
+                    else if (typeDef.kind === Kind.DIRECTIVE_DEFINITION) {
+                        context.stateBuilder.directive.arg.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    break;
+                }
+                case Kind.OBJECT_TYPE_DEFINITION:
+                case Kind.OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.objectType.setInaccessible(parent.name.value);
+                    break;
+                case Kind.INTERFACE_TYPE_DEFINITION:
+                case Kind.INTERFACE_TYPE_EXTENSION:
+                    context.stateBuilder.interfaceType.setInaccessible(parent.name.value);
+                    break;
+                case Kind.UNION_TYPE_DEFINITION:
+                case Kind.UNION_TYPE_EXTENSION:
+                    context.stateBuilder.unionType.setInaccessible(parent.name.value);
+                    break;
+                case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.inputObjectType.setInaccessible(parent.name.value);
+                    break;
+                case Kind.ENUM_TYPE_DEFINITION:
+                case Kind.ENUM_TYPE_EXTENSION:
+                    context.stateBuilder.enumType.setInaccessible(parent.name.value);
+                    break;
+                case Kind.ENUM_VALUE_DEFINITION: {
+                    const enumValue = parent.name.value;
+                    const typeDef = context.typeNodeInfo.getTypeDef();
+                    if (!typeDef) {
+                        throw new Error('Could not find the parent type of the enum value annotated with @inaccessible');
+                    }
+                    context.stateBuilder.enumType.value.setInaccessible(typeDef.name.value, enumValue);
+                    break;
+                }
+            }
+            context.stateBuilder.markSpecAsUsed('inaccessible');
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/key.js

@@ -0,0 +1,144 @@
+import { GraphQLError, Kind } from 'graphql';
+import { print } from '../../../../graphql/printer.js';
+import { getFieldsArgument, parseFields, validateDirectiveAgainstOriginal, visitFields, } from '../../../helpers.js';
+export function KeyRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'key', context);
+        },
+        Directive(directiveNode) {
+            if (!context.isAvailableFederationDirective('key', directiveNode)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!typeDef) {
+                return;
+            }
+            const typeCoordinate = typeDef.name.value;
+            const usedOnInterface = typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION;
+            const usedOnObject = typeDef.kind === Kind.OBJECT_TYPE_DEFINITION || typeDef.kind === Kind.OBJECT_TYPE_EXTENSION;
+            if (!usedOnObject && !usedOnInterface) {
+                return;
+            }
+            if (usedOnInterface &&
+                context.satisfiesVersionRange('> v1.0') &&
+                context.satisfiesVersionRange('< v2.3')) {
+                context.reportError(new GraphQLError(`Cannot use @key on interface "${typeCoordinate}": @key is not yet supported on interfaces`, {
+                    nodes: directiveNode,
+                    extensions: { code: 'KEY_UNSUPPORTED_ON_INTERFACE' },
+                }));
+                return;
+            }
+            const fieldsArg = getFieldsArgument(directiveNode);
+            if (!fieldsArg) {
+                return;
+            }
+            const printedFieldsValue = print(fieldsArg.value);
+            if (fieldsArg.value.kind !== Kind.STRING) {
+                context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): Invalid value for argument "fields": must be a string.`, {
+                    nodes: directiveNode,
+                    extensions: {
+                        code: 'KEY_INVALID_FIELDS_TYPE',
+                    },
+                }));
+                return;
+            }
+            let selectionSet;
+            try {
+                selectionSet = parseFields(fieldsArg.value.value);
+            }
+            catch (error) {
+                if (error instanceof GraphQLError) {
+                    context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): ${error.message}`, {
+                        nodes: directiveNode,
+                        extensions: {
+                            code: 'KEY_INVALID_FIELDS',
+                        },
+                    }));
+                    return;
+                }
+                throw error;
+            }
+            if (!selectionSet) {
+                return;
+            }
+            const knownObjectsAndInterfaces = context.getSubgraphObjectOrInterfaceTypes();
+            let isValid = true;
+            const fieldsUsedInKey = new Set();
+            visitFields({
+                context,
+                selectionSet,
+                typeDefinition: typeDef,
+                interceptField(info) {
+                    if (info.typeDefinition.name.value === typeDef.name.value) {
+                        fieldsUsedInKey.add(info.fieldName);
+                        context.markAsKeyField(`${info.typeDefinition.name}.${info.fieldName}`);
+                    }
+                },
+                interceptUnknownField(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): Cannot query field "${info.fieldName}" on type "${info.typeDefinition.name.value}" (the field should either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).`, { nodes: directiveNode, extensions: { code: 'KEY_INVALID_FIELDS' } }));
+                },
+                interceptDirective(info) {
+                    isValid = false;
+                    if (info.isKnown) {
+                        context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): cannot have directive applications in the @key(fields:) argument but found @${info.directiveName}.`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'KEY_DIRECTIVE_IN_FIELDS_ARG' },
+                        }));
+                    }
+                    else {
+                        context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): Unknown directive "@${info.directiveName}"`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'KEY_INVALID_FIELDS' },
+                        }));
+                    }
+                },
+                interceptArguments(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): field ${info.typeDefinition.name.value}.${info.fieldName} cannot be included because it has arguments (fields with argument are not allowed in @key)`, { nodes: directiveNode, extensions: { code: 'KEY_FIELDS_HAS_ARGS' } }));
+                },
+                interceptInterfaceType(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" is a Interface type which is not allowed in @key`, { nodes: directiveNode, extensions: { code: 'KEY_FIELDS_SELECT_INVALID_TYPE' } }));
+                },
+            });
+            if (usedOnInterface) {
+                const expectedFieldsValue = fieldsArg.value.value;
+                knownObjectsAndInterfaces.forEach(def => {
+                    if (def.interfaces?.some(i => i.name.value === typeDef.name.value)) {
+                        let shouldError = true;
+                        const keyDirectives = def.directives?.filter(d => context.isAvailableFederationDirective('key', d));
+                        if (!!keyDirectives?.length) {
+                            for (const keyDirective of keyDirectives) {
+                                const fieldsArg = getFieldsArgument(keyDirective);
+                                if (fieldsArg &&
+                                    fieldsArg.value.kind === Kind.STRING &&
+                                    fieldsArg.value.value === expectedFieldsValue) {
+                                    shouldError = false;
+                                }
+                            }
+                        }
+                        if (shouldError && context.satisfiesVersionRange('> v1.0')) {
+                            isValid = false;
+                            context.reportError(new GraphQLError(`Key @key(fields: ${printedFieldsValue}) on interface type "${typeDef.name.value}" is missing on implementation type "${def.name.value}".`, {
+                                nodes: directiveNode,
+                                extensions: { code: 'INTERFACE_KEY_NOT_ON_IMPLEMENTATION' },
+                            }));
+                        }
+                    }
+                });
+            }
+            if (isValid) {
+                const resolvableArgValue = directiveNode.arguments?.find(arg => arg.name.value === 'resolvable' && arg.value.kind === Kind.BOOLEAN)?.value;
+                const resolvable = resolvableArgValue?.value ?? true;
+                if (usedOnInterface) {
+                    context.stateBuilder.interfaceType.setKey(typeDef.name.value, fieldsArg.value.value, fieldsUsedInKey, resolvable);
+                    return;
+                }
+                context.stateBuilder.objectType.setKey(typeDef.name.value, fieldsArg.value.value, fieldsUsedInKey, resolvable);
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/override.js

@@ -0,0 +1,52 @@
+import { GraphQLError, Kind } from 'graphql';
+import { validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function OverrideRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'override', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('override', node)) {
+                return;
+            }
+            const fieldDef = context.typeNodeInfo.getFieldDef();
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!fieldDef || !typeDef) {
+                return;
+            }
+            if ((typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) &&
+                context.satisfiesVersionRange('>= v2.3')) {
+                context.reportError(new GraphQLError(`@override cannot be used on field "${typeDef.name.value}.${fieldDef.name.value}" on subgraph "${context.getSubgraphName()}": @override is not supported on interface type fields.`, { nodes: node, extensions: { code: 'OVERRIDE_ON_INTERFACE' } }));
+                return;
+            }
+            const fromArg = node.arguments?.find(arg => arg.name.value === 'from');
+            if (!fromArg || fromArg.value.kind !== Kind.STRING) {
+                return;
+            }
+            if (!typeDef) {
+                throw new Error('Parent type not found but `@override` directive is present on a field.');
+            }
+            const conflictingDirectives = fieldDef.directives?.filter(directive => context.isAvailableFederationDirective('external', directive));
+            if (conflictingDirectives?.length) {
+                conflictingDirectives.forEach(directive => {
+                    context.reportError(new GraphQLError(`@override cannot be used on field "${typeDef.name.value}.${fieldDef.name.value}" on subgraph "${context.getSubgraphName()}" since "${typeDef.name.value}.${fieldDef.name.value}" on "${context.getSubgraphName()}" is marked with directive "@${directive.name.value}"`, {
+                        extensions: {
+                            code: 'OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE',
+                        },
+                    }));
+                });
+            }
+            if (fromArg.value.value === context.getSubgraphName()) {
+                context.reportError(new GraphQLError(`Source and destination subgraphs "${fromArg.value.value}" are the same for overridden field "${typeDef.name.value}.${fieldDef.name.value}"`, { nodes: node, extensions: { code: 'OVERRIDE_FROM_SELF_ERROR' } }));
+            }
+            if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
+                context.stateBuilder.objectType.field.setOverride(typeDef.name.value, fieldDef.name.value, fromArg.value.value);
+            }
+            else {
+                context.stateBuilder.interfaceType.field.setOverride(typeDef.name.value, fieldDef.name.value, fromArg.value.value);
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/elements/provides.js

@@ -0,0 +1,169 @@
+import { GraphQLError, Kind } from 'graphql';
+import { print } from '../../../../graphql/printer.js';
+import { getFieldsArgument, namedTypeFromTypeNode, parseFields, validateDirectiveAgainstOriginal, visitFields, } from '../../../helpers.js';
+export function ProvidesRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'provides', context);
+        },
+        Directive(directiveNode) {
+            if (!context.isAvailableFederationDirective('provides', directiveNode)) {
+                return;
+            }
+            const annotatedType = context.typeNodeInfo.getTypeDef();
+            const annotatedField = context.typeNodeInfo.getFieldDef();
+            if (!annotatedType || !annotatedField) {
+                return;
+            }
+            const fieldCoordinate = `${annotatedType.name.value}.${annotatedField.name.value}`;
+            const usedOnInterface = annotatedType.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                annotatedType?.kind === Kind.INTERFACE_TYPE_EXTENSION;
+            const knownObjectsAndInterfaces = context.getSubgraphObjectOrInterfaceTypes();
+            const outputType = namedTypeFromTypeNode(annotatedField.type);
+            const targetType = knownObjectsAndInterfaces.get(outputType.name.value);
+            if (!targetType) {
+                context.reportError(new GraphQLError(`Invalid @provides directive on field "${fieldCoordinate}": field has type "${print(annotatedField.type)}" which is not a Composite Type`, {
+                    nodes: directiveNode,
+                    extensions: {
+                        code: 'PROVIDES_ON_NON_OBJECT_FIELD',
+                    },
+                }));
+                return;
+            }
+            if (usedOnInterface) {
+                context.reportError(new GraphQLError(`Cannot use @provides on field "${fieldCoordinate}" of parent type "${annotatedType.name.value}": @provides is not yet supported within interfaces`, {
+                    nodes: directiveNode,
+                    extensions: { code: 'PROVIDES_UNSUPPORTED_ON_INTERFACE' },
+                }));
+                return;
+            }
+            const fieldsArg = getFieldsArgument(directiveNode);
+            if (!fieldsArg) {
+                return;
+            }
+            const printedFieldsValue = print(fieldsArg.value);
+            if (fieldsArg.value.kind !== Kind.STRING) {
+                context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): Invalid value for argument "fields": must be a string.`, {
+                    nodes: directiveNode,
+                    extensions: {
+                        code: 'PROVIDES_INVALID_FIELDS_TYPE',
+                    },
+                }));
+                return;
+            }
+            let selectionSet;
+            try {
+                selectionSet = parseFields(fieldsArg.value.value);
+            }
+            catch (error) {
+                if (error instanceof GraphQLError) {
+                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): ${error.message}`, {
+                        nodes: directiveNode,
+                        extensions: {
+                            code: 'PROVIDES_INVALID_FIELDS',
+                        },
+                    }));
+                    return;
+                }
+                throw error;
+            }
+            if (!selectionSet) {
+                return;
+            }
+            let isValid = true;
+            visitFields({
+                context,
+                selectionSet,
+                typeDefinition: targetType,
+                interceptUnknownField(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): Cannot query field "${info.fieldName}" on type "${info.typeDefinition.name.value}" (if the field is defined in another subgraph, you need to add it to this subgraph with @external).`, { nodes: directiveNode, extensions: { code: 'PROVIDES_INVALID_FIELDS' } }));
+                },
+                interceptDirective(info) {
+                    isValid = false;
+                    if (info.isKnown) {
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): cannot have directive applications in the @provides(fields:) argument but found @${info.directiveName}.`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'PROVIDES_DIRECTIVE_IN_FIELDS_ARG' },
+                        }));
+                    }
+                    else {
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): Unknown directive "@${info.directiveName}" in selection`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'PROVIDES_INVALID_FIELDS' },
+                        }));
+                    }
+                },
+                interceptArguments(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): field ${info.typeDefinition.name.value}.${info.fieldName} cannot be included because it has arguments (fields with argument are not allowed in @provides)`, { nodes: directiveNode, extensions: { code: 'PROVIDES_FIELDS_HAS_ARGS' } }));
+                },
+                interceptNonExternalField(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @provides since it is already provided by this subgraph (it is not marked @external)`, {
+                        extensions: {
+                            code: 'PROVIDES_FIELDS_MISSING_EXTERNAL',
+                        },
+                    }));
+                },
+                interceptExternalField(info) {
+                    if (context.satisfiesVersionRange('< v2.0')) {
+                        return;
+                    }
+                    const keyDirectives = info.typeDefinition.directives?.filter(directive => context.isAvailableFederationDirective('key', directive));
+                    if (!keyDirectives?.length) {
+                        return;
+                    }
+                    let interceptedFieldIsPrimaryKeyFromExtension = false;
+                    for (const keyDirective of keyDirectives) {
+                        if (interceptedFieldIsPrimaryKeyFromExtension) {
+                            break;
+                        }
+                        const fieldsArg = keyDirective.arguments?.find(arg => arg.name.value === 'fields' && arg.value.kind === Kind.STRING);
+                        if (fieldsArg) {
+                            const keyFields = parseFields(fieldsArg.value.value);
+                            if (keyFields) {
+                                visitFields({
+                                    context,
+                                    selectionSet: keyFields,
+                                    typeDefinition: info.typeDefinition,
+                                    interceptField(keyFieldInfo) {
+                                        if (keyFieldInfo.typeDefinition.name.value === info.typeDefinition.name.value &&
+                                            keyFieldInfo.fieldName === info.fieldName) {
+                                            const isInterfaceType = keyFieldInfo.typeDefinition.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                                                keyFieldInfo.typeDefinition.kind === Kind.INTERFACE_TYPE_EXTENSION;
+                                            if (isInterfaceType) {
+                                                return;
+                                            }
+                                            const isExtension = keyFieldInfo.typeDefinition.kind === Kind.OBJECT_TYPE_EXTENSION ||
+                                                keyFieldInfo.typeDefinition.kind === Kind.INTERFACE_TYPE_EXTENSION ||
+                                                keyFieldInfo.typeDefinition.directives?.some(directive => context.isAvailableFederationDirective('extends', directive));
+                                            if (isExtension) {
+                                                interceptedFieldIsPrimaryKeyFromExtension = true;
+                                            }
+                                        }
+                                        if (info.typeDefinition.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                                            info.typeDefinition.kind === Kind.OBJECT_TYPE_EXTENSION) {
+                                            context.stateBuilder.objectType.field.markAsProvided(info.typeDefinition.name.value, info.fieldName);
+                                        }
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    if (interceptedFieldIsPrimaryKeyFromExtension) {
+                        isValid = false;
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @provides since it is already "effectively" provided by this subgraph (while it is marked @external, it is a @key field of an extension type, which are not internally considered external for historical/backward compatibility reasons)`, {
+                            extensions: {
+                                code: 'PROVIDES_FIELDS_MISSING_EXTERNAL',
+                            },
+                        }));
+                    }
+                },
+            });
+            if (isValid) {
+                context.stateBuilder.objectType.field.setProvides(annotatedType.name.value, annotatedField.name.value, fieldsArg.value.value);
+            }
+        },
+    };
+}