public String buildDeprecationReason(List<Directive> directives) { directives = directives == null ? emptyList() : directives; Optional<Directive> directive = directives.stream().filter(d -> "deprecated".equals(d.getName())).findFirst(); if (directive.isPresent()) { Map<String, String> args = directive.get().getArguments().stream().collect(toMap( Argument::getName, arg -> ((StringValue) arg.getValue()).getValue() )); if (args.isEmpty()) { return NO_LONGER_SUPPORTED; // default value from spec } else { // pre flight checks have ensured its valid return args.get("reason"); } } return null; }
private NodePrinter<Directive> directive() { final String argSep = compactMode ? "," : ", "; return (out, node) -> { String arguments = wrap("(", join(node.getArguments(), argSep), ")"); out.printf("@%s%s", node.getName(), arguments); }; }
private boolean getDirectiveResult(Map<String, Object> variables, List<Directive> directives, String directiveName, boolean defaultValue) { Directive directive = getDirectiveByName(directives, directiveName); if (directive != null) { Map<String, Object> argumentValues = valuesResolver.getArgumentValues(SkipDirective.getArguments(), directive.getArguments(), variables); return (Boolean) argumentValues.get("if"); } return defaultValue; }
/** * A special check for the magic @deprecated directive * * @param errors the list of errors * @param directive the directive to check * @param errorSupplier the error supplier function */ static void checkDeprecatedDirective(List<GraphQLError> errors, Directive directive, Supplier<InvalidDeprecationDirectiveError> errorSupplier) { if ("deprecated".equals(directive.getName())) { // it can have zero args List<Argument> arguments = directive.getArguments(); if (arguments.size() == 0) { return; } // but if has more than it must have 1 called "reason" of type StringValue if (arguments.size() == 1) { Argument arg = arguments.get(0); if ("reason".equals(arg.getName()) && arg.getValue() instanceof StringValue) { return; } } // not valid errors.add(errorSupplier.get()); } }
public GraphQLDirective buildDirective(Directive directive, Set<GraphQLDirective> directiveDefinitions, DirectiveLocation directiveLocation) { Optional<GraphQLDirective> directiveDefinition = directiveDefinitions.stream().filter(dd -> dd.getName().equals(directive.getName())).findFirst(); GraphQLDirective.Builder builder = GraphQLDirective.newDirective() .name(directive.getName()) .description(buildDescription(directive, null)) .validLocations(directiveLocation); List<GraphQLArgument> arguments = directive.getArguments().stream() .map(arg -> buildDirectiveArgument(arg, directiveDefinition)) .collect(Collectors.toList()); if (directiveDefinition.isPresent()) { arguments = transferMissingArguments(arguments, directiveDefinition.get()); } arguments.forEach(builder::argument); return builder.build(); }
@Override public TraversalControl visitDirective(Directive node, TraverserContext<Node> context) { Directive changedNode = node.transform(builder -> { List<Argument> arguments = sort(node.getArguments(), comparing(Argument::getName)); builder.arguments(arguments); }); return changeNode(context, changedNode); }
private Builder(Directive existing) { this.sourceLocation = existing.getSourceLocation(); this.comments = existing.getComments(); this.name = existing.getName(); this.arguments = existing.getArguments(); this.ignoredChars = existing.getIgnoredChars(); }
private void checkDirectiveArguments(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry, Node element, String elementName, Directive directive, DirectiveDefinition directiveDefinition) { Map<String, InputValueDefinition> allowedArgs = getByName(directiveDefinition.getInputValueDefinitions(), (InputValueDefinition::getName), mergeFirst()); Map<String, Argument> providedArgs = getByName(directive.getArguments(), (Argument::getName), mergeFirst()); directive.getArguments().forEach(argument -> { InputValueDefinition allowedArg = allowedArgs.get(argument.getName()); if (allowedArg == null) { errors.add(new DirectiveUnknownArgumentError(element, elementName, directive.getName(), argument.getName())); } else { ArgValueOfAllowedTypeChecker argValueOfAllowedTypeChecker = new ArgValueOfAllowedTypeChecker(directive, element, elementName, argument, typeRegistry, runtimeWiring); argValueOfAllowedTypeChecker.checkArgValueMatchesAllowedType(errors, argument.getValue(), allowedArg.getType()); } }); allowedArgs.forEach((argName, definitionArgument) -> { if (isNoNullArgWithoutDefaultValue(definitionArgument)) { if (!providedArgs.containsKey(argName)) { errors.add(new DirectiveMissingNonNullArgumentError(element, elementName, directive.getName(), argName)); } } }); }
private void checkEnumValues(List<GraphQLError> errors, EnumTypeDefinition enumType, List<EnumValueDefinition> enumValueDefinitions) { // enum unique ness checkNamedUniqueness(errors, enumValueDefinitions, EnumValueDefinition::getName, (name, inputValueDefinition) -> new NonUniqueNameError(enumType, inputValueDefinition)); // directive checks enumValueDefinitions.forEach(enumValue -> { BiFunction<String, Directive, NonUniqueDirectiveError> errorFunction = (directiveName, directive) -> new NonUniqueDirectiveError(enumType, enumValue, directiveName); checkNamedUniqueness(errors, enumValue.getDirectives(), Directive::getName, errorFunction); }); enumValueDefinitions.forEach(enumValue -> enumValue.getDirectives().forEach(directive -> { checkDeprecatedDirective(errors, directive, () -> new InvalidDeprecationDirectiveError(enumType, enumValue)); BiFunction<String, Argument, NonUniqueArgumentError> errorFunction = (argumentName, argument) -> new NonUniqueArgumentError(enumType, enumValue, argumentName); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, errorFunction); })); }
private void checkInputValues(List<GraphQLError> errors, InputObjectTypeDefinition inputType, List<InputValueDefinition> inputValueDefinitions) { // field unique ness checkNamedUniqueness(errors, inputValueDefinitions, InputValueDefinition::getName, (name, inputValueDefinition) -> { // not sure why this is needed but inlining breaks it @SuppressWarnings("UnnecessaryLocalVariable") InputObjectTypeDefinition as = inputType; return new NonUniqueNameError(as, inputValueDefinition); }); // directive checks inputValueDefinitions.forEach(inputValueDef -> checkNamedUniqueness(errors, inputValueDef.getDirectives(), Directive::getName, (directiveName, directive) -> new NonUniqueDirectiveError(inputType, inputValueDef, directiveName))); inputValueDefinitions.forEach(inputValueDef -> inputValueDef.getDirectives().forEach(directive -> { checkDeprecatedDirective(errors, directive, () -> new InvalidDeprecationDirectiveError(inputType, inputValueDef)); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, (argumentName, argument) -> new NonUniqueArgumentError(inputType, inputValueDef, argumentName)); })); }
private void checkObjTypeFields(List<GraphQLError> errors, ObjectTypeDefinition typeDefinition, List<FieldDefinition> fieldDefinitions) { // field unique ness checkNamedUniqueness(errors, fieldDefinitions, FieldDefinition::getName, (name, fieldDef) -> new NonUniqueNameError(typeDefinition, fieldDef)); // field arg unique ness fieldDefinitions.forEach(fld -> checkNamedUniqueness(errors, fld.getInputValueDefinitions(), InputValueDefinition::getName, (name, inputValueDefinition) -> new NonUniqueArgumentError(typeDefinition, fld, name))); // directive checks fieldDefinitions.forEach(fld -> checkNamedUniqueness(errors, fld.getDirectives(), Directive::getName, (directiveName, directive) -> new NonUniqueDirectiveError(typeDefinition, fld, directiveName))); fieldDefinitions.forEach(fld -> fld.getDirectives().forEach(directive -> { checkDeprecatedDirective(errors, directive, () -> new InvalidDeprecationDirectiveError(typeDefinition, fld)); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, (argumentName, argument) -> new NonUniqueArgumentError(typeDefinition, fld, argumentName)); })); }
private void checkInterfaceFields(List<GraphQLError> errors, InterfaceTypeDefinition interfaceType, List<FieldDefinition> fieldDefinitions) { // field unique ness checkNamedUniqueness(errors, fieldDefinitions, FieldDefinition::getName, (name, fieldDef) -> new NonUniqueNameError(interfaceType, fieldDef)); // field arg unique ness fieldDefinitions.forEach(fld -> checkNamedUniqueness(errors, fld.getInputValueDefinitions(), InputValueDefinition::getName, (name, inputValueDefinition) -> new NonUniqueArgumentError(interfaceType, fld, name))); // directive checks fieldDefinitions.forEach(fld -> checkNamedUniqueness(errors, fld.getDirectives(), Directive::getName, (directiveName, directive) -> new NonUniqueDirectiveError(interfaceType, fld, directiveName))); fieldDefinitions.forEach(fld -> fld.getDirectives().forEach(directive -> { checkDeprecatedDirective(errors, directive, () -> new InvalidDeprecationDirectiveError(interfaceType, fld)); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, (argumentName, argument) -> new NonUniqueArgumentError(interfaceType, fld, argumentName)); })); }
@Override public void checkDirective(Directive directive, List<Node> ancestors) { GraphQLDirective graphQLDirective = getValidationContext().getDirective(); if (graphQLDirective == null) return; Map<String, Argument> argumentMap = argumentMap(directive.getArguments()); for (GraphQLArgument graphQLArgument : graphQLDirective.getArguments()) { Argument argument = argumentMap.get(graphQLArgument.getName()); if (argument == null && (isNonNull(graphQLArgument.getType()))) { String message = String.format("Missing directive argument %s", graphQLArgument.getName()); addError(ValidationErrorType.MissingDirectiveArgument, directive.getSourceLocation(), message); } } } }
() -> new InvalidDeprecationDirectiveError(extension, fld)); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, (argumentName, argument) -> new NonUniqueArgumentError(extension, fld, argumentName));
() -> new InvalidDeprecationDirectiveError(extension, fld)); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, (argumentName, argument) -> new NonUniqueArgumentError(extension, fld, argumentName));
() -> new InvalidDeprecationDirectiveError(extension, fld)); checkNamedUniqueness(errors, directive.getArguments(), Argument::getName, (argumentName, argument) -> new NonUniqueArgumentError(extension, fld, argumentName));
private NodePrinter<Directive> directive() { final String argSep = compactMode ? "," : ", "; return (out, node) -> { String arguments = wrap("(", join(node.getArguments(), argSep), ")"); out.printf("@%s%s", node.getName(), arguments); }; }
@Override public TraversalControl visitDirective(Directive node, TraverserContext<Node> context) { Directive changedNode = node.transform(builder -> { List<Argument> arguments = sort(node.getArguments(), comparing(Argument::getName)); builder.arguments(arguments); }); return changeNode(context, changedNode); }
private Builder(Directive existing) { this.sourceLocation = existing.getSourceLocation(); this.comments = existing.getComments(); this.name = existing.getName(); this.arguments = existing.getArguments(); this.ignoredChars = existing.getIgnoredChars(); }
private Map<String, Object> parseDirective(Directive dir, DataFetchingEnvironment env) { GraphQLDirective directive = env.getExecutionContext().getGraphQLSchema().getDirective(dir.getName()); if (directive == null) { return null; } return Collections.unmodifiableMap( valuesResolver.getArgumentValues(env.getGraphQLSchema().getFieldVisibility(), directive.getArguments(), dir.getArguments(), env.getExecutionContext().getVariables())); }