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

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

@@ -0,0 +1,115 @@
+import { GraphQLError, Kind } from 'graphql';
+import { print } from '../../../../graphql/printer.js';
+import { getFieldsArgument, parseFields, validateDirectiveAgainstOriginal, visitFields, } from '../../../helpers.js';
+export function RequiresRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'requires', context);
+        },
+        Directive(directiveNode) {
+            if (!context.isAvailableFederationDirective('requires', 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;
+            if (annotatedField && usedOnInterface) {
+                context.reportError(new GraphQLError(`Cannot use @requires on field "${fieldCoordinate}" of parent type "${annotatedType.name.value}": @requires is not yet supported within interfaces`, {
+                    nodes: directiveNode,
+                    extensions: { code: 'REQUIRES_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 @requires(fields: ${printedFieldsValue}): Invalid value for argument "fields": must be a string.`, {
+                    nodes: directiveNode,
+                    extensions: {
+                        code: 'REQUIRES_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 @requires(fields: ${printedFieldsValue}): ${error.message}`, {
+                        nodes: directiveNode,
+                        extensions: {
+                            code: 'REQUIRES_INVALID_FIELDS',
+                        },
+                    }));
+                    return;
+                }
+                throw error;
+            }
+            if (!selectionSet) {
+                return;
+            }
+            let isValid = true;
+            if (annotatedType.kind !== Kind.INTERFACE_TYPE_DEFINITION &&
+                annotatedType.kind !== Kind.INTERFACE_TYPE_EXTENSION &&
+                annotatedType.kind !== Kind.OBJECT_TYPE_DEFINITION &&
+                annotatedType.kind !== Kind.OBJECT_TYPE_EXTENSION) {
+                return;
+            }
+            visitFields({
+                context,
+                selectionSet,
+                typeDefinition: annotatedType,
+                interceptField(info) {
+                    if (info.typeDefinition.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                        info.typeDefinition.kind === Kind.OBJECT_TYPE_EXTENSION) {
+                        context.stateBuilder.objectType.field.markedAsRequired(info.typeDefinition.name.value, info.fieldName);
+                    }
+                },
+                interceptUnknownField(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(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: 'REQUIRES_INVALID_FIELDS' } }));
+                },
+                interceptDirective(info) {
+                    isValid = false;
+                    if (info.isKnown) {
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(fields: ${printedFieldsValue}): cannot have directive applications in the @requires(fields:) argument but found @${info.directiveName}.`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'REQUIRES_DIRECTIVE_IN_FIELDS_ARG' },
+                        }));
+                    }
+                    else {
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(fields: ${printedFieldsValue}): Unknown directive "@${info.directiveName}" in selection`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'REQUIRES_INVALID_FIELDS' },
+                        }));
+                    }
+                },
+                interceptNonExternalField(info) {
+                    isValid = false;
+                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @requires since it is already provided by this subgraph (it is not marked @external)`, {
+                        extensions: {
+                            code: 'REQUIRES_FIELDS_MISSING_EXTERNAL',
+                        },
+                    }));
+                },
+            });
+            if (isValid) {
+                if (usedOnInterface) {
+                    context.stateBuilder.interfaceType.field.setRequires(annotatedType.name.value, annotatedField.name.value, fieldsArg.value.value);
+                    return;
+                }
+                context.stateBuilder.objectType.field.setRequires(annotatedType.name.value, annotatedField.name.value, fieldsArg.value.value);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,39 @@
+import { GraphQLError, Kind } from 'graphql';
+import { validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function ShareableRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'shareable', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('shareable', node)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            const fieldDef = context.typeNodeInfo.getFieldDef();
+            if (!typeDef) {
+                return;
+            }
+            if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
+                if (fieldDef) {
+                    context.stateBuilder.objectType.field.setShareable(typeDef.name.value, fieldDef.name.value);
+                }
+                else {
+                    context.stateBuilder.objectType.setShareable(typeDef.name.value);
+                }
+            }
+            if (!fieldDef) {
+                return;
+            }
+            if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+                context.reportError(new GraphQLError(`Invalid use of @shareable on field "${typeDef.name.value}.${fieldDef.name.value}": only object type fields can be marked with @shareable`, {
+                    nodes: node,
+                    extensions: { code: 'INVALID_SHAREABLE_USAGE' },
+                }));
+                return;
+            }
+        },
+    };
+}

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

@@ -0,0 +1,116 @@
+import { Kind } from 'graphql';
+import { validateDirectiveAgainstOriginal } from '../../../helpers.js';
+export function TagRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            validateDirectiveAgainstOriginal(node, 'tag', context);
+        },
+        Directive(node, _key, _parent, paths, ancestors) {
+            if (!context.isAvailableFederationDirective('tag', node)) {
+                return;
+            }
+            const nameArg = node.arguments?.find(arg => arg.name.value === 'name');
+            if (!nameArg) {
+                throw new Error('Expected @tag to have a "name" argument');
+            }
+            if (nameArg.value.kind !== Kind.STRING) {
+                throw new Error('Expected "@tag(name:)" to be a string');
+            }
+            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');
+            }
+            const tag = nameArg.value.value;
+            switch (parent.kind) {
+                case Kind.SCALAR_TYPE_DEFINITION:
+                case Kind.SCALAR_TYPE_EXTENSION:
+                    context.stateBuilder.scalarType.setTag(parent.name.value, tag);
+                    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 @tag');
+                    }
+                    if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+                        context.stateBuilder.interfaceType.field.setTag(typeDef.name.value, parent.name.value, tag);
+                    }
+                    else {
+                        context.stateBuilder.objectType.field.setTag(typeDef.name.value, parent.name.value, tag);
+                    }
+                    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 @tag');
+                    }
+                    if (typeDef.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                        context.stateBuilder.inputObjectType.field.setTag(typeDef.name.value, parent.name.value, tag);
+                    }
+                    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 @tag');
+                        }
+                        context.stateBuilder.objectType.field.arg.setTag(typeDef.name.value, fieldDef.name.value, parent.name.value, tag);
+                    }
+                    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 @tag');
+                        }
+                        context.stateBuilder.interfaceType.field.arg.setTag(typeDef.name.value, fieldDef.name.value, parent.name.value, tag);
+                    }
+                    else if (typeDef.kind === Kind.DIRECTIVE_DEFINITION) {
+                        context.stateBuilder.directive.arg.setTag(typeDef.name.value, parent.name.value, tag);
+                    }
+                    break;
+                }
+                case Kind.OBJECT_TYPE_DEFINITION:
+                case Kind.OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.objectType.setTag(parent.name.value, tag);
+                    break;
+                case Kind.INTERFACE_TYPE_DEFINITION:
+                case Kind.INTERFACE_TYPE_EXTENSION:
+                    context.stateBuilder.interfaceType.setTag(parent.name.value, tag);
+                    break;
+                case Kind.UNION_TYPE_DEFINITION:
+                case Kind.UNION_TYPE_EXTENSION:
+                    context.stateBuilder.unionType.setTag(parent.name.value, tag);
+                    break;
+                case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.inputObjectType.setTag(parent.name.value, tag);
+                    break;
+                case Kind.ENUM_TYPE_DEFINITION:
+                case Kind.ENUM_TYPE_EXTENSION:
+                    context.stateBuilder.enumType.setTag(parent.name.value, tag);
+                    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 @tag');
+                    }
+                    context.stateBuilder.enumType.value.setTag(typeDef.name.value, enumValue, tag);
+                    break;
+                }
+            }
+            context.stateBuilder.markSpecAsUsed('tag');
+        },
+    };
+}

package/esm/subgraph/validation/rules/known-argument-names-on-directives-rule.js

@@ -0,0 +1,30 @@
+import { GraphQLError, Kind } from 'graphql';
+export function KnownArgumentNamesOnDirectivesRule(context) {
+    const directiveArgs = new Map();
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+            const argsNodes = def.arguments ?? [];
+            directiveArgs.set(def.name.value, new Set(argsNodes.map(arg => arg.name.value)));
+        }
+    }
+    return {
+        Directive(directiveNode) {
+            const directiveName = directiveNode.name.value;
+            const knownArgs = directiveArgs.get(directiveName);
+            if (directiveNode.arguments && knownArgs) {
+                for (const argNode of directiveNode.arguments) {
+                    const argName = argNode.name.value;
+                    if (!knownArgs.has(argName)) {
+                        context.reportError(new GraphQLError(`Unknown argument "${argName}" on directive "@${directiveName}".`, {
+                            nodes: argNode,
+                            extensions: {
+                                code: 'INVALID_GRAPHQL',
+                            },
+                        }));
+                    }
+                }
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/known-directives-rule.js

@@ -0,0 +1,101 @@
+import { DirectiveLocation, GraphQLError, Kind, OperationTypeNode, specifiedDirectives, } from 'graphql';
+export function KnownDirectivesRule(context) {
+    const locationsMap = new Map();
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+            locationsMap.set(def.name.value, new Set(def.locations.map(name => name.value)));
+        }
+    }
+    for (const specifiedDirective of specifiedDirectives) {
+        locationsMap.set(specifiedDirective.name, new Set(specifiedDirective.locations.map(loc => String(loc))));
+    }
+    return {
+        Directive(node, _key, _parent, _path, ancestors) {
+            const name = node.name.value;
+            const locations = locationsMap.get(name);
+            if (!locations) {
+                context.reportError(new GraphQLError(`Unknown directive "@${name}".`, {
+                    nodes: node,
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+                return;
+            }
+            const candidateLocation = getDirectiveLocationForASTPath(ancestors);
+            if (candidateLocation && !locations.has(candidateLocation)) {
+                context.reportError(new GraphQLError(`Directive "@${name}" may not be used on ${candidateLocation}.`, {
+                    nodes: node,
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+        },
+    };
+}
+function getDirectiveLocationForASTPath(ancestors) {
+    const appliedTo = ancestors[ancestors.length - 1];
+    if (!('kind' in appliedTo)) {
+        throw new Error('Expected a node');
+    }
+    switch (appliedTo.kind) {
+        case Kind.OPERATION_DEFINITION:
+            return getDirectiveLocationForOperation(appliedTo.operation);
+        case Kind.FIELD:
+            return DirectiveLocation.FIELD;
+        case Kind.FRAGMENT_SPREAD:
+            return DirectiveLocation.FRAGMENT_SPREAD;
+        case Kind.INLINE_FRAGMENT:
+            return DirectiveLocation.INLINE_FRAGMENT;
+        case Kind.FRAGMENT_DEFINITION:
+            return DirectiveLocation.FRAGMENT_DEFINITION;
+        case Kind.VARIABLE_DEFINITION:
+            return DirectiveLocation.VARIABLE_DEFINITION;
+        case Kind.SCHEMA_DEFINITION:
+        case Kind.SCHEMA_EXTENSION:
+            return DirectiveLocation.SCHEMA;
+        case Kind.SCALAR_TYPE_DEFINITION:
+        case Kind.SCALAR_TYPE_EXTENSION:
+            return DirectiveLocation.SCALAR;
+        case Kind.OBJECT_TYPE_DEFINITION:
+        case Kind.OBJECT_TYPE_EXTENSION:
+            return DirectiveLocation.OBJECT;
+        case Kind.FIELD_DEFINITION:
+            return DirectiveLocation.FIELD_DEFINITION;
+        case Kind.INTERFACE_TYPE_DEFINITION:
+        case Kind.INTERFACE_TYPE_EXTENSION:
+            return DirectiveLocation.INTERFACE;
+        case Kind.UNION_TYPE_DEFINITION:
+        case Kind.UNION_TYPE_EXTENSION:
+            return DirectiveLocation.UNION;
+        case Kind.ENUM_TYPE_DEFINITION:
+        case Kind.ENUM_TYPE_EXTENSION:
+            return DirectiveLocation.ENUM;
+        case Kind.ENUM_VALUE_DEFINITION:
+            return DirectiveLocation.ENUM_VALUE;
+        case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+        case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            return DirectiveLocation.INPUT_OBJECT;
+        case Kind.INPUT_VALUE_DEFINITION: {
+            const parentNode = ancestors[ancestors.length - 3];
+            if (!('kind' in parentNode)) {
+                throw new Error('Expected a node');
+            }
+            return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION
+                ? DirectiveLocation.INPUT_FIELD_DEFINITION
+                : DirectiveLocation.ARGUMENT_DEFINITION;
+        }
+    }
+}
+function getDirectiveLocationForOperation(operation) {
+    switch (operation) {
+        case OperationTypeNode.QUERY:
+            return DirectiveLocation.QUERY;
+        case OperationTypeNode.MUTATION:
+            return DirectiveLocation.MUTATION;
+        case OperationTypeNode.SUBSCRIPTION:
+            return DirectiveLocation.SUBSCRIPTION;
+    }
+}

package/esm/subgraph/validation/rules/known-federation-directive-rule.js

@@ -0,0 +1,30 @@
+import { GraphQLError, Kind } from 'graphql';
+export function KnownFederationDirectivesRule(context) {
+    const availableDirectivesSet = new Set();
+    const knownDirectivesSet = new Set();
+    const knownDirectives = context.getKnownFederationDirectives();
+    for (const directive of knownDirectives) {
+        knownDirectivesSet.add(directive.name.value);
+    }
+    const availableDirectives = context.getAvailableFederationDirectives();
+    for (const directive of availableDirectives) {
+        availableDirectivesSet.add(directive.name.value);
+    }
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+            availableDirectivesSet.add(def.name.value);
+        }
+    }
+    return {
+        Directive(node) {
+            const name = node.name.value;
+            if (!availableDirectivesSet.has(name) &&
+                knownDirectivesSet.has(name) &&
+                !name.startsWith('federation__')) {
+                context.reportError(new GraphQLError(`Unknown directive "@${name}". If you meant the "@${name}" federation directive, you should use fully-qualified name "@federation__${name}" or add "@${name}" to the \`import\` argument of the @link to the federation specification.`, { nodes: node, extensions: { code: 'INVALID_GRAPHQL' } }));
+                return;
+            }
+        },
+    };
+}

package/esm/subgraph/validation/rules/known-root-type-rule.js

@@ -0,0 +1,21 @@
+import { GraphQLError, isTypeDefinitionNode, isTypeExtensionNode, } from 'graphql';
+export function KnownRootTypeRule(context) {
+    const { definitions } = context.getDocument();
+    const typeNames = new Set(definitions.filter(isTypeDefinitionOrExtensionNode).map(def => def.name.value));
+    return {
+        SchemaDefinition(node) {
+            node.operationTypes.forEach(operationType => {
+                if (!typeNames.has(operationType.type.name.value)) {
+                    context.reportError(new GraphQLError(`Cannot set schema ${operationType.operation} root to unknown type ${operationType.type.name.value}`, {
+                        extensions: {
+                            code: 'INVALID_GRAPHQL',
+                        },
+                    }));
+                }
+            });
+        },
+    };
+}
+function isTypeDefinitionOrExtensionNode(node) {
+    return isTypeDefinitionNode(node) || isTypeExtensionNode(node);
+}

package/esm/subgraph/validation/rules/known-type-names-rule.js

@@ -0,0 +1,30 @@
+import { GraphQLError, isTypeDefinitionNode, isTypeExtensionNode, isTypeSystemDefinitionNode, isTypeSystemExtensionNode, specifiedScalarTypes, } from 'graphql';
+function isTypeDefinitionOrExtensionNode(node) {
+    return isTypeDefinitionNode(node) || isTypeExtensionNode(node);
+}
+export function KnownTypeNamesRule(context) {
+    const { definitions } = context.getDocument();
+    const typeNames = new Set(definitions.filter(isTypeDefinitionOrExtensionNode).map(def => def.name.value));
+    return {
+        NamedType(node, _1, parent, _2, ancestors) {
+            const typeName = node.name.value;
+            if (!typeNames.has(typeName)) {
+                const definitionNode = ancestors[2] ?? parent;
+                const isSDL = definitionNode != null && isSDLNode(definitionNode);
+                if (isSDL && standardTypeNames.has(typeName)) {
+                    return;
+                }
+                context.reportError(new GraphQLError(`Unknown type ${typeName}`, {
+                    nodes: node,
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+        },
+    };
+}
+const standardTypeNames = new Set([...specifiedScalarTypes].map(type => type.name));
+function isSDLNode(value) {
+    return 'kind' in value && (isTypeSystemDefinitionNode(value) || isTypeSystemExtensionNode(value));
+}

package/esm/subgraph/validation/rules/lone-schema-definition-rule.js

@@ -0,0 +1,16 @@
+import { GraphQLError } from 'graphql';
+export function LoneSchemaDefinitionRule(context) {
+    let schemaDefinitionsCount = 0;
+    return {
+        SchemaDefinition() {
+            if (schemaDefinitionsCount > 0) {
+                context.reportError(new GraphQLError('Must provide only one schema definition.', {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            ++schemaDefinitionsCount;
+        },
+    };
+}

package/esm/subgraph/validation/rules/provided-arguments-on-directives-rule.js

@@ -0,0 +1,100 @@
+import { GraphQLError, Kind, specifiedScalarTypes } from 'graphql';
+import { print } from '../../../graphql/printer.js';
+import { namedTypeFromTypeNode } from '../../helpers.js';
+export function ProvidedArgumentsOnDirectivesRule(context) {
+    return {
+        Directive: {
+            leave(directiveNode, _k, _p, _pp, ancestors) {
+                const directiveName = directiveNode.name.value;
+                const directiveDefinition = context.getKnownDirectiveDefinition(directiveName);
+                if (!directiveDefinition) {
+                    return;
+                }
+                const args = directiveNode.arguments;
+                if (args && directiveDefinition.arguments) {
+                    const coordinate = context.getSchemaCoordinate(ancestors);
+                    for (const arg of args) {
+                        const argDefinition = directiveDefinition.arguments.find(a => a.name.value === arg.name.value);
+                        if (argDefinition && arg.value) {
+                            if (argDefinition.type.kind === Kind.NON_NULL_TYPE && arg.value.kind === Kind.NULL) {
+                                continue;
+                            }
+                            const printedType = printTypeNode(argDefinition.type, context);
+                            const printedValue = printValueNode(arg.value);
+                            if (!printedType) {
+                                continue;
+                            }
+                            if (printedType !== 'Any' && printedType !== printedValue) {
+                                const namedType = namedTypeFromTypeNode(argDefinition.type);
+                                const typeName = namedType.name.value;
+                                if (printedValue === 'Int' && typeName === 'Float') {
+                                    continue;
+                                }
+                                context.reportError(new GraphQLError(`Invalid value for "@${directiveName}(${arg.name.value}:)" of type "${print(argDefinition.type)}" in application of "@${directiveName}" to "${coordinate}".`, {
+                                    nodes: arg,
+                                    extensions: {
+                                        code: 'INVALID_GRAPHQL',
+                                    },
+                                }));
+                            }
+                        }
+                    }
+                }
+            },
+        },
+    };
+}
+function printValueNode(valueNode) {
+    switch (valueNode.kind) {
+        case Kind.LIST:
+            if (!valueNode.values.length) {
+                return '[]';
+            }
+            return printValueNode(valueNode.values[0]);
+        case Kind.ENUM:
+            return 'Enum';
+        case Kind.NULL:
+            return 'Null';
+        case Kind.INT:
+            return 'Int';
+        case Kind.FLOAT:
+            return 'Float';
+        case Kind.STRING:
+            return 'String';
+        case Kind.BOOLEAN:
+            return 'Boolean';
+        case Kind.OBJECT:
+            return 'Object';
+    }
+    throw new Error(`Unknown value node kind: ${valueNode}`);
+}
+function printTypeNode(typeNode, context) {
+    if (typeNode.kind === Kind.NAMED_TYPE) {
+        const def = context.getKnownTypeDefinition(typeNode.name.value);
+        if (!def) {
+            const specifiedScalar = specifiedScalarTypes.find(s => s.name === typeNode.name.value);
+            if (specifiedScalar) {
+                return specifiedScalar.name;
+            }
+            return null;
+        }
+        switch (def.kind) {
+            case Kind.SCALAR_TYPE_DEFINITION:
+            case Kind.SCALAR_TYPE_EXTENSION:
+                return 'Any';
+            case Kind.ENUM_TYPE_DEFINITION:
+            case Kind.ENUM_TYPE_EXTENSION:
+                return 'Enum';
+            case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            case Kind.OBJECT_TYPE_DEFINITION:
+            case Kind.OBJECT_TYPE_EXTENSION:
+            case Kind.INTERFACE_TYPE_DEFINITION:
+            case Kind.INTERFACE_TYPE_EXTENSION:
+            case Kind.UNION_TYPE_DEFINITION:
+            case Kind.UNION_TYPE_EXTENSION:
+                return 'Object';
+        }
+    }
+    return printTypeNode(typeNode.type, context);
+}

package/esm/subgraph/validation/rules/provided-required-arguments-on-directives-rule.js

@@ -0,0 +1,42 @@
+import { GraphQLError, Kind } from 'graphql';
+import { print } from '../../../graphql/printer.js';
+export function ProvidedRequiredArgumentsOnDirectivesRule(context) {
+    const requiredArgsMap = Object.create(null);
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+            const argNodes = def.arguments ?? [];
+            const requiredArgs = argNodes.filter(isRequiredArgumentNode);
+            requiredArgsMap[def.name.value] = {};
+            for (const requiredArg of requiredArgs) {
+                requiredArgsMap[def.name.value][requiredArg.name.value] = requiredArg;
+            }
+        }
+    }
+    return {
+        Directive: {
+            leave(directiveNode) {
+                const directiveName = directiveNode.name.value;
+                const requiredArgs = requiredArgsMap[directiveName];
+                if (requiredArgs) {
+                    const argNodes = directiveNode.arguments ?? [];
+                    const argNodeMap = new Set(argNodes.map(arg => arg.name.value));
+                    for (const [argName, argDef] of Object.entries(requiredArgs)) {
+                        if (!argNodeMap.has(argName)) {
+                            const argType = print(argDef.type);
+                            context.reportError(new GraphQLError(`Directive "@${directiveName}" argument "${argName}" of type "${argType}" is required, but it was not provided.`, {
+                                nodes: directiveNode,
+                                extensions: {
+                                    code: 'INVALID_GRAPHQL',
+                                },
+                            }));
+                        }
+                    }
+                }
+            },
+        },
+    };
+}
+function isRequiredArgumentNode(arg) {
+    return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
+}