/** * This helps you transform the current GraphQLArgument into another one by starting a builder with all * the current values and allows you to transform it how you want. * * @param builderConsumer the consumer code that will be given a builder to transform * * @return a new field based on calling build on that builder */ public GraphQLArgument transform(Consumer<Builder> builderConsumer) { Builder builder = newArgument(this); builderConsumer.accept(builder); return builder.build(); }
/** * Take an argument builder in a function definition and apply. Can be used in a jdk8 lambda * e.g.: * <pre> * {@code * argument(a -> a.name("argumentName")) * } * </pre> * * @param builderFunction a supplier for the builder impl * * @return this */ public Builder argument(UnaryOperator<GraphQLArgument.Builder> builderFunction) { GraphQLArgument.Builder builder = GraphQLArgument.newArgument(); builder = builderFunction.apply(builder); return argument(builder); }
/** * Take an argument builder in a function definition and apply. Can be used in a jdk8 lambda * e.g.: * <pre> * {@code * argument(a -> a.name("argumentName")) * } * </pre> * * @param builderFunction a supplier for the builder impl * * @return this */ public Builder argument(UnaryOperator<GraphQLArgument.Builder> builderFunction) { GraphQLArgument.Builder builder = GraphQLArgument.newArgument(); builder = builderFunction.apply(builder); return argument(builder); }
public List<GraphQLArgument> getBackwardPaginationConnectionFieldArguments() { List<GraphQLArgument> args = new ArrayList<>(); args.add(newArgument() .name("before") .description("fetching only nodes before this node (exclusive)") .type(GraphQLString) .build()); args.add(newArgument() .name("last") .description("fetching only the last certain number of nodes") .type(GraphQLInt) .build()); return args; }
public List<GraphQLArgument> getForwardPaginationConnectionFieldArguments() { List<GraphQLArgument> args = new ArrayList<>(); args.add(newArgument() .name("after") .description("fetching only nodes after this node (exclusive)") .type(GraphQLString) .build()); args.add(newArgument() .name("first") .description("fetching only the first certain number of nodes") .type(GraphQLInt) .build()); return args; }
public List<GraphQLArgument> getConnectionFieldArguments() { List<GraphQLArgument> args = new ArrayList<>(); args.add(newArgument() .name("before") .description("fetching only nodes before this node (exclusive)") .type(GraphQLString) .build()); args.add(newArgument() .name("after") .description("fetching only nodes after this node (exclusive)") .type(GraphQLString) .build()); args.add(newArgument() .name("first") .description("fetching only the first certain number of nodes") .type(GraphQLInt) .build()); args.add(newArgument() .name("last") .description("fetching only the last certain number of nodes") .type(GraphQLInt) .build()); return args; }
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 GraphQLArgument buildDirectiveArgumentFromDefinition(InputValueDefinition arg, Function<Type, GraphQLInputType> inputTypeFactory) { GraphQLArgument.Builder builder = GraphQLArgument.newArgument() .name(arg.getName()) .definition(arg); GraphQLInputType inputType = inputTypeFactory.apply(arg.getType()); builder.type(inputType); builder.value(buildValue(arg.getDefaultValue(), inputType)); builder.defaultValue(buildValue(arg.getDefaultValue(), inputType)); 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; }
public GraphQLFieldDefinition nodeField(GraphQLInterfaceType nodeInterface, DataFetcher nodeDataFetcher) { return newFieldDefinition() .name("node") .description("Fetches an object given its ID") .type(nodeInterface) .dataFetcher(nodeDataFetcher) .argument(newArgument() .name("id") .description("The ID of an object") .type(nonNull(GraphQLID))) .build(); }
void listsAndNonNullLists() { GraphQLList.list(GraphQLString); // a list of Strings GraphQLNonNull.nonNull(GraphQLString); // a non null String // with static imports its even shorter newArgument() .name("example") .type(nonNull(list(GraphQLString))); }
.argument(GraphQLArgument.newArgument() .name("intialValue") .type(GraphQLInt) .defaultValue(5)) .argument(GraphQLArgument.newArgument() .name("filter") .type(filterType())))
private GraphQLArgument buildArgument(BuildContext buildCtx, InputValueDefinition valueDefinition) { buildCtx.enterNode(valueDefinition); GraphQLArgument.Builder builder = GraphQLArgument.newArgument(); builder.definition(valueDefinition); builder.name(valueDefinition.getName()); builder.description(schemaGeneratorHelper.buildDescription(valueDefinition, valueDefinition.getDescription())); GraphQLInputType inputType = buildInputType(buildCtx, valueDefinition.getType()); builder.type(inputType); Value defaultValue = valueDefinition.getDefaultValue(); if (defaultValue != null) { builder.defaultValue(schemaGeneratorHelper.buildValue(defaultValue, inputType)); } builder.withDirectives( buildDirectives(valueDefinition.getDirectives(), emptyList(), ARGUMENT_DEFINITION, buildCtx.getDirectiveDefinitions()) ); GraphQLArgument argument = builder.build(); argument = directiveBehaviour.onArgument(argument, buildCtx.mkBehaviourParams()); return buildCtx.exitNode(argument); }
public GraphQLFieldDefinition mutation(String name, String fieldName, List<GraphQLInputObjectField> inputFields, List<GraphQLFieldDefinition> outputFields, DataFetcher dataFetcher) { GraphQLInputObjectType inputObjectType = newInputObject() .name(name + "Input") .fields(inputFields) .build(); GraphQLObjectType outputType = newObject() .name(name + "Payload") .fields(outputFields) .build(); return newFieldDefinition() .name(fieldName) .type(outputType) .argument(newArgument() .name("input") .type(nonNull(inputObjectType))) .dataFetcher(dataFetcher) .build(); }
.newArgument() .name("format") .type(Scalars.GraphQLString)
.name("stoptimesForServiceDate") .type(new GraphQLList(stoptimesInPatternType)) .argument(GraphQLArgument.newArgument() .name("date") .type(Scalars.GraphQLString) .name("stoptimesForPatterns") .type(new GraphQLList(stoptimesInPatternType)) .argument(GraphQLArgument.newArgument() .name("startTime") .argument(GraphQLArgument.newArgument() .name("timeRange") .type(Scalars.GraphQLInt) .defaultValue(24 * 60 * 60) .build()) .argument(GraphQLArgument.newArgument() .name("numberOfDepartures") .type(Scalars.GraphQLInt) .defaultValue(5) .build()) .argument(GraphQLArgument.newArgument() .name("omitNonPickups") .type(Scalars.GraphQLBoolean) .name("stoptimesWithoutPatterns") .type(new GraphQLList(stoptimeType)) .argument(GraphQLArgument.newArgument() .name("startTime")
.name("createReview") .type(reviewType) .argument(newArgument() .name("episode") .type(episodeType) .argument(newArgument() .name("review") .type(reviewInputType)
.description("String#split(regex) but replace empty strings with nulls to help us test null behavior in lists") .type(list(typeRef("StringObject"))) .argument(GraphQLArgument.newArgument() .name("regex") .type(GraphQLString)) .description("String#split(regex) but replace empty strings with nulls to help us test null behavior in lists") .type(list(nonNull(typeRef("StringObject")))) .argument(GraphQLArgument.newArgument() .name("regex") .type(GraphQLString)) .name("append") .type(typeRef("StringObject")) .argument(GraphQLArgument.newArgument() .name("text") .type(GraphQLString)) .name("emptyOptional") .type(GraphQLString) .argument(GraphQLArgument.newArgument() .name("text") .type(GraphQLString)) .name("optional") .type(GraphQLString) .argument(GraphQLArgument.newArgument() .name("text") .type(GraphQLString))
/** * Return a new name argument with the provided description. * * @param description * @return */ public GraphQLArgument createNameArg(String description) { return newArgument().name("name").type(GraphQLString).description(description).build(); }
private GraphQLArgument toGraphQLArgument(DirectiveArgument directiveArgument, BuildContext buildContext) { GraphQLArgument argument = newArgument() .name(directiveArgument.getName()) .description(directiveArgument.getDescription()) .type(toGraphQLInputType(directiveArgument.getJavaType(), buildContext)) .value(directiveArgument.getValue()) .defaultValue(directiveArgument.getDefaultValue()) .withDirectives(toGraphQLDirectives(directiveArgument.getTypedElement(), buildContext.directiveBuilder::buildArgumentDefinitionDirectives, buildContext)) .build(); return buildContext.transformers.transform(argument, directiveArgument, this, buildContext); }