public Builder possibleType(GraphQLObjectType type) { assertNotNull(type, "possible type can't be null"); types.put(type.getName(), type); return this; }
if (queryType != null && !queryType.getName().equals("Query")) { needsSchemaPrinted = true; if (mutationType != null && !mutationType.getName().equals("Mutation")) { needsSchemaPrinted = true; if (subscriptionType != null && !subscriptionType.getName().equals("Subscription")) { needsSchemaPrinted = true; out.format("schema {\n"); if (queryType != null) { out.format(" query: %s\n", queryType.getName()); out.format(" mutation: %s\n", mutationType.getName()); out.format(" subscription: %s\n", subscriptionType.getName());
/** * Returns true if a specified concrete type is a possible type of a provided abstract type. * If the provided abstract type is: * - an interface, it checks whether the concrete type is one of its implementations. * - a union, it checks whether the concrete type is one of its possible types. * * @param abstractType abstract type either interface or union * @param concreteType concrete type * * @return true if possible type, false otherwise. */ public boolean isPossibleType(GraphQLType abstractType, GraphQLObjectType concreteType) { if (abstractType instanceof GraphQLInterfaceType) { return getImplementations((GraphQLInterfaceType) abstractType).stream() .map(GraphQLType::getName) .anyMatch(name -> concreteType.getName().equals(name)); } else if (abstractType instanceof GraphQLUnionType) { return ((GraphQLUnionType) abstractType).getTypes().stream() .map(GraphQLType::getName) .anyMatch(name -> concreteType.getName().equals(name)); } return assertShouldNeverHappen("Unsupported abstract type %s. Abstract types supported are Union and Interface.", abstractType.getName()); }
public Builder(GraphQLObjectType existing) { name = existing.getName(); description = existing.getDescription(); definition = existing.getDefinition(); fields.putAll(getByName(existing.getFieldDefinitions(), GraphQLFieldDefinition::getName)); interfaces.putAll(getByName(existing.getInterfaces(), GraphQLType::getName)); directives.putAll(getByName(existing.getDirectives(), GraphQLDirective::getName)); }
private TypePrinter<GraphQLObjectType> objectPrinter() { return (out, type, visibility) -> { if (isIntrospectionType(type)) { return; } printComments(out, type, ""); if (type.getInterfaces().isEmpty()) { out.format("type %s%s {\n", type.getName(), directivesString(type.getDirectives())); } else { Stream<String> interfaceNames = type.getInterfaces() .stream() .map(GraphQLType::getName) .sorted(Comparator.naturalOrder()); out.format("type %s implements %s%s {\n", type.getName(), interfaceNames.collect(joining(" & ")), 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); } }
public Builder possibleType(GraphQLObjectType type) { assertNotNull(type, "possible type can't be null"); types.put(type.getName(), type); return this; }
@Override public boolean equals(Object obj) { return obj instanceof GraphQLObjectType && ((GraphQLObjectType) obj).getName().contentEquals(getName()) && ((GraphQLObjectType) obj).getFieldDefinitions().equals(getFieldDefinitions()); } }
public GraphQLObjectTypeWrapper(Class<?> objectClass, GraphQLObjectType objectType) { super(objectType.getName(), objectType.getDescription(), objectType.getFieldDefinitions(), objectType.getInterfaces()); this.objectClass = objectClass; }
@Test public void defaults() { GraphQLObjectType object = GraphQLAnnotations.object(TestDefaults.class); assertEquals(object.getName(), "TestDefaults"); assertNull(object.getDescription()); }
public Builder(GraphQLObjectType existing) { name = existing.getName(); description = existing.getDescription(); definition = existing.getDefinition(); fields.putAll(getByName(existing.getFieldDefinitions(), GraphQLFieldDefinition::getName)); interfaces.putAll(getByName(existing.getInterfaces(), GraphQLType::getName)); directives.putAll(getByName(existing.getDirectives(), GraphQLDirective::getName)); }
@Test public void metainformation() { GraphQLObjectType object = GraphQLAnnotations.object(TestObject.class); assertEquals(object.getName(), "TestObject"); assertEquals(object.getDescription(), "TestObject object"); }
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); } }
private void assertGenericMapTypeMapping(String name, GraphQLOutputType expectedValueType, GraphQLOutputType graphQLOutputType) { GraphQLList listType = (GraphQLList) graphQLOutputType; // verify we contstructed an object from the map with the enum values as fields // and their type the expected value type assertEquals(GraphQLList.class, listType.getClass()); GraphQLObjectType objectType = (GraphQLObjectType) listType.getWrappedType(); assertEquals(name, objectType.getName()); assertNotNull(objectType.getFieldDefinition(MapMapper.KEY_NAME)); assertNotNull(objectType.getFieldDefinition(MapMapper.VALUE_NAME)); assertEquals(expectedValueType.getClass(), objectType.getFieldDefinition(MapMapper.KEY_NAME).getType().getClass()); assertEquals(expectedValueType.getClass(), objectType.getFieldDefinition(MapMapper.VALUE_NAME).getType().getClass()); }
@Test public void testIgnoredFields() { IGraphQLObjectMapper graphQLObjectMapper = newGraphQLObjectMapper(Optional.<ITypeNamingStrategy> absent()); GraphQLObjectType type = (GraphQLObjectType) graphQLObjectMapper.getOutputType(TestIgnoredFields.class); assertEquals(TestIgnoredFields.class.getSimpleName(), type.getName()); assertEquals(1, type.getFieldDefinitions().size()); assertNull(type.getFieldDefinition("keyValueStore")); assertNotNull(type.getFieldDefinition("stringField")); assertEquals("stringField", type.getFieldDefinition("stringField").getName()); assertEquals(Scalars.GraphQLString, type.getFieldDefinition("stringField").getType()); }