FilesExpand file tree

 master

/

ParserOptions.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

170 lines (141 loc) · 5.73 KB

 master

/

ParserOptions.java

Copy path

Top

File metadata and controls

• Code
• Blame

170 lines (141 loc) · 5.73 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

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

package graphql.parser;

import graphql.PublicApi;

import java.util.function.Consumer;

import static graphql.Assert.assertNotNull;

/**

* Options that control how the {@link Parser} behaves.

*/

@PublicApi

public class ParserOptions {

/**

* An graphql hacking vector is to send nonsensical queries that burn lots of parsing CPU time and burn

* memory representing a document that wont ever execute. To prevent this for most users, graphql-java

* set this value to 15000. ANTLR parsing time is linear to the number of tokens presented. The more you

* allow the longer it takes.

*

* If you want to allow more, then {@link #setDefaultParserOptions(ParserOptions)} allows you to change this

* JVM wide.

*/

public static int MAX_QUERY_TOKENS = 15000;

private static ParserOptions defaultJvmParserOptions = newParserOptions()

.captureIgnoredChars(false)

.captureSourceLocation(true)

.maxTokens(MAX_QUERY_TOKENS) // to prevent a billion laughs style attacks, we set a default for graphql-java

.build();

/**

* By default the Parser will not capture ignored characters. A static holds this default

* value in a JVM wide basis options object.

*

* Significant memory savings can be made if we do NOT capture ignored characters,

* especially in SDL parsing.

*

* @return the static default value on whether to capture ignored chars

*

* @see graphql.language.IgnoredChar

* @see graphql.language.SourceLocation

*/

public static ParserOptions getDefaultParserOptions() {

return defaultJvmParserOptions;

}

/**

* By default the Parser will not capture ignored characters. A static holds this default

* value in a JVM wide basis options object.

*

* Significant memory savings can be made if we do NOT capture ignored characters,

* especially in SDL parsing. So we have set this to false by default.

*

* This static can be set to true to allow the behavior of version 16.x or before.

*

* @param options - the new default JVM parser options

*

* @see graphql.language.IgnoredChar

* @see graphql.language.SourceLocation

*/

public static void setDefaultParserOptions(ParserOptions options) {

defaultJvmParserOptions = assertNotNull(options);

}

private final boolean captureIgnoredChars;

private final boolean captureSourceLocation;

private final int maxTokens;

private final ParsingListener parsingListener;

private ParserOptions(Builder builder) {

this.captureIgnoredChars = builder.captureIgnoredChars;

this.captureSourceLocation = builder.captureSourceLocation;

this.maxTokens = builder.maxTokens;

this.parsingListener = builder.parsingListener;

}

/**

* Significant memory savings can be made if we do NOT capture ignored characters,

* especially in SDL parsing. So we have set this to false by default.

*

* @return true if ignored chars are captured in AST nodes

*/

public boolean isCaptureIgnoredChars() {

return captureIgnoredChars;

}

/**

* Memory savings can be made if we do NOT set {@link graphql.language.SourceLocation}s

* on AST nodes, especially in SDL parsing.

*

* @return true if {@link graphql.language.SourceLocation}s are captured in AST nodes

*

* @see graphql.language.SourceLocation

*/

public boolean isCaptureSourceLocation() {

return captureSourceLocation;

}

/**

* A graphql hacking vector is to send nonsensical queries that burn lots of parsing CPU time and burn

* memory representing a document that won't ever execute. To prevent this you can set a maximum number of parse

* tokens that will be accepted before an exception is thrown and the parsing is stopped.

*

* @return the maximum number of raw tokens the parser will accept, after which an exception will be thrown.

*/

public int getMaxTokens() {

return maxTokens;

}

public ParsingListener getParsingListener() {

return parsingListener;

}

public ParserOptions transform(Consumer<Builder> builderConsumer) {

Builder builder = new Builder(this);

builderConsumer.accept(builder);

return builder.build();

}

public static Builder newParserOptions() {

return new Builder();

}

public static class Builder {

private boolean captureIgnoredChars = false;

private boolean captureSourceLocation = true;

private int maxTokens = MAX_QUERY_TOKENS;

private ParsingListener parsingListener = ParsingListener.NOOP;

Builder() {

}

Builder(ParserOptions parserOptions) {

this.captureIgnoredChars = parserOptions.captureIgnoredChars;

this.captureSourceLocation = parserOptions.captureSourceLocation;

this.maxTokens = parserOptions.maxTokens;

this.parsingListener = parserOptions.parsingListener;

}

public Builder captureIgnoredChars(boolean captureIgnoredChars) {

this.captureIgnoredChars = captureIgnoredChars;

return this;

}

public Builder captureSourceLocation(boolean captureSourceLocation) {

this.captureSourceLocation = captureSourceLocation;

return this;

}

public Builder maxTokens(int maxTokens) {

this.maxTokens = maxTokens;

return this;

}

public Builder parsingListener(ParsingListener parsingListener) {

this.parsingListener = assertNotNull(parsingListener);

return this;

}

public ParserOptions build() {

return new ParserOptions(this);

}

}

}