graphql/validation/rules/KnownArgumentNamesRule.mjs

A Query Language and Runtime which can target any service.

import { didYouMean } from "../../jsutils/didYouMean.mjs";
import { suggestionList } from "../../jsutils/suggestionList.mjs";
import { GraphQLError } from "../../error/GraphQLError.mjs";
import { Kind } from "../../language/kinds.mjs";
import { specifiedDirectives } from "../../type/directives.mjs";
export function KnownArgumentNamesRule(context) {
    return {
        ...KnownArgumentNamesOnDirectivesRule(context),
        FragmentArgument(argNode) {
            const fragmentSignature = context.getFragmentSignature();
            if (fragmentSignature) {
                const varDef = fragmentSignature.variableDefinitions.get(argNode.name.value);
                if (!varDef) {
                    const argName = argNode.name.value;
                    const suggestions = context.hideSuggestions
                        ? []
                        : suggestionList(argName, Array.from(fragmentSignature.variableDefinitions.values()).map((varSignature) => varSignature.variable.name.value));
                    context.reportError(new GraphQLError(`Unknown argument "${argName}" on fragment "${fragmentSignature.definition.name.value}".` +
                        didYouMean(suggestions), { nodes: argNode }));
                }
            }
        },
        Argument(argNode) {
            const argDef = context.getArgument();
            const fieldDef = context.getFieldDef();
            if (!argDef && fieldDef) {
                const argName = argNode.name.value;
                const suggestions = context.hideSuggestions
                    ? []
                    : suggestionList(argName, fieldDef.args.map((arg) => arg.name));
                context.reportError(new GraphQLError(`Unknown argument "${argName}" on field "${fieldDef}".` +
                    didYouMean(suggestions), { nodes: argNode }));
            }
        },
    };
}
export function KnownArgumentNamesOnDirectivesRule(context) {
    const directiveArgs = new Map();
    const schema = context.getSchema();
    const definedDirectives = schema
        ? schema.getDirectives()
        : specifiedDirectives;
    for (const directive of definedDirectives) {
        directiveArgs.set(directive.name, directive.args.map((arg) => arg.name));
    }
    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, argsNodes.map((arg) => arg.name.value));
        }
    }
    return {
        Directive(directiveNode) {
            const directiveName = directiveNode.name.value;
            const knownArgs = directiveArgs.get(directiveName);
            if (directiveNode.arguments != null && knownArgs != null) {
                for (const argNode of directiveNode.arguments) {
                    const argName = argNode.name.value;
                    if (!knownArgs.includes(argName)) {
                        const suggestions = suggestionList(argName, knownArgs);
                        context.reportError(new GraphQLError(`Unknown argument "${argName}" on directive "@${directiveName}".` +
                            (context.hideSuggestions ? '' : didYouMean(suggestions)), { nodes: argNode }));
                    }
                }
            }
            return false;
        },
    };
}
//# sourceMappingURL=KnownArgumentNamesRule.js.map