apollo-compiler 1.31.1

A compiler for the GraphQL query language.
Documentation 
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

use apollo_compiler::parser::Parser;

#[test]
fn it_errors_when_selection_set_recursion_limit_exceeded() {
    let input = r#"
    query {
      Q1 {
        url {
          hostname
        }
      }
    }
    "#;
    let mut parser = Parser::new().recursion_limit(1);
    let invalid = parser.parse_ast(input, "doc.graphql").unwrap_err();
    assert_eq!(parser.recursion_reached(), 2);
    let errors = invalid.errors.to_string();
    assert!(
        errors.contains("parser recursion limit reached"),
        "{errors}"
    );
    assert_eq!(invalid.partial.definitions.len(), 1);
}

#[test]
fn it_passes_when_selection_set_recursion_limit_is_not_exceeded() {
    let input = r#"
    query {
      Q1 {
        Q2 {
          Q3 {
            url
          }
        }
      }
    }
    "#;
    let mut parser = Parser::new().recursion_limit(7);
    let ast = parser.parse_ast(input, "doc.graphql").unwrap();
    assert_eq!(parser.recursion_reached(), 4);
    assert_eq!(ast.definitions.len(), 1);
}

#[test]
fn it_errors_when_selection_set_token_limit_is_exceeded() {
    let schema = r#"
    type Query {
      field(arg1: Int, arg2: Int, arg3: Int, arg4: Int, arg5: Int, arg6: Int): Int
    }
    "#;
    let invalid = Parser::new()
        .token_limit(18)
        .parse_ast(schema, "doc.graphql")
        .unwrap_err();
    let errors = invalid.errors.to_string();
    assert!(
        errors.contains("token limit reached, aborting lexing"),
        "{errors}"
    );
    assert!(errors.contains("doc.graphql:3:30"), "{errors}");
    assert_eq!(invalid.partial.definitions.len(), 1);
}

#[test]
fn it_errors_with_multiple_limits() {
    let input = r#"
        query {
            a {
                a {
                    a {
                        a
                    }
                }
            }
        }
    "#;
    let invalid = Parser::new()
        .token_limit(22)
        .recursion_limit(10)
        .parse_ast(input, "doc.graphql")
        .unwrap_err();
    let errors = invalid.errors.to_string();
    assert!(
        errors.contains("token limit reached, aborting lexing"),
        "{errors}"
    );
    assert!(errors.contains("doc.graphql:8:18"), "{errors}");

    let invalid = Parser::new()
        .token_limit(200)
        .recursion_limit(3)
        .parse_ast(input, "doc.graphql")
        .unwrap_err();
    let errors = invalid.errors.to_string();
    assert!(
        errors.contains("parser recursion limit reached"),
        "{errors}"
    );
    assert!(errors.contains("doc.graphql:6:25"), "{errors}");
}