FilesExpand file tree

 master

/

NodeUtil.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

104 lines (85 loc) · 3.92 KB

 master

/

NodeUtil.java

Copy path

Top

File metadata and controls

• Code
• Blame

104 lines (85 loc) · 3.92 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

101

102

103

104

package graphql.language;

import graphql.Internal;

import graphql.execution.UnknownOperationException;

import graphql.util.FpKit;

import graphql.util.NodeLocation;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import static graphql.util.FpKit.mergeFirst;

/**

* Helper class for working with {@link Node}s

*/

@Internal

public class NodeUtil {

public static boolean isEqualTo(String thisStr, String thatStr) {

if (null == thisStr) {

if (null != thatStr) {

return false;

}

} else if (!thisStr.equals(thatStr)) {

return false;

}

return true;

}

public static Map<String, Directive> directivesByName(List<Directive> directives) {

return FpKit.getByName(directives, Directive::getName, mergeFirst());

}

public static Map<String, Argument> argumentsByName(List<Argument> arguments) {

return FpKit.getByName(arguments, Argument::getName, mergeFirst());

}

public static class GetOperationResult {

public OperationDefinition operationDefinition;

public Map<String, FragmentDefinition> fragmentsByName;

}

public static Map<String, FragmentDefinition> getFragmentsByName(Document document) {

Map<String, FragmentDefinition> fragmentsByName = new LinkedHashMap<>();

for (Definition definition : document.getDefinitions()) {

if (definition instanceof FragmentDefinition) {

FragmentDefinition fragmentDefinition = (FragmentDefinition) definition;

fragmentsByName.put(fragmentDefinition.getName(), fragmentDefinition);

}

}

return fragmentsByName;

}

public static GetOperationResult getOperation(Document document, String operationName) {

Map<String, FragmentDefinition> fragmentsByName = new LinkedHashMap<>();

Map<String, OperationDefinition> operationsByName = new LinkedHashMap<>();

for (Definition definition : document.getDefinitions()) {

if (definition instanceof OperationDefinition) {

OperationDefinition operationDefinition = (OperationDefinition) definition;

operationsByName.put(operationDefinition.getName(), operationDefinition);

}

if (definition instanceof FragmentDefinition) {

FragmentDefinition fragmentDefinition = (FragmentDefinition) definition;

fragmentsByName.put(fragmentDefinition.getName(), fragmentDefinition);

}

}

if (operationName == null && operationsByName.size() > 1) {

throw new UnknownOperationException("Must provide operation name if query contains multiple operations.");

}

OperationDefinition operation;

if (operationName == null || operationName.isEmpty()) {

operation = operationsByName.values().iterator().next();

} else {

operation = operationsByName.get(operationName);

}

if (operation == null) {

throw new UnknownOperationException(String.format("Unknown operation named '%s'.", operationName));

}

GetOperationResult result = new GetOperationResult();

result.fragmentsByName = fragmentsByName;

result.operationDefinition = operation;

return result;

}

public static void assertNewChildrenAreEmpty(NodeChildrenContainer newChildren) {

if (!newChildren.isEmpty()) {

throw new IllegalArgumentException("Cannot pass non-empty newChildren to Node that doesn't hold children");

}

}

public static Node removeChild(Node node, NodeLocation childLocationToRemove) {

NodeChildrenContainer namedChildren = node.getNamedChildren();

NodeChildrenContainer newChildren = namedChildren.transform(builder -> builder.removeChild(childLocationToRemove.getName(), childLocationToRemove.getIndex()));

return node.withNewChildren(newChildren);

}

}