/** * 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 Builder(GraphQLInterfaceType existing) { this.name = existing.getName(); this.description = existing.getDescription(); this.typeResolver = existing.getTypeResolver(); this.definition = existing.getDefinition(); this.fields.putAll(getByName(existing.getFieldDefinitions(), GraphQLFieldDefinition::getName)); this.directives.putAll(getByName(existing.getDirectives(), GraphQLDirective::getName)); }
public GraphQLInterfaceType build() { return new GraphQLInterfaceType(name, description, valuesToList(fields), typeResolver, valuesToList(directives), definition); } }
private static TypeResolver getTypeResolverForInterface(GraphQLInterfaceType parentType, Map<String, TypeResolver> typeResolverMap) { assertNotNull(parentType); TypeResolver typeResolver = typeResolverMap.get(parentType.getName()); if (typeResolver == null) { typeResolver = parentType.getTypeResolver(); } return assertNotNull(typeResolver, "There must be a type resolver for interface " + parentType.getName()); }
private void checkObjectImplementsInterface(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector) { List<GraphQLFieldDefinition> fieldDefinitions = interfaceType.getFieldDefinitions(); for (GraphQLFieldDefinition interfaceFieldDef : fieldDefinitions) { GraphQLFieldDefinition objectFieldDef = objectType.getFieldDefinition(interfaceFieldDef.getName()); if (objectFieldDef == null) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' is missing", objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName()))); } else { checkFieldTypeCompatibility(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef); } } }
private GraphQLInterfaceType buildInterfaceType(BuildContext buildCtx, InterfaceTypeDefinition typeDefinition) { buildCtx.enterNode(typeDefinition); GraphQLInterfaceType.Builder builder = GraphQLInterfaceType.newInterface(); builder.definition(typeDefinition); builder.name(typeDefinition.getName()); if (!buildCtx.codeRegistry.hasTypeResolver(interfaceType.getName())) { TypeResolver typeResolver = getTypeResolverForInterface(buildCtx, typeDefinition); buildCtx.getCodeRegistry().typeResolver(interfaceType, typeResolver); interfaceType = interfaceType.transform(interfaceBuilder -> interfaceBuilder.field(fieldDefinition));
@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); }
public Builder typeResolverIfAbsent(GraphQLInterfaceType parentType, TypeResolver typeResolver) { typeResolverMap.putIfAbsent(parentType.getName(), typeResolver); return this; }
private GraphQLFieldDefinition buildRelayMutation(Method method, ProcessingElementsContainer container, GraphQLFieldDefinition.Builder builder, GraphQLOutputType outputType, List<GraphQLArgument> args) { GraphQLFieldDefinition relayFieldDefinition; if (!(outputType instanceof GraphQLObjectType || outputType instanceof GraphQLInterfaceType)) { throw new RuntimeException("outputType should be an object or an interface"); } StringBuilder titleBuffer = new StringBuilder(method.getName()); titleBuffer.setCharAt(0, Character.toUpperCase(titleBuffer.charAt(0))); String title = titleBuffer.toString(); List<GraphQLFieldDefinition> fieldDefinitions = outputType instanceof GraphQLObjectType ? ((GraphQLObjectType) outputType).getFieldDefinitions() : ((GraphQLInterfaceType) outputType).getFieldDefinitions(); relayFieldDefinition = container.getRelay().mutationWithClientMutationId(title, method.getName(), args.stream(). map(t -> newInputObjectField().name(t.getName()).type(t.getType()).description(t.getDescription()).build()). collect(Collectors.toList()), fieldDefinitions, new StaticDataFetcher(null)); builder.argument(relayFieldDefinition.getArguments()).type(relayFieldDefinition.getType()); return relayFieldDefinition; }
public static boolean isRelayNodeInterface(GraphQLType node) { return node instanceof GraphQLInterfaceType && node.getName().equals(Relay.NODE) && ((GraphQLInterfaceType) node).getFieldDefinitions().size() == 1 && ((GraphQLInterfaceType) node).getFieldDefinition(GraphQLId.RELAY_ID_FIELD_NAME) != null && isRelayId(((GraphQLInterfaceType) node).getFieldDefinition(GraphQLId.RELAY_ID_FIELD_NAME)); }
private TypePrinter<GraphQLInterfaceType> interfacePrinter() { return (out, type, visibility) -> { if (isIntrospectionType(type)) { return; } printComments(out, type, ""); out.format("interface %s%s {\n", type.getName(), directivesString(type.getDirectives())); visibility.getFieldDefinitions(type) .stream() .sorted(Comparator.comparing(GraphQLFieldDefinition::getName)) .forEach(fd -> { printComments(out, fd, " "); out.format(" %s%s: %s%s\n", fd.getName(), argsString(fd.getArguments()), typeString(fd.getType()), directivesString(fd.getDirectives())); }); out.format("}\n\n"); }; }
/** * @param name the name * @param description the description * @param fieldDefinitions the fields * @param typeResolver the type resolver function * @param directives the directives on this type element * @param definition the AST definition * * @deprecated use the {@link #newInterface()} builder pattern instead, as this constructor will be made private in a future version. */ @Internal @Deprecated public GraphQLInterfaceType(String name, String description, List<GraphQLFieldDefinition> fieldDefinitions, TypeResolver typeResolver, List<GraphQLDirective> directives, InterfaceTypeDefinition definition) { assertValidName(name); assertNotNull(fieldDefinitions, "fieldDefinitions can't null"); assertNotNull(directives, "directives cannot be null"); this.name = name; this.description = description; buildDefinitionMap(sortGraphQLTypes(fieldDefinitions)); this.typeResolver = typeResolver; this.definition = definition; this.directives = directives; }
} else if (descriptionHolder instanceof GraphQLInterfaceType) { GraphQLInterfaceType type = (GraphQLInterfaceType) descriptionHolder; return descriptionAndComments(type::getDescription, type::getDefinition, () -> type.getDefinition().getDescription()); } else if (descriptionHolder instanceof GraphQLScalarType) { GraphQLScalarType type = (GraphQLScalarType) descriptionHolder;
private GraphQLInterfaceType buildInterfaceType(BuildContext buildCtx, InterfaceTypeDefinition typeDefinition) { buildCtx.enterNode(typeDefinition); GraphQLInterfaceType.Builder builder = GraphQLInterfaceType.newInterface(); builder.definition(typeDefinition); builder.name(typeDefinition.getName()); if (!buildCtx.codeRegistry.hasTypeResolver(interfaceType.getName())) { TypeResolver typeResolver = getTypeResolverForInterface(buildCtx, typeDefinition); buildCtx.getCodeRegistry().typeResolver(interfaceType, typeResolver); interfaceType = interfaceType.transform(interfaceBuilder -> interfaceBuilder.field(fieldDefinition));
@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); }
private void checkObjectImplementsInterface(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector) { List<GraphQLFieldDefinition> fieldDefinitions = interfaceType.getFieldDefinitions(); for (GraphQLFieldDefinition interfaceFieldDef : fieldDefinitions) { GraphQLFieldDefinition objectFieldDef = objectType.getFieldDefinition(interfaceFieldDef.getName()); if (objectFieldDef == null) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' is missing", objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName()))); } else { checkFieldTypeCompatibility(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef); } } }
public Builder typeResolver(GraphQLInterfaceType parentType, TypeResolver typeResolver) { typeResolverMap.put(parentType.getName(), typeResolver); return this; }
@Test public void test() { GraphQLInterfaceRetriever graphQLInterfaceRetriever = GraphQLAnnotations.getInstance().getObjectHandler().getTypeRetriever().getGraphQLInterfaceRetriever(); GraphQLInterfaceType iface = (GraphQLInterfaceType) graphQLInterfaceRetriever.getInterface(TestIface.class, GraphQLAnnotations.getInstance().getContainer()); List<GraphQLFieldDefinition> fields = iface.getFieldDefinitions(); assertEquals(fields.size(), 1); assertEquals(fields.get(0).getName(), "value"); }
@Override public TraversalControl visitGraphQLInterfaceType(GraphQLInterfaceType node, TraverserContext<GraphQLType> context) { TypeResolver typeResolver = node.getTypeResolver(); if (typeResolver != null) { codeRegistry.typeResolverIfAbsent(node, typeResolver); } assertTrue(codeRegistry.getTypeResolver(node) != null, "You MUST provide a type resolver for the interface type '" + node.getName() + "'"); return CONTINUE; }
private TypePrinter<GraphQLInterfaceType> interfacePrinter() { return (out, type, visibility) -> { if (isIntrospectionType(type)) { return; } SchemaPrinterComparatorEnvironment environment = SchemaPrinterComparatorEnvironment.newEnvironment() .parentType(GraphQLInterfaceType.class) .elementType(GraphQLFieldDefinition.class) .build(); Comparator<? super GraphQLType> comparator = options.comparatorRegistry.getComparator(environment); printComments(out, type, ""); out.format("interface %s%s {\n", type.getName(), directivesString(GraphQLInterfaceType.class, type.getDirectives())); visibility.getFieldDefinitions(type) .stream() .sorted(comparator) .forEach(fd -> { printComments(out, fd, " "); out.format(" %s%s: %s%s\n", fd.getName(), argsString(GraphQLFieldDefinition.class, fd.getArguments()), typeString(fd.getType()), directivesString(GraphQLFieldDefinition.class, fd.getDirectives())); }); out.format("}\n\n"); }; }