private Argument findArgumentByName(String name, List<Argument> arguments) { for (Argument argument : arguments) { if (argument.getName().equals(name)) { return argument; } } return null; }
private Map<String, Argument> argumentMap(List<Argument> arguments) { Map<String, Argument> result = new LinkedHashMap<>(); for (Argument argument : arguments) { result.put(argument.getName(), argument); } return result; }
private Map<String, Argument> argumentMap(List<Argument> arguments) { Map<String, Argument> result = new LinkedHashMap<>(); for (Argument argument : arguments) { result.put(argument.getName(), argument); } return result; }
public ArgumentValidationUtil(Argument argument) { argumentName = argument.getName(); argumentValue = argument.getValue(); }
private void addValidationError(List<GraphQLError> errors, String message, Object... args) { errors.add(new DirectiveIllegalArgumentTypeError(element, elementName, directive.getName(), argument.getName(), String.format(message, args))); }
/** * 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()); } }
private boolean sameArguments(List<Argument> arguments1, List<Argument> arguments2) { if (arguments1.size() != arguments2.size()) { return false; } for (Argument argument : arguments1) { Argument matchedArgument = findArgumentByName(argument.getName(), arguments2); if (matchedArgument == null) { return false; } if (!sameValue(argument.getValue(), matchedArgument.getValue())) { return false; } } return true; }
@Override public void checkArgument(Argument argument) { GraphQLDirective directiveDef = getValidationContext().getDirective(); if (directiveDef != null) { GraphQLArgument directiveArgument = directiveDef.getArgument(argument.getName()); if (directiveArgument == null) { String message = String.format("Unknown directive argument %s", argument.getName()); addError(ValidationErrorType.UnknownDirective, argument.getSourceLocation(), message); } return; } GraphQLFieldDefinition fieldDef = getValidationContext().getFieldDef(); if (fieldDef == null) return; GraphQLArgument fieldArgument = fieldDef.getArgument(argument.getName()); if (fieldArgument == null) { String message = String.format("Unknown field argument %s", argument.getName()); addError(ValidationErrorType.UnknownArgument, argument.getSourceLocation(), message); } } }
private Builder(Argument existing) { this.sourceLocation = existing.getSourceLocation(); this.comments = existing.getComments(); this.name = existing.getName(); this.value = existing.getValue(); this.ignoredChars = existing.getIgnoredChars(); }
private void enterImpl(Argument argument) { GraphQLArgument argumentType = null; if (getDirective() != null) { argumentType = find(getDirective().getArguments(), argument.getName()); } else if (getFieldDef() != null) { argumentType = find(getFieldDef().getArguments(), argument.getName()); } addInputType(argumentType != null ? argumentType.getType() : null); this.argument = argumentType; }
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 GraphQLArgument buildDirectiveArgument(Argument arg, Optional<GraphQLDirective> directiveDefinition) { Optional<GraphQLArgument> directiveDefArgument = directiveDefinition.map(dd -> dd.getArgument(arg.getName())); GraphQLArgument.Builder builder = GraphQLArgument.newArgument(); builder.name(arg.getName()); GraphQLInputType inputType; Object defaultValue = null; if (directiveDefArgument.isPresent()) { inputType = directiveDefArgument.get().getType(); defaultValue = directiveDefArgument.get().getDefaultValue(); } else { inputType = buildDirectiveInputType(arg.getValue()); } builder.type(inputType); builder.defaultValue(defaultValue); Object value = buildValue(arg.getValue(), inputType); // // we put the default value in if the specified is null builder.value(value == null ? defaultValue : value); return builder.build(); }
private Argument findArgumentByName(String name, List<Argument> arguments) { for (Argument argument : arguments) { if (argument.getName().equals(name)) { return argument; } } return null; }
private Map<String, Argument> argumentMap(List<Argument> arguments) { Map<String, Argument> result = new LinkedHashMap<>(); for (Argument argument : arguments) { result.put(argument.getName(), argument); } return result; }
private Map<String, Argument> argumentMap(List<Argument> arguments) { Map<String, Argument> result = new LinkedHashMap<>(); for (Argument argument : arguments) { result.put(argument.getName(), argument); } return result; }
private Optional<Argument> getPageArgument(Field field) { return field.getArguments() .stream() .filter(it -> GraphQLJpaSchemaBuilder.PAGE_PARAM_NAME.equals(it.getName())) .findFirst(); }
private Builder(Argument existing) { this.sourceLocation = existing.getSourceLocation(); this.comments = existing.getComments(); this.name = existing.getName(); this.value = existing.getValue(); this.ignoredChars = existing.getIgnoredChars(); }
private void enterImpl(Argument argument) { GraphQLArgument argumentType = null; if (getDirective() != null) { argumentType = find(getDirective().getArguments(), argument.getName()); } else if (getFieldDef() != null) { argumentType = find(getFieldDef().getArguments(), argument.getName()); } addInputType(argumentType != null ? argumentType.getType() : null); this.argument = argumentType; }
@Override protected Predicate getPredicate(CriteriaBuilder cb, Root<?> root, From<?,?> path, DataFetchingEnvironment environment, Argument argument) { if(isLogicalArgument(argument) || isDistinctArgument(argument)) return null; if(isWhereArgument(argument)) return getWherePredicate(cb, root, path, new ArgumentEnvironment(environment, argument.getName()), argument); return super.getPredicate(cb, root, path, environment, argument); }