/** * This helps you transform the current GraphQLInterfaceType 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 GraphQLInterfaceType transform(Consumer<Builder> builderConsumer) { Builder builder = newInterface(this); builderConsumer.accept(builder); return builder.build(); }
GraphQLInterfaceType interfaceType = builder.build(); if (!buildCtx.codeRegistry.hasTypeResolver(interfaceType.getName())) { TypeResolver typeResolver = getTypeResolverForInterface(buildCtx, typeDefinition);
@Override public graphql.schema.GraphQLType getInterface(Class<?> iface) throws GraphQLAnnotationsException { String typeName = getTypeName(iface); graphql.schema.GraphQLType type = typeRegistry.get(typeName); if (type != null) { // type already exists, do not build a new new one return type; } if (iface.getAnnotation(GraphQLUnion.class) != null) { type = getUnionBuilder(iface).build(); } else if (!iface.isAnnotationPresent(GraphQLTypeResolver.class)) { type = getObject(iface); } else { type = getIfaceBuilder(iface).build(); } typeRegistry.put(typeName, type); return type; }
.fields(graphQLFieldDefinitions) .typeResolver(new CompleteObjectTreeTypeResolver(objectTypeResolverMap)) .build();
type = new UnionBuilder(graphQLObjectInfoRetriever).getUnionBuilder(object, container).build(); } else if (object.isAnnotationPresent(GraphQLTypeResolver.class)) { type = new InterfaceBuilder(graphQLObjectInfoRetriever, graphQLFieldRetriever, extensionsHandler).getInterfaceBuilder(object, container).build(); } else if (Enum.class.isAssignableFrom(object)) { type = new EnumBuilder(graphQLObjectInfoRetriever).getEnumBuilder(object).build();
.typeResolver(this) .field(GraphQLFieldDefinition.newFieldDefinition().name("id").type(Scalars.GraphQLString).build()) .build());
GraphQLInterfaceType interfaceType = builder.build(); if (!buildCtx.codeRegistry.hasTypeResolver(interfaceType.getName())) { TypeResolver typeResolver = getTypeResolverForInterface(buildCtx, typeDefinition);
protected GraphQLInterfaceType generateInterfaceType(Object object) { List<GraphQLFieldDefinition> fieldDefinitions = getOutputFieldDefinitions(object); if (fieldDefinitions == null || fieldDefinitions.isEmpty()) { return null; } String name = getGraphQLTypeNameOrIdentityCode(object); TypeResolver typeResolver = getTypeResolver(object); String description = getTypeDescription(object); if (name == null || fieldDefinitions == null || typeResolver == null) { return null; } GraphQLInterfaceType.Builder builder = GraphQLInterfaceType.newInterface() .description(description) .fields(fieldDefinitions) .name(name) .typeResolver(typeResolver); return builder.build(); }
@Test public void wireGraphQLInterfaceType_validLocations_correctMethodIsCalled() throws Exception { // Arrange AnnotationsDirectiveWiring upperWiring = mock(AnnotationsDirectiveWiring.class); GraphQLInterfaceType directiveContainer = GraphQLInterfaceType.newInterface().name("asdf").typeResolver(new TypeResolver() { @Override public GraphQLObjectType getType(TypeResolutionEnvironment env) { return null; } }).build(); AnnotationsWiringEnvironmentImpl upperCaseEnv = new AnnotationsWiringEnvironmentImpl(directiveContainer, directiveContainer.getDirective("upperCase")); when(upperWiring.onInterface(upperCaseEnv)).thenReturn(directiveContainer); HashMap<GraphQLDirective, AnnotationsDirectiveWiring> map = new HashMap<>(); GraphQLDirective upperCase = newDirective().name("upperCase").validLocations(Introspection.DirectiveLocation.INTERFACE).build(); map.put(upperCase, upperWiring); // Act directiveWirer.wire(directiveContainer, map); // Assert verify(upperWiring).onInterface(upperCaseEnv); }
@Test(expectedExceptions = InvalidDirectiveLocationException.class) public void wireGraphQLInterfaceType_invalidLocations_exceptionIsThrown() throws Exception { // Arrange AnnotationsDirectiveWiring upperWiring = mock(AnnotationsDirectiveWiring.class); GraphQLInterfaceType directiveContainer = GraphQLInterfaceType.newInterface().name("asdf").typeResolver(new TypeResolver() { @Override public GraphQLObjectType getType(TypeResolutionEnvironment env) { return null; } }).build(); AnnotationsWiringEnvironmentImpl upperCaseEnv = new AnnotationsWiringEnvironmentImpl(directiveContainer, directiveContainer.getDirective("upperCase")); when(upperWiring.onInterface(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 GraphQLType build() { return Types.interfaceTypeBuilder() .name(NAME) .field(Fields.notNullStringField("id")) .typeResolver((env) -> { Object source = env.getObject(); if(source instanceof Element) { Element element = (Element) source; return (GraphQLObjectType) env.getSchema().getType(element.type()); } throw new IllegalArgumentException("Can't resolve type"); }) .build(); }
public Builder type(GraphQLInterfaceType.Builder builder) { return type(builder.build()); }
@Override public GraphQLInterfaceType toGraphQLType(String typeName, AnnotatedType javaType, OperationMapper operationMapper, BuildContext buildContext) { GraphQLInterfaceType.Builder typeBuilder = newInterface() .name(typeName) .description(buildContext.typeInfoGenerator.generateTypeDescription(javaType, buildContext.messageBundle)); List<GraphQLFieldDefinition> fields = objectTypeMapper.getFields(javaType, buildContext, operationMapper); fields.forEach(typeBuilder::field); typeBuilder.typeResolver(buildContext.typeResolver); typeBuilder.withDirective(Directives.mappedType(javaType)); buildContext.directiveBuilder.buildInterfaceTypeDirectives(javaType, buildContext.directiveBuilderParams()).forEach(directive -> typeBuilder.withDirective(operationMapper.toGraphQLDirective(directive, buildContext))); GraphQLInterfaceType type = typeBuilder.build(); registerImplementations(javaType, type, operationMapper, buildContext); return type; }
/** * This helps you transform the current GraphQLInterfaceType 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 GraphQLInterfaceType transform(Consumer<Builder> builderConsumer) { Builder builder = newInterface(this); builderConsumer.accept(builder); return builder.build(); }
public GraphQLInterfaceType nodeInterface(TypeResolver typeResolver) { return newInterface() .name(NODE) .description("An object with an ID") .typeResolver(typeResolver) .field(newFieldDefinition() .name("id") .description("The ID of an object") .type(nonNull(GraphQLID))) .build(); }
public Builder type(GraphQLInterfaceType.Builder builder) { return type(builder.build()); }
public GraphQLInterfaceType nodeInterface(TypeResolver typeResolver) { return newInterface() .name(NODE) .description("An object with an ID") .typeResolver(typeResolver) .field(newFieldDefinition() .name("id") .description("The ID of an object") .type(nonNull(GraphQLID))) .build(); }
void interfaceType() { GraphQLInterfaceType comicCharacter = newInterface() .name("ComicCharacter") .description("A abstract comic character.") .field(newFieldDefinition() .name("name") .description("The name of the character.") .type(GraphQLString)) .build(); }