@Override public void check(GraphQLFieldDefinition fieldDef, SchemaValidationErrorCollector validationErrorCollector) { for (GraphQLArgument argument : fieldDef.getArguments()) { GraphQLInputType argumentType = argument.getType(); if (argumentType instanceof GraphQLInputObjectType) { List<String> path = new ArrayList<>(); path.add(argumentType.getName()); check((GraphQLInputObjectType) argumentType, new LinkedHashSet<>(), path, validationErrorCollector); } } }
private String makeArgStr(GraphQLArgument argument) { // we don't do default value checking because toString of getDefaultValue is not guaranteed to be stable return argument.getName() + ":" + simplePrint(argument.getType()); }
private String directiveString(GraphQLDirective directive) { StringBuilder sb = new StringBuilder(); sb.append("@").append(directive.getName()); List<GraphQLArgument> args = directive.getArguments(); args = args .stream() .sorted(Comparator.comparing(GraphQLArgument::getName)) .collect(toList()); if (!args.isEmpty()) { sb.append("("); for (int i = 0; i < args.size(); i++) { GraphQLArgument arg = args.get(i); sb.append(arg.getName()); if (arg.getValue() != null) { sb.append(" : "); sb.append(printAst(arg.getValue(), arg.getType())); } else if (arg.getDefaultValue() != null) { sb.append(" : "); sb.append(printAst(arg.getDefaultValue(), arg.getType())); } if (i < args.size() - 1) { sb.append(", "); } } sb.append(")"); } return sb.toString(); }
private Map<String, Object> getArgumentValuesImpl(GraphQLCodeRegistry codeRegistry, List<GraphQLArgument> argumentTypes, List<Argument> arguments, Map<String, Object> variables) { if (argumentTypes.isEmpty()) { return Collections.emptyMap(); } Map<String, Object> result = new LinkedHashMap<>(); Map<String, Argument> argumentMap = argumentMap(arguments); for (GraphQLArgument fieldArgument : argumentTypes) { String argName = fieldArgument.getName(); Argument argument = argumentMap.get(argName); Object value; if (argument != null) { value = coerceValueAst(codeRegistry.getFieldVisibility(), fieldArgument.getType(), argument.getValue(), variables); } else { value = fieldArgument.getDefaultValue(); } // only put an arg into the result IF they specified a variable at all or // the default value ended up being something non null if (argumentMap.containsKey(argName) || value != null) { result.put(argName, value); } } return result; }
public Builder(GraphQLArgument existing) { this.name = existing.getName(); this.type = existing.getType(); this.value = existing.getValue(); this.defaultValue = existing.getDefaultValue(); this.description = existing.getDescription(); this.definition = existing.getDefinition(); this.directives.putAll(FpKit.getByName(existing.getDirectives(), GraphQLDirective::getName)); }
@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); } } } }
@Override public void checkField(Field field) { GraphQLFieldDefinition fieldDef = getValidationContext().getFieldDef(); if (fieldDef == null) return; Map<String, Argument> argumentMap = argumentMap(field.getArguments()); for (GraphQLArgument graphQLArgument : fieldDef.getArguments()) { Argument argument = argumentMap.get(graphQLArgument.getName()); if (argument == null && (isNonNull(graphQLArgument.getType())) && (graphQLArgument.getDefaultValue() == null)) { String message = String.format("Missing field argument %s", graphQLArgument.getName()); addError(ValidationErrorType.MissingFieldArgument, field.getSourceLocation(), message); } } }
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 List<GraphQLArgument> transferMissingArguments(List<GraphQLArgument> arguments, GraphQLDirective directiveDefinition) { Map<String, GraphQLArgument> declaredArgs = FpKit.getByName(arguments, GraphQLArgument::getName, FpKit.mergeFirst()); List<GraphQLArgument> argumentsOut = new ArrayList<>(arguments); for (GraphQLArgument directiveDefArg : directiveDefinition.getArguments()) { if (!declaredArgs.containsKey(directiveDefArg.getName())) { GraphQLArgument missingArg = GraphQLArgument.newArgument() .name(directiveDefArg.getName()) .description(directiveDefArg.getDescription()) .definition(directiveDefArg.getDefinition()) .type(directiveDefArg.getType()) .defaultValue(directiveDefArg.getDefaultValue()) .value(directiveDefArg.getDefaultValue()) .build(); argumentsOut.add(missingArg); } } return argumentsOut; }
@Override public void checkArgument(Argument argument) { GraphQLArgument fieldArgument = getValidationContext().getArgument(); if (fieldArgument == null) return; ArgumentValidationUtil validationUtil = new ArgumentValidationUtil(argument); if (!validationUtil.isValidLiteralValue(argument.getValue(), fieldArgument.getType(), getValidationContext().getSchema())) { addError(ValidationErrorType.WrongType, argument.getSourceLocation(), validationUtil.getMessage()); } } }
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 public void check(GraphQLFieldDefinition fieldDef, SchemaValidationErrorCollector validationErrorCollector) { for (GraphQLArgument argument : fieldDef.getArguments()) { GraphQLInputType argumentType = argument.getType(); if (argumentType instanceof GraphQLInputObjectType) { List<String> path = new ArrayList<>(); path.add(argumentType.getName()); check((GraphQLInputObjectType) argumentType, new LinkedHashSet<>(), path, validationErrorCollector); } } }
private String makeArgStr(GraphQLArgument argument) { // we don't do default value checking because toString of getDefaultValue is not guaranteed to be stable return argument.getName() + ":" + simplePrint(argument.getType()); }
protected String getMutationArgumentType(GraphQLFieldDefinition mutationGraphQLFieldDefinition) { GraphQLArgument graphQLArgument = getMutationArgument(mutationGraphQLFieldDefinition); GraphQLInputType graphQLInputType = graphQLArgument.getType(); return graphQLInputType != null ? schemaUtil.getUnmodifiedType(graphQLInputType).getName() : ""; }
public Builder(GraphQLArgument existing) { this.name = existing.getName(); this.type = existing.getType(); this.value = existing.getValue(); this.defaultValue = existing.getDefaultValue(); this.description = existing.getDescription(); this.definition = existing.getDefinition(); this.directives.putAll(FpKit.getByName(existing.getDirectives(), GraphQLDirective::getName)); }
@Override public GraphQLArgument transformArgument(GraphQLArgument argument, DirectiveArgument directiveArgument, OperationMapper operationMapper, BuildContext buildContext) { if (directiveArgument.getAnnotation() != null && directiveArgument.getDefaultValue() == null) { return argument.transform(builder -> builder.type(GraphQLNonNull.nonNull(argument.getType()))); } return transformArgument(argument, directiveArgument.getTypedElement(), directiveArgument.toString(), operationMapper, buildContext); }
@Test public void complexInputObjectArgument() { GraphQLObjectType object = GraphQLAnnotations.object(TestObjectInput.class); GraphQLArgument argument = object.getFieldDefinition("test2").getArgument("arg"); assertTrue(argument.getType() instanceof GraphQLInputObjectType); assertEquals(argument.getName(), "arg"); GraphQLSchema schema = newSchema().query(object).build(); ExecutionResult result = GraphQL.newGraphQL(schema).build().execute("{ test2(arg: {inputs:[{ a:\"ok\", b:2 }]}, other:0) }", new TestObjectInput()); assertTrue(result.getErrors().isEmpty()); Map<String, Object> v = result.getData(); assertEquals(v.get("test2"), "ok"); }
@Test public void getArgument_goodFieldSupplied_correctArgumentCreated() throws NoSuchFieldException { GraphQLArgument isActive = directiveArgumentCreator.getArgument(this.getClass().getDeclaredField("isActive"), DirectiveArgumentCreatorTest.class); // Assert assertEquals(isActive.getName(), "isActive"); assertEquals(isActive.getDefaultValue(), true); assertEquals(isActive.getDescription(), "isActive"); assertEquals(isActive.getType(), GraphQLBoolean); } }
public static GraphQLArgument.Builder notNull (GraphQLArgument.Builder aBuilder) { GraphQLArgument arg = aBuilder.build(); return GraphQLArgument.newArgument() .name(arg.getName()) .defaultValue(arg.getDefaultValue()) .definition(arg.getDefinition()) .description(arg.getDescription()) .type(new GraphQLNonNull(arg.getType())); }