/** * This helps you transform the current GraphQLInputObjectType 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 object based on calling build on that builder */ public GraphQLInputObjectType transform(Consumer<Builder> builderConsumer) { Builder builder = newInputObject(this); builderConsumer.accept(builder); return builder.build(); }
void inputTypes() { GraphQLInputObjectType inputObjectType = newInputObject() .name("inputObjectType") .field(newInputObjectField() .name("field") .type(GraphQLString)) .build(); }
private GraphQLInputObjectType buildInputObjectType(BuildContext buildCtx, InputObjectTypeDefinition typeDefinition) { buildCtx.enterNode(typeDefinition); GraphQLInputObjectType.Builder builder = GraphQLInputObjectType.newInputObject(); builder.definition(typeDefinition); builder.name(typeDefinition.getName()); builder.description(schemaGeneratorHelper.buildDescription(typeDefinition, typeDefinition.getDescription())); List<InputObjectTypeExtensionDefinition> extensions = inputObjectTypeExtensions(typeDefinition, buildCtx); builder.withDirectives( buildDirectives(typeDefinition.getDirectives(), directivesOf(extensions), INPUT_OBJECT, buildCtx.getDirectiveDefinitions()) ); typeDefinition.getInputValueDefinitions().forEach(inputValue -> builder.field(buildInputField(buildCtx, inputValue))); extensions.forEach(extension -> extension.getInputValueDefinitions().forEach(inputValueDefinition -> { GraphQLInputObjectField inputField = buildInputField(buildCtx, inputValueDefinition); if (!builder.hasField(inputField.getName())) { builder.field(inputField); } })); GraphQLInputObjectType inputObjectType = builder.build(); inputObjectType = directiveBehaviour.onInputObjectType(inputObjectType, buildCtx.mkBehaviourParams()); return buildCtx.exitNode(inputObjectType); }
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(); }
public static GraphQLInputObjectType rangeType() { return GraphQLInputObjectType.newInputObject() .name("Range") .field(GraphQLInputObjectField.newInputObjectField() .name("lowerBound") .type(GraphQLInt)) .field(GraphQLInputObjectField.newInputObjectField() .name("upperBound") .type(GraphQLInt)) .build(); } }
public static GraphQLInputObjectType filterType() { return GraphQLInputObjectType.newInputObject() .name("Filter") .field(GraphQLInputObjectField.newInputObjectField() .name("even") .type(GraphQLBoolean)) .field(GraphQLInputObjectField.newInputObjectField() .name("range") .type(rangeType())) .build(); }
void mutationExample() { GraphQLInputObjectType episodeType = GraphQLInputObjectType.newInputObject() .name("Episode") .field(newInputObjectField() .build(); GraphQLInputObjectType reviewInputType = GraphQLInputObjectType.newInputObject() .name("ReviewInput") .field(newInputObjectField()
/** * This helps you transform the current GraphQLInputObjectType 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 object based on calling build on that builder */ public GraphQLInputObjectType transform(Consumer<Builder> builderConsumer) { Builder builder = newInputObject(this); builderConsumer.accept(builder); return builder.build(); }
public GraphQLInputType buildGraphQLInputTypeFromMethodParam(DfsContext dfsContext, ResolvableTypeAccessor resolvableTypeAccessor) { Class<?> cls = resolvableTypeAccessor.resolve(); GraphQLInputType graphQLInputObjectType = (GraphQLInputType) objectTypeResolverMap.get(cls); if (graphQLInputObjectType == null) graphQLInputObjectType = (GraphQLInputType) createGraphQLFieldType(dfsContext, resolvableTypeAccessor, false); if (graphQLInputObjectType == null) { // -- class as input parameter final List<GraphQLInputObjectField> graphQLInputFieldDefinitions = new ArrayList<GraphQLInputObjectField>(); ReflectionUtils.getAllFields(cls).forEach(field -> { GraphQLInputObjectField definition = buildGraphQLInputObjectField(dfsContext, field, cls); if (definition != null) graphQLInputFieldDefinitions.add(definition); }); graphQLInputObjectType = newInputObject() .name(cls.getSimpleName()) .description(resolvableTypeAccessor.getDescription()) .fields(graphQLInputFieldDefinitions) .build(); } return graphQLInputObjectType; }
@Override protected GraphQLInputObjectType toGraphQLInputType(String typeName, AnnotatedType javaType, OperationMapper operationMapper, BuildContext buildContext) { GraphQLInputObjectType.Builder typeBuilder = newInputObject() .name(typeName) .description(buildContext.typeInfoGenerator.generateInputTypeDescription(javaType, buildContext.messageBundle)); InputFieldBuilderParams params = InputFieldBuilderParams.builder() .withType(javaType) .withEnvironment(buildContext.globalEnvironment) .build(); buildContext.inputFieldBuilders.getInputFields(params).forEach(field -> typeBuilder.field(operationMapper.toGraphQLInputField(field, buildContext))); return typeBuilder.build(); }
@Override protected GraphQLInputObjectType toGraphQLInputType(String typeName, AnnotatedType javaType, OperationMapper operationMapper, BuildContext buildContext) { GraphQLInputObjectType.Builder builder = GraphQLInputObjectType.newInputObject() .name(typeName) .description(buildContext.typeInfoGenerator.generateInputTypeDescription(javaType, buildContext.messageBundle)); Enum[] keys = (Enum[]) ClassUtils.getRawType(getElementType(javaType, 0).getType()).getEnumConstants(); Arrays.stream(keys).forEach(enumValue -> builder.field(GraphQLInputObjectField.newInputObjectField() .name(enumMapper.getValueName(enumValue, buildContext.messageBundle)) .description(enumMapper.getValueDescription(enumValue, buildContext.messageBundle)) .type(operationMapper.toGraphQLInputType(getElementType(javaType, 1), buildContext)) .build())); return builder.build(); }
@Test(expectedExceptions = InvalidDirectiveLocationException.class) public void wireGraphQLInputObjectType_invalidLocations_exceptionIsThrown() throws Exception { // Arrange AnnotationsDirectiveWiring upperWiring = mock(AnnotationsDirectiveWiring.class); GraphQLInputObjectType directiveContainer = GraphQLInputObjectType.newInputObject().name("asdf") .build(); AnnotationsWiringEnvironmentImpl upperCaseEnv = new AnnotationsWiringEnvironmentImpl(directiveContainer, directiveContainer.getDirective("upperCase")); when(upperWiring.onInputObjectType(upperCaseEnv)).thenReturn(directiveContainer); HashMap<GraphQLDirective, AnnotationsDirectiveWiring> map = new HashMap<>(); GraphQLDirective upperCase = newDirective().name("upperCase").build(); map.put(upperCase, upperWiring); // Act directiveWirer.wire(directiveContainer, map); }
@Test public void wireGraphQLInputObjectType_validLocations_correctMethodIsCalled() throws Exception { // Arrange AnnotationsDirectiveWiring upperWiring = mock(AnnotationsDirectiveWiring.class); GraphQLInputObjectType directiveContainer = GraphQLInputObjectType.newInputObject().name("asdf") .build(); AnnotationsWiringEnvironmentImpl upperCaseEnv = new AnnotationsWiringEnvironmentImpl(directiveContainer, directiveContainer.getDirective("upperCase")); when(upperWiring.onInputObjectType(upperCaseEnv)).thenReturn(directiveContainer); HashMap<GraphQLDirective, AnnotationsDirectiveWiring> map = new HashMap<>(); GraphQLDirective upperCase = newDirective().name("upperCase").validLocations(Introspection.DirectiveLocation.INPUT_OBJECT).build(); map.put(upperCase, upperWiring); // Act directiveWirer.wire(directiveContainer, map); // Assert verify(upperWiring).onInputObjectType(upperCaseEnv); }
@Test(expectedExceptions = InvalidDirectiveLocationException.class) public void wireGraphQLInputObjectField_invalidLocations_exceptionIsThrown() throws Exception { // Arrange AnnotationsDirectiveWiring upperWiring = mock(AnnotationsDirectiveWiring.class); GraphQLInputObjectField directiveContainer = GraphQLInputObjectField.newInputObjectField().name("asdf") .type(GraphQLInputObjectType.newInputObject().name("dfdf").build()).build(); AnnotationsWiringEnvironmentImpl upperCaseEnv = new AnnotationsWiringEnvironmentImpl(directiveContainer, directiveContainer.getDirective("upperCase")); when(upperWiring.onInputObjectField(upperCaseEnv)).thenReturn(directiveContainer); HashMap<GraphQLDirective, AnnotationsDirectiveWiring> map = new HashMap<>(); GraphQLDirective upperCase = newDirective().name("upperCase").build(); map.put(upperCase, upperWiring); // Act directiveWirer.wire(directiveContainer, map); }
@Override public GraphQLInputType getInputType(IGraphQLObjectMapper objectMapper, Type type) { return GraphQLInputObjectType.newInputObject().name(objectMapper.getTypeNamingStrategy().getTypeName(objectMapper, type)) .field(GraphQLInputObjectField.newInputObjectField().name("time").type(Scalars.GraphQLString).build()).build(); }
@Override public GraphQLInputObjectType toGraphQLInputType(String typeName, AnnotatedType javaType, OperationMapper operationMapper, BuildContext buildContext) { GraphQLInputObjectType.Builder typeBuilder = newInputObject() .name(typeName) .description(buildContext.typeInfoGenerator.generateInputTypeDescription(javaType, buildContext.messageBundle)); InputFieldBuilderParams params = InputFieldBuilderParams.builder() .withType(javaType) .withEnvironment(buildContext.globalEnvironment) .build(); buildContext.inputFieldBuilders.getInputFields(params).forEach(field -> typeBuilder.field(operationMapper.toGraphQLInputField(field, buildContext))); if (ClassUtils.isAbstract(javaType)) { createInputDisambiguatorField(javaType, buildContext).ifPresent(typeBuilder::field); } typeBuilder.withDirective(Directives.mappedType(javaType)); buildContext.directiveBuilder.buildInputObjectTypeDirectives(javaType, buildContext.directiveBuilderParams()).forEach(directive -> typeBuilder.withDirective(operationMapper.toGraphQLDirective(directive, buildContext))); return typeBuilder.build(); }
private GraphQLInputType getListInputMapping(final IGraphQLObjectMapper graphQLObjectMapper, final Type type) { ParameterizedType pType = (ParameterizedType) type; GraphQLInputObjectType objectType = GraphQLInputObjectType.newInputObject() .name(graphQLObjectMapper.getTypeNamingStrategy().getTypeName(graphQLObjectMapper, type)) .field(GraphQLInputObjectField.newInputObjectField() .name(KEY_NAME) .type(graphQLObjectMapper.getInputType(pType.getActualTypeArguments()[0])) .build()) .field(GraphQLInputObjectField.newInputObjectField() .name(VALUE_NAME) .type(graphQLObjectMapper.getInputType(pType.getActualTypeArguments()[1])) .build()) .build(); return new GraphQLList(objectType); }
@Test public void wireGraphQLInputObjectField_validLocations_correctMethodIsCalled() throws Exception { // Arrange AnnotationsDirectiveWiring upperWiring = mock(AnnotationsDirectiveWiring.class); GraphQLInputObjectField directiveContainer = GraphQLInputObjectField.newInputObjectField().name("asdf") .type(GraphQLInputObjectType.newInputObject().name("dfdf").build()).build(); AnnotationsWiringEnvironmentImpl upperCaseEnv = new AnnotationsWiringEnvironmentImpl(directiveContainer, directiveContainer.getDirective("upperCase")); when(upperWiring.onInputObjectField(upperCaseEnv)).thenReturn(directiveContainer); HashMap<GraphQLDirective, AnnotationsDirectiveWiring> map = new HashMap<>(); GraphQLDirective upperCase = newDirective().name("upperCase").validLocations(Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION).build(); map.put(upperCase, upperWiring); // Act directiveWirer.wire(directiveContainer, map); // Assert verify(upperWiring).onInputObjectField(upperCaseEnv); }
@Test public void testDecoratedFieldWithArguments_directiveArgumentIsNotAScalarType_throwAGraphQLAnnotationsException() throws Exception { // Arrange ProcessingElementsContainer processingElementsContainer = new ProcessingElementsContainer(); GraphQLInputObjectType inputField = GraphQLInputObjectType.newInputObject().name("inputField").build(); GraphQLDirective upperCase = newDirective().name("upperCase").argument(builder -> builder.name("arg").type(inputField)).build(); processingElementsContainer.getDirectiveRegistry().put("upperCase", upperCase); DirectivesBuilder directivesBuilder = new DirectivesBuilder(this.getClass().getField("decoratedFieldWithArguments"), processingElementsContainer); // Act try { directivesBuilder.build(); throw new Exception(); } catch (GraphQLAnnotationsException e) { assertEquals(e.getMessage(), "Directive argument type must be a scalar!"); } }
private GraphQLInputType mapEntry(GraphQLInputType keyType, GraphQLInputType valueType, BuildContext buildContext) { String typeName = "mapEntry_" + getTypeName(keyType) + "_" + getTypeName(valueType) + "_input"; if (buildContext.typeCache.contains(typeName)) { return new GraphQLTypeReference(typeName); } buildContext.typeCache.register(typeName); return newInputObject() .name(typeName) .description("Map entry input") .field(newInputObjectField() .name("key") .description("Map key input") .type(keyType) .build()) .field(newInputObjectField() .name("value") .description("Map value input") .type(valueType) .build()) .build(); }