public GraphQLArgument getArgument(String name) { for (GraphQLArgument argument : arguments) { if (argument.getName().equals(name)) return argument; } return null; }
private GraphQLArgument find(List<GraphQLArgument> arguments, String name) { for (GraphQLArgument argument : arguments) { if (argument.getName().equals(name)) return argument; } return null; }
public GraphQLArgument getArgument(String name) { for (GraphQLArgument argument : arguments) { if (argument.getName().equals(name)) return argument; } return null; }
public Builder argument(GraphQLArgument argument) { assertNotNull(argument, "argument can't be null"); this.arguments.put(argument.getName(), argument); return this; }
public Builder argument(GraphQLArgument argument) { Assert.assertNotNull(argument, "argument must not be null"); arguments.put(argument.getName(), argument); return this; }
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; }
sb.append(prefix).append(argument.getName()).append(": ").append(typeString(argument.getType())); Object defaultValue = argument.getDefaultValue(); if (defaultValue != null) {
@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); } } }
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)); }
private void checkFieldArgumentEquivalence(GraphQLObjectType objectTyoe, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector, GraphQLFieldDefinition interfaceFieldDef, GraphQLFieldDefinition objectFieldDef) { List<GraphQLArgument> interfaceArgs = interfaceFieldDef.getArguments(); List<GraphQLArgument> objectArgs = objectFieldDef.getArguments(); if (interfaceArgs.size() != objectArgs.size()) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' has a different number of arguments", objectTyoe.getName(), interfaceType.getName(), interfaceFieldDef.getName()))); } else { for (int i = 0; i < interfaceArgs.size(); i++) { GraphQLArgument interfaceArg = interfaceArgs.get(i); GraphQLArgument objectArg = objectArgs.get(i); String interfaceArgStr = makeArgStr(interfaceArg); String objectArgStr = makeArgStr(objectArg); boolean same = true; if (!interfaceArgStr.equals(objectArgStr)) { same = false; } if (!Objects.equals(interfaceArg.getDefaultValue(), objectArg.getDefaultValue())) { same = false; } if (!same) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' argument '%s' is defined differently", objectTyoe.getName(), interfaceType.getName(), interfaceFieldDef.getName(), interfaceArg.getName()))); } } } }
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; }
public GraphQLArgument getArgument(String name) { for (GraphQLArgument argument : arguments) { if (argument.getName().equals(name)) return argument; } return null; }
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()); }
@Test public void namedFields() { GraphQLObjectType object = GraphQLAnnotations.object(TestObjectNamedArgs.class); List<GraphQLFieldDefinition> fields = object.getFieldDefinitions(); assertEquals(fields.size(), 1); List<GraphQLArgument> args = fields.get(0).getArguments(); assertEquals(args.size(), 1); GraphQLArgument arg = args.get(0); assertEquals(arg.getName(), "namedArg"); }
@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 inputObjectArgument() { GraphQLObjectType object = GraphQLAnnotations.object(TestObjectInput.class); GraphQLArgument argument = object.getFieldDefinition("test").getArgument("arg"); assertTrue(argument.getType() instanceof GraphQLInputObjectType); assertEquals(argument.getName(), "arg"); GraphQLSchema schema = newSchema().query(object).build(); ExecutionResult result = GraphQL.newGraphQL(schema).build().execute("{ test( other:0,arg: { a:\"ok\", b:2 }) }", new TestObjectInput()); assertTrue(result.getErrors().isEmpty()); Map<String, Object> v = (Map<String, Object>) result.getData(); assertEquals(v.get("test"), "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); } }