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

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

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvidesRules = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../../../../graphql/printer.js");
+const helpers_js_1 = require("../../../helpers.js");
+function ProvidesRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.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 === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                annotatedType?.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
+            const knownObjectsAndInterfaces = context.getSubgraphObjectOrInterfaceTypes();
+            const outputType = (0, helpers_js_1.namedTypeFromTypeNode)(annotatedField.type);
+            const targetType = knownObjectsAndInterfaces.get(outputType.name.value);
+            if (!targetType) {
+                context.reportError(new graphql_1.GraphQLError(`Invalid @provides directive on field "${fieldCoordinate}": field has type "${(0, printer_js_1.print)(annotatedField.type)}" which is not a Composite Type`, {
+                    nodes: directiveNode,
+                    extensions: {
+                        code: 'PROVIDES_ON_NON_OBJECT_FIELD',
+                    },
+                }));
+                return;
+            }
+            if (usedOnInterface) {
+                context.reportError(new graphql_1.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 = (0, helpers_js_1.getFieldsArgument)(directiveNode);
+            if (!fieldsArg) {
+                return;
+            }
+            const printedFieldsValue = (0, printer_js_1.print)(fieldsArg.value);
+            if (fieldsArg.value.kind !== graphql_1.Kind.STRING) {
+                context.reportError(new graphql_1.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 = (0, helpers_js_1.parseFields)(fieldsArg.value.value);
+            }
+            catch (error) {
+                if (error instanceof graphql_1.GraphQLError) {
+                    context.reportError(new graphql_1.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;
+            (0, helpers_js_1.visitFields)({
+                context,
+                selectionSet,
+                typeDefinition: targetType,
+                interceptUnknownField(info) {
+                    isValid = false;
+                    context.reportError(new graphql_1.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 graphql_1.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 graphql_1.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 graphql_1.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 graphql_1.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 === graphql_1.Kind.STRING);
+                        if (fieldsArg) {
+                            const keyFields = (0, helpers_js_1.parseFields)(fieldsArg.value.value);
+                            if (keyFields) {
+                                (0, helpers_js_1.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 === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                                                keyFieldInfo.typeDefinition.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
+                                            if (isInterfaceType) {
+                                                return;
+                                            }
+                                            const isExtension = keyFieldInfo.typeDefinition.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION ||
+                                                keyFieldInfo.typeDefinition.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION ||
+                                                keyFieldInfo.typeDefinition.directives?.some(directive => context.isAvailableFederationDirective('extends', directive));
+                                            if (isExtension) {
+                                                interceptedFieldIsPrimaryKeyFromExtension = true;
+                                            }
+                                        }
+                                        if (info.typeDefinition.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                                            info.typeDefinition.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                                            context.stateBuilder.objectType.field.markAsProvided(info.typeDefinition.name.value, info.fieldName);
+                                        }
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    if (interceptedFieldIsPrimaryKeyFromExtension) {
+                        isValid = false;
+                        context.reportError(new graphql_1.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);
+            }
+        },
+    };
+}
+exports.ProvidesRules = ProvidesRules;

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiresRules = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../../../../graphql/printer.js");
+const helpers_js_1 = require("../../../helpers.js");
+function RequiresRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.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 === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                annotatedType?.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
+            if (annotatedField && usedOnInterface) {
+                context.reportError(new graphql_1.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 = (0, helpers_js_1.getFieldsArgument)(directiveNode);
+            if (!fieldsArg) {
+                return;
+            }
+            const printedFieldsValue = (0, printer_js_1.print)(fieldsArg.value);
+            if (fieldsArg.value.kind !== graphql_1.Kind.STRING) {
+                context.reportError(new graphql_1.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 = (0, helpers_js_1.parseFields)(fieldsArg.value.value);
+            }
+            catch (error) {
+                if (error instanceof graphql_1.GraphQLError) {
+                    context.reportError(new graphql_1.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 !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
+                annotatedType.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION &&
+                annotatedType.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                annotatedType.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                return;
+            }
+            (0, helpers_js_1.visitFields)({
+                context,
+                selectionSet,
+                typeDefinition: annotatedType,
+                interceptField(info) {
+                    if (info.typeDefinition.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                        info.typeDefinition.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                        context.stateBuilder.objectType.field.markedAsRequired(info.typeDefinition.name.value, info.fieldName);
+                    }
+                },
+                interceptUnknownField(info) {
+                    isValid = false;
+                    context.reportError(new graphql_1.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 graphql_1.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 graphql_1.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 graphql_1.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);
+            }
+        },
+    };
+}
+exports.RequiresRules = RequiresRules;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareableRules = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../../../helpers.js");
+function ShareableRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.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 === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.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 === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
+                context.reportError(new graphql_1.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;
+            }
+        },
+    };
+}
+exports.ShareableRules = ShareableRules;

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagRules = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../../../helpers.js");
+function TagRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.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 !== graphql_1.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 graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+                    context.stateBuilder.scalarType.setTag(parent.name.value, tag);
+                    break;
+                case graphql_1.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 === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.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 graphql_1.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 === graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                        context.stateBuilder.inputObjectType.field.setTag(typeDef.name.value, parent.name.value, tag);
+                    }
+                    else if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.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 === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.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 === graphql_1.Kind.DIRECTIVE_DEFINITION) {
+                        context.stateBuilder.directive.arg.setTag(typeDef.name.value, parent.name.value, tag);
+                    }
+                    break;
+                }
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.objectType.setTag(parent.name.value, tag);
+                    break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+                    context.stateBuilder.interfaceType.setTag(parent.name.value, tag);
+                    break;
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                case graphql_1.Kind.UNION_TYPE_EXTENSION:
+                    context.stateBuilder.unionType.setTag(parent.name.value, tag);
+                    break;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.inputObjectType.setTag(parent.name.value, tag);
+                    break;
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+                    context.stateBuilder.enumType.setTag(parent.name.value, tag);
+                    break;
+                case graphql_1.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');
+        },
+    };
+}
+exports.TagRules = TagRules;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownArgumentNamesOnDirectivesRule = void 0;
+const graphql_1 = require("graphql");
+function KnownArgumentNamesOnDirectivesRule(context) {
+    const directiveArgs = new Map();
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === graphql_1.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 graphql_1.GraphQLError(`Unknown argument "${argName}" on directive "@${directiveName}".`, {
+                            nodes: argNode,
+                            extensions: {
+                                code: 'INVALID_GRAPHQL',
+                            },
+                        }));
+                    }
+                }
+            }
+        },
+    };
+}
+exports.KnownArgumentNamesOnDirectivesRule = KnownArgumentNamesOnDirectivesRule;

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownFederationDirectivesRule = void 0;
+const graphql_1 = require("graphql");
+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 === graphql_1.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 graphql_1.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;
+            }
+        },
+    };
+}
+exports.KnownFederationDirectivesRule = KnownFederationDirectivesRule;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownRootTypeRule = void 0;
+const graphql_1 = require("graphql");
+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 graphql_1.GraphQLError(`Cannot set schema ${operationType.operation} root to unknown type ${operationType.type.name.value}`, {
+                        extensions: {
+                            code: 'INVALID_GRAPHQL',
+                        },
+                    }));
+                }
+            });
+        },
+    };
+}
+exports.KnownRootTypeRule = KnownRootTypeRule;
+function isTypeDefinitionOrExtensionNode(node) {
+    return (0, graphql_1.isTypeDefinitionNode)(node) || (0, graphql_1.isTypeExtensionNode)(node);
+}