FilesExpand file tree

 master

/

TypeMismatchError.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

100 lines (82 loc) · 3.29 KB

 master

/

TypeMismatchError.java

Copy path

Top

File metadata and controls

• Code
• Blame

100 lines (82 loc) · 3.29 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

package graphql;

import graphql.execution.ResultPath;

import graphql.introspection.Introspection;

import graphql.language.SourceLocation;

import graphql.schema.GraphQLEnumType;

import graphql.schema.GraphQLInputObjectType;

import graphql.schema.GraphQLInterfaceType;

import graphql.schema.GraphQLList;

import graphql.schema.GraphQLNonNull;

import graphql.schema.GraphQLObjectType;

import graphql.schema.GraphQLScalarType;

import graphql.schema.GraphQLType;

import graphql.schema.GraphQLUnionType;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import static graphql.Assert.assertNotNull;

import static java.lang.String.format;

@PublicApi

public class TypeMismatchError implements GraphQLError {

private final String message;

private final List<Object> path;

private final GraphQLType expectedType;

public TypeMismatchError(ResultPath path, GraphQLType expectedType) {

this.path = assertNotNull(path).toList();

this.expectedType = assertNotNull(expectedType);

this.message = mkMessage(path, expectedType);

}

private String mkMessage(ResultPath path, GraphQLType expectedType) {

String expectedTypeKind = GraphQLTypeToTypeKindMapping.getTypeKindFromGraphQLType(expectedType).name();

return format("Can't resolve value (%s) : type mismatch error, expected type %s", path, expectedTypeKind);

}

static class GraphQLTypeToTypeKindMapping {

private static final Map<Class<? extends GraphQLType>, Introspection.TypeKind> registry = new LinkedHashMap<Class<? extends GraphQLType>, Introspection.TypeKind>() {{

put(GraphQLEnumType.class, Introspection.TypeKind.ENUM);

put(GraphQLList.class, Introspection.TypeKind.LIST);

put(GraphQLObjectType.class, Introspection.TypeKind.OBJECT);

put(GraphQLScalarType.class, Introspection.TypeKind.SCALAR);

put(GraphQLInputObjectType.class, Introspection.TypeKind.INPUT_OBJECT);

put(GraphQLInterfaceType.class, Introspection.TypeKind.INTERFACE);

put(GraphQLNonNull.class, Introspection.TypeKind.NON_NULL);

put(GraphQLUnionType.class, Introspection.TypeKind.UNION);

}};

private GraphQLTypeToTypeKindMapping() {

}

public static Introspection.TypeKind getTypeKindFromGraphQLType(GraphQLType type) {

return registry.containsKey(type.getClass()) ? registry.get(type.getClass()) : Assert.assertShouldNeverHappen("Unknown kind of type: " + type);

}

}

@Override

public String getMessage() {

return message;

}

@Override

public List<SourceLocation> getLocations() {

return null;

}

@Override

public ErrorType getErrorType() {

return ErrorType.DataFetchingException;

}

@Override

public List<Object> getPath() {

return path;

}

@Override

public String toString() {

return "TypeMismatchError{" +

"path=" + path +

", expectedType=" + expectedType +

'}';

}

@SuppressWarnings("EqualsWhichDoesntCheckParameterClass")

@Override

public boolean equals(Object o) {

return GraphqlErrorHelper.equals(this, o);

}

@Override

public int hashCode() {

return GraphqlErrorHelper.hashCode(this);

}

}