public Builder typeResolverIfAbsent(GraphQLInterfaceType parentType, TypeResolver typeResolver) { typeResolverMap.putIfAbsent(parentType.getName(), typeResolver); return this; }
public Builder typeResolver(GraphQLInterfaceType parentType, TypeResolver typeResolver) { typeResolverMap.put(parentType.getName(), typeResolver); return this; }
public Builder withInterface(GraphQLInterfaceType interfaceType) { assertNotNull(interfaceType, "interfaceType can't be null"); this.interfaces.put(interfaceType.getName(), interfaceType); return this; }
/** * This will return the list of {@link graphql.schema.GraphQLObjectType} types that implement the given * interface type. * * @param type interface type to obtain implementations of. * * @return list of types implementing provided interface */ public List<GraphQLObjectType> getImplementations(GraphQLInterfaceType type) { List<GraphQLObjectType> implementations = byInterface.get(type.getName()); return (implementations == null) ? Collections.emptyList() : Collections.unmodifiableList(sortGraphQLTypes(implementations)); }
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 buildObjectTypeInterfaces(BuildContext buildCtx, ObjectTypeDefinition typeDefinition, GraphQLObjectType.Builder builder, List<ObjectTypeExtensionDefinition> extensions) { Map<String, GraphQLOutputType> interfaces = new LinkedHashMap<>(); typeDefinition.getImplements().forEach(type -> { GraphQLOutputType newInterfaceType = buildOutputType(buildCtx, type); interfaces.put(newInterfaceType.getName(), newInterfaceType); }); extensions.forEach(extension -> extension.getImplements().forEach(type -> { GraphQLInterfaceType interfaceType = buildOutputType(buildCtx, type); if (!interfaces.containsKey(interfaceType.getName())) { interfaces.put(interfaceType.getName(), interfaceType); } })); interfaces.values().forEach(interfaze -> { if (interfaze instanceof GraphQLInterfaceType) { builder.withInterface((GraphQLInterfaceType) interfaze); return; } if (interfaze instanceof GraphQLTypeReference) { builder.withInterface((GraphQLTypeReference) interfaze); return; } }); }
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)); }
@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; } 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"); }; }
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 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 void checkFieldTypeCompatibility(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector, GraphQLFieldDefinition interfaceFieldDef, GraphQLFieldDefinition objectFieldDef) { String interfaceFieldDefStr = simplePrint(interfaceFieldDef.getType()); String objectFieldDefStr = simplePrint(objectFieldDef.getType()); if (!isCompatible(interfaceFieldDef.getType(), objectFieldDef.getType())) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' is defined as '%s' type and not as '%s' type", objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName(), objectFieldDefStr, interfaceFieldDefStr))); } else { checkFieldArgumentEquivalence(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef); } }
if (!buildCtx.codeRegistry.hasTypeResolver(interfaceType.getName())) { TypeResolver typeResolver = getTypeResolverForInterface(buildCtx, typeDefinition); buildCtx.getCodeRegistry().typeResolver(interfaceType, typeResolver);
public Builder typeResolverIfAbsent(GraphQLInterfaceType parentType, TypeResolver typeResolver) { typeResolverMap.putIfAbsent(parentType.getName(), typeResolver); return this; }
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 registerImplementations(AnnotatedType javaType, GraphQLInterfaceType type, OperationMapper operationMapper, BuildContext buildContext) { if (isImplementationAutoDiscoveryEnabled(javaType)) { buildContext.implDiscoveryStrategy.findImplementations(javaType, getScanPackages(javaType), buildContext).forEach(impl -> getImplementingType(impl, operationMapper, buildContext) .ifPresent(implType -> buildContext.typeRegistry.registerDiscoveredCovariantType(type.getName(), impl, implType))); } }
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 void checkFieldTypeCompatibility(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector, GraphQLFieldDefinition interfaceFieldDef, GraphQLFieldDefinition objectFieldDef) { String interfaceFieldDefStr = simplePrint(interfaceFieldDef.getType()); String objectFieldDefStr = simplePrint(objectFieldDef.getType()); if (!isCompatible(interfaceFieldDef.getType(), objectFieldDef.getType())) { validationErrorCollector.addError( error(format("object type '%s' does not implement interface '%s' because field '%s' is defined as '%s' type and not as '%s' type", objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName(), objectFieldDefStr, interfaceFieldDefStr))); } else { checkFieldArgumentEquivalence(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef); } }