Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
104 changes: 98 additions & 6 deletions src/main/java/graphql/schema/idl/SchemaGenerator.java
Original file line number Diff line number Diff line change
@@ -1,11 +1,55 @@
package graphql.schema.idl;

import graphql.GraphQLError;
import graphql.language.*;
import graphql.schema.*;
import graphql.language.ArrayValue;
import graphql.language.BooleanValue;
import graphql.language.Comment;
import graphql.language.EnumTypeDefinition;
import graphql.language.EnumValue;
import graphql.language.FieldDefinition;
import graphql.language.FloatValue;
import graphql.language.InputObjectTypeDefinition;
import graphql.language.InputValueDefinition;
import graphql.language.IntValue;
import graphql.language.InterfaceTypeDefinition;
import graphql.language.Node;
import graphql.language.ObjectTypeDefinition;
import graphql.language.ObjectValue;
import graphql.language.OperationTypeDefinition;
import graphql.language.ScalarTypeDefinition;
import graphql.language.SchemaDefinition;
import graphql.language.StringValue;
import graphql.language.Type;
import graphql.language.TypeDefinition;
import graphql.language.TypeExtensionDefinition;
import graphql.language.UnionTypeDefinition;
import graphql.language.Value;
import graphql.schema.DataFetcher;
import graphql.schema.GraphQLArgument;
import graphql.schema.GraphQLEnumType;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLInputObjectField;
import graphql.schema.GraphQLInputObjectType;
import graphql.schema.GraphQLInputType;
import graphql.schema.GraphQLInterfaceType;
import graphql.schema.GraphQLObjectType;
import graphql.schema.GraphQLOutputType;
import graphql.schema.GraphQLScalarType;
import graphql.schema.GraphQLSchema;
import graphql.schema.GraphQLTypeReference;
import graphql.schema.GraphQLUnionType;
import graphql.schema.PropertyDataFetcher;
import graphql.schema.TypeResolver;
import graphql.schema.TypeResolverProxy;
import graphql.schema.idl.errors.SchemaProblem;

import java.util.*;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Stack;

/**
* This can generate a working runtime schema from a compiled type registry and runtime wiring
Expand Down Expand Up @@ -215,13 +259,61 @@ private GraphQLObjectType buildObjectType(BuildContext buildCtx, ObjectTypeDefin
builder.name(typeDefinition.getName());
builder.description(buildDescription(typeDefinition));

typeDefinition.getFieldDefinitions().forEach(fieldDef ->
builder.field(buildField(buildCtx, typeDefinition, fieldDef)));
List<TypeExtensionDefinition> typeExtensions = getTypeExtensionsOf(typeDefinition, buildCtx);

buildObjectTypeFields(buildCtx, typeDefinition, builder, typeExtensions);

buildObjectTypeInterfaces(buildCtx, typeDefinition, builder, typeExtensions);

typeDefinition.getImplements().forEach(type -> builder.withInterface((GraphQLInterfaceType) buildOutputType(buildCtx, type)));
return builder.build();
}

private void buildObjectTypeFields(BuildContext buildCtx, ObjectTypeDefinition typeDefinition, GraphQLObjectType.Builder builder, List<TypeExtensionDefinition> typeExtensions) {
Map<String, GraphQLFieldDefinition> fieldDefinitions = new LinkedHashMap<>();

typeDefinition.getFieldDefinitions().forEach(fieldDef -> {
GraphQLFieldDefinition newFieldDefinition = buildField(buildCtx, typeDefinition, fieldDef);
fieldDefinitions.put(newFieldDefinition.getName(), newFieldDefinition);
});

// an object consists of the fields it gets from its definition AND its type extensions
typeExtensions.forEach(typeExt -> typeExt.getFieldDefinitions().forEach(fieldDef -> {
GraphQLFieldDefinition newFieldDefinition = buildField(buildCtx, typeDefinition, fieldDef);
//
// de-dupe here - pre-flight checks ensure all dupes are of the same type
if (!fieldDefinitions.containsKey(newFieldDefinition.getName())) {
fieldDefinitions.put(newFieldDefinition.getName(), newFieldDefinition);
}
}));

fieldDefinitions.values().forEach(builder::field);
}

private void buildObjectTypeInterfaces(BuildContext buildCtx, ObjectTypeDefinition typeDefinition, GraphQLObjectType.Builder builder, List<TypeExtensionDefinition> typeExtensions) {
Map<String, GraphQLInterfaceType> interfaces = new LinkedHashMap<>();
typeDefinition.getImplements().forEach(type -> {
GraphQLInterfaceType newInterfaceType = buildOutputType(buildCtx, type);
interfaces.put(newInterfaceType.getName(), newInterfaceType);
});

// an object consists of the interfaces it gets from its definition AND its type extensions
typeExtensions.forEach(typeExt -> typeExt.getImplements().forEach(type -> {
GraphQLInterfaceType interfaceType = buildOutputType(buildCtx, type);
//
// de-dupe here - pre-flight checks ensure all dupes are of the same type
if (!interfaces.containsKey(interfaceType.getName())) {
interfaces.put(interfaceType.getName(), interfaceType);
}
}));

interfaces.values().forEach(builder::withInterface);
}

private List<TypeExtensionDefinition> getTypeExtensionsOf(ObjectTypeDefinition objectTypeDefinition, BuildContext buildCtx) {
List<TypeExtensionDefinition> typeExtensionDefinitions = buildCtx.typeRegistry.typeExtensions().get(objectTypeDefinition.getName());
return typeExtensionDefinitions == null ? Collections.emptyList() : typeExtensionDefinitions;
}

private GraphQLInterfaceType buildInterfaceType(BuildContext buildCtx, InterfaceTypeDefinition typeDefinition) {
GraphQLInterfaceType.Builder builder = GraphQLInterfaceType.newInterface();
builder.name(typeDefinition.getName());
Expand Down
99 changes: 95 additions & 4 deletions src/main/java/graphql/schema/idl/SchemaTypeChecker.java
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
package graphql.schema.idl;

import graphql.GraphQLError;
import graphql.language.AstPrinter;
import graphql.language.FieldDefinition;
import graphql.language.InputObjectTypeDefinition;
import graphql.language.InputValueDefinition;
Expand All @@ -13,20 +14,24 @@
import graphql.language.TypeExtensionDefinition;
import graphql.language.TypeName;
import graphql.language.UnionTypeDefinition;
import graphql.schema.idl.errors.MissingInterfaceTypeError;
import graphql.schema.idl.errors.MissingScalarImplementationError;
import graphql.schema.idl.errors.MissingTypeError;
import graphql.schema.idl.errors.MissingTypeResolverError;
import graphql.schema.idl.errors.OperationTypesMustBeObjects;
import graphql.schema.idl.errors.QueryOperationMissingError;
import graphql.schema.idl.errors.SchemaMissingError;
import graphql.schema.idl.errors.SchemaProblem;
import graphql.schema.idl.errors.TypeExtensionFieldRedefinitionError;
import graphql.schema.idl.errors.TypeExtensionMissingBaseTypeError;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
Expand All @@ -39,13 +44,16 @@ public class SchemaTypeChecker {
public List<GraphQLError> checkTypeRegistry(TypeDefinitionRegistry typeRegistry, RuntimeWiring wiring) throws SchemaProblem {
List<GraphQLError> errors = new ArrayList<>();
checkForMissingTypes(errors, typeRegistry);

checkTypeExtensionsHaveCorrespondingType(errors, typeRegistry);
checkTypeExtensionsFieldRedefinition(errors, typeRegistry);

checkSchemaInvariants(errors, typeRegistry);

checkScalarImplementationsArePresent(errors, typeRegistry, wiring);
checkTypeResolversArePresent(errors, typeRegistry, wiring);

return errors;

}

private void checkSchemaInvariants(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry) {
Expand Down Expand Up @@ -73,11 +81,11 @@ private void checkSchemaInvariants(List<GraphQLError> errors, TypeDefinitionRegi

private void checkForMissingTypes(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry) {
// type extensions
Collection<TypeExtensionDefinition> typeExtensions = typeRegistry.typeExtensions().values();
List<TypeExtensionDefinition> typeExtensions = typeRegistry.typeExtensions().values().stream().flatMap(Collection::stream).collect(Collectors.toList());
typeExtensions.forEach(typeExtension -> {

List<Type> implementsTypes = typeExtension.getImplements();
implementsTypes.forEach(checkTypeExists("type extension", typeRegistry, errors, typeExtension));
implementsTypes.forEach(checkInterfaceTypeExists(typeRegistry, errors, typeExtension));

checkFieldTypesPresent(typeRegistry, errors, typeExtension, typeExtension.getFieldDefinitions());

Expand All @@ -91,7 +99,7 @@ private void checkForMissingTypes(List<GraphQLError> errors, TypeDefinitionRegis
objectTypes.forEach(objectType -> {

List<Type> implementsTypes = objectType.getImplements();
implementsTypes.forEach(checkTypeExists("object", typeRegistry, errors, objectType));
implementsTypes.forEach(checkInterfaceTypeExists(typeRegistry, errors, objectType));

checkFieldTypesPresent(typeRegistry, errors, objectType, objectType.getFieldDefinitions());

Expand Down Expand Up @@ -128,6 +136,7 @@ private void checkForMissingTypes(List<GraphQLError> errors, TypeDefinitionRegis
});
}


private void checkScalarImplementationsArePresent(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry, RuntimeWiring wiring) {
typeRegistry.scalars().keySet().forEach(scalarName -> {
if (!wiring.getScalars().containsKey(scalarName)) {
Expand Down Expand Up @@ -175,6 +184,88 @@ private Consumer<Type> checkTypeExists(String typeOfType, TypeDefinitionRegistry
};
}

private Consumer<? super Type> checkInterfaceTypeExists(TypeDefinitionRegistry typeRegistry, List<GraphQLError> errors, TypeDefinition typeDefinition) {
return t -> {
TypeInfo typeInfo = TypeInfo.typeInfo(t);
TypeName unwrapped = typeInfo.getTypeName();
Optional<TypeDefinition> type = typeRegistry.getType(unwrapped);
if (!type.isPresent()) {
errors.add(new MissingInterfaceTypeError("interface", typeDefinition, unwrapped));
} else if (!(type.get() instanceof InterfaceTypeDefinition)) {
errors.add(new MissingInterfaceTypeError("interface", typeDefinition, unwrapped));
}
};
}

/*
A type can re-define a field if its actual the same type, but if they make 'fieldA : String' into
'fieldA : Int' then we cant handle that. Even 'fieldA : String' to 'fieldA: String!' is tough to handle
so we don't
*/
private void checkTypeExtensionsFieldRedefinition(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry) {
Map<String, List<TypeExtensionDefinition>> typeExtensions = typeRegistry.typeExtensions();
typeExtensions.values().forEach(extList -> extList.forEach(typeExtension -> {
//
// first check for field re-defs within a type ext
for (TypeExtensionDefinition otherTypeExt : extList) {
if (otherTypeExt == typeExtension) {
continue;
}
// its the children that matter - the fields cannot be redefined
checkForFieldRedefinition(errors, otherTypeExt, otherTypeExt.getFieldDefinitions(), typeExtension.getFieldDefinitions());
}
//
// then check for field re-defs from the base type
Optional<TypeDefinition> type = typeRegistry.getType(typeExtension.getName());
if (type.isPresent() && type.get() instanceof ObjectTypeDefinition) {
ObjectTypeDefinition baseType = (ObjectTypeDefinition) type.get();

checkForFieldRedefinition(errors, typeExtension, typeExtension.getFieldDefinitions(), baseType.getFieldDefinitions());
}

}));

}

private void checkForFieldRedefinition(List<GraphQLError> errors, TypeDefinition typeDefinition, List<FieldDefinition> fieldDefinitions, List<FieldDefinition> referenceFieldDefinitions) {
Map<String, FieldDefinition> referenceFields = referenceFieldDefinitions.stream()
.collect(Collectors.toMap(
FieldDefinition::getName, Function.identity()
));

fieldDefinitions.forEach(fld -> {
FieldDefinition referenceField = referenceFields.get(fld.getName());
if (referenceFields.containsKey(fld.getName())) {
// ok they have the same field but is it the same type
if (!isSameType(fld.getType(), referenceField.getType())) {
errors.add(new TypeExtensionFieldRedefinitionError(typeDefinition, fld));
}
}
});
}

private boolean isSameType(Type type1, Type type2) {
String s1 = AstPrinter.printAst(type1);
String s2 = AstPrinter.printAst(type2);
return s1.equals(s2);
}

private void checkTypeExtensionsHaveCorrespondingType(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry) {
Map<String, List<TypeExtensionDefinition>> typeExtensions = typeRegistry.typeExtensions();
typeExtensions.forEach((name, extTypeList) -> {
TypeExtensionDefinition extensionDefinition = extTypeList.get(0);
Optional<TypeDefinition> typeDefinition = typeRegistry.getType(new TypeName(name));
if (!typeDefinition.isPresent()) {
errors.add(new TypeExtensionMissingBaseTypeError(extensionDefinition));
} else {
if (!(typeDefinition.get() instanceof ObjectTypeDefinition)) {
errors.add(new TypeExtensionMissingBaseTypeError(extensionDefinition));
}
}
});
}


private Consumer<OperationTypeDefinition> checkOperationTypesExist(TypeDefinitionRegistry typeRegistry, List<GraphQLError> errors) {
return op -> {
TypeName unwrapped = TypeInfo.typeInfo(op.getType()).getTypeName();
Expand Down
26 changes: 19 additions & 7 deletions src/main/java/graphql/schema/idl/TypeDefinitionRegistry.java
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@
public class TypeDefinitionRegistry {

private final Map<String, ScalarTypeDefinition> scalarTypes = new LinkedHashMap<>();
private final Map<String, TypeExtensionDefinition> typeExtensions = new LinkedHashMap<>();
private final Map<String, List<TypeExtensionDefinition>> typeExtensions = new LinkedHashMap<>();
private final Map<String, TypeDefinition> types = new LinkedHashMap<>();
private SchemaDefinition schema;

Expand All @@ -49,9 +49,6 @@ public TypeDefinitionRegistry merge(TypeDefinitionRegistry typeRegistry) throws
Map<String, ScalarTypeDefinition> tempScalarTypes = new LinkedHashMap<>();
typeRegistry.scalarTypes.values().forEach(newEntry -> define(this.scalarTypes, tempScalarTypes, newEntry).ifPresent(errors::add));

Map<String, TypeExtensionDefinition> tempTypeExtensions = new LinkedHashMap<>();
typeRegistry.typeExtensions.values().forEach(newEntry -> define(this.typeExtensions, tempTypeExtensions, newEntry).ifPresent(errors::add));

if (typeRegistry.schema != null && this.schema != null) {
errors.add(new SchemaRedefinitionError(this.schema, typeRegistry.schema));
}
Expand All @@ -63,8 +60,14 @@ public TypeDefinitionRegistry merge(TypeDefinitionRegistry typeRegistry) throws
// ok commit to the merge
this.schema = typeRegistry.schema;
this.types.putAll(tempTypes);
this.typeExtensions.putAll(tempTypeExtensions);
this.scalarTypes.putAll(tempScalarTypes);
//
// merge type extensions since they can be redefined by design
typeRegistry.typeExtensions.entrySet().forEach(newEntry -> {
List<TypeExtensionDefinition> currentList = this.typeExtensions
.computeIfAbsent(newEntry.getKey(), k -> new ArrayList<>());
currentList.addAll(newEntry.getValue());
});

return this;
}
Expand All @@ -79,7 +82,7 @@ public TypeDefinitionRegistry merge(TypeDefinitionRegistry typeRegistry) throws
public Optional<GraphQLError> add(Definition definition) {
if (definition instanceof TypeExtensionDefinition) {
TypeExtensionDefinition newEntry = (TypeExtensionDefinition) definition;
return define(typeExtensions, typeExtensions, newEntry);
return defineExt(typeExtensions, newEntry);
} else if (definition instanceof ScalarTypeDefinition) {
ScalarTypeDefinition newEntry = (ScalarTypeDefinition) definition;
return define(scalarTypes, scalarTypes, newEntry);
Expand Down Expand Up @@ -109,6 +112,11 @@ private <T extends TypeDefinition> Optional<GraphQLError> define(Map<String, T>
return Optional.empty();
}

private Optional<GraphQLError> defineExt(Map<String, List<TypeExtensionDefinition>> typeExtensions, TypeExtensionDefinition newEntry) {
List<TypeExtensionDefinition> currentList = typeExtensions.computeIfAbsent(newEntry.getName(), k -> new ArrayList<>());
currentList.add(newEntry);
return Optional.empty();
}

public Map<String, TypeDefinition> types() {
return new LinkedHashMap<>(types);
Expand All @@ -120,7 +128,7 @@ public Map<String, ScalarTypeDefinition> scalars() {
return scalars;
}

public Map<String, TypeExtensionDefinition> typeExtensions() {
public Map<String, List<TypeExtensionDefinition>> typeExtensions() {
return new LinkedHashMap<>(typeExtensions);
}

Expand All @@ -139,6 +147,10 @@ public boolean hasType(TypeName typeName) {

public Optional<TypeDefinition> getType(Type type) {
String typeName = TypeInfo.typeInfo(type).getName();
return getType(typeName);
}

public Optional<TypeDefinition> getType(String typeName) {
TypeDefinition typeDefinition = types.get(typeName);
if (typeDefinition != null) {
return Optional.of(typeDefinition);
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,14 @@
package graphql.schema.idl.errors;

import graphql.language.TypeDefinition;
import graphql.language.TypeName;

import static java.lang.String.format;

public class MissingInterfaceTypeError extends BaseError {

public MissingInterfaceTypeError(String typeOfType, TypeDefinition typeDefinition, TypeName typeName) {
super(typeDefinition, format("The %s type '%s' is not present when resolving type '%s' %s",
typeOfType, typeName.getName(), typeDefinition.getName(), lineCol(typeDefinition)));
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,6 @@
public class SchemaMissingError extends BaseError {

public SchemaMissingError() {
super(null, "There is no ttop level schema object defined");
super(null, "There is no top level schema object defined");
}
}
Loading