apollo-compiler 1.32.0

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
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

use apollo_compiler::ExecutableDocument;
use apollo_compiler::Schema;
use criterion::*;

fn bench_many_same_field(c: &mut Criterion) {
    let schema =
        Schema::parse_and_validate("type Query { hello: String! }", "schema.graphql").unwrap();
    let query = format!("{{ {} }}", "hello ".repeat(1_000));

    c.bench_function("many_same_field", move |b| {
        b.iter(|| {
            let doc =
                ExecutableDocument::parse_and_validate(&schema, &query, "query.graphql").unwrap();
            std::hint::black_box(doc);
        });
    });
}

fn bench_many_same_nested_field(c: &mut Criterion) {
    let schema = Schema::parse_and_validate(
        "
        type Nested { hello: String! }
        type Query { nested: Nested! }
    ",
        "schema.graphql",
    )
    .unwrap();
    let query = format!("{{ {} }}", "nested { hello } ".repeat(1_000));

    c.bench_function("many_same_nested_field", move |b| {
        b.iter(|| {
            let doc =
                ExecutableDocument::parse_and_validate(&schema, &query, "query.graphql").unwrap();
            std::hint::black_box(doc);
        });
    });
}

fn bench_many_arguments(c: &mut Criterion) {
    let schema =
        Schema::parse_and_validate("type Query { hello: String! }", "schema.graphql").unwrap();
    let args = (0..2_000).fold(String::new(), |mut acc, i| {
        use std::fmt::Write;
        _ = writeln!(&mut acc, "arg{i}: {i}");
        acc
    });
    let field = format!("hello({args})");
    let query = format!("{{ {field} {field} }}");

    c.bench_function("many_arguments", move |b| {
        b.iter(|| {
            // Will return errors but that's cool
            let doc = ExecutableDocument::parse_and_validate(&schema, &query, "query.graphql");
            _ = std::hint::black_box(doc);
        });
    });
}

fn bench_many_types(c: &mut Criterion) {
    let schema = Schema::parse_and_validate(
        "
        interface Abstract {
          field: Abstract
          leaf: Int
        }
        interface Abstract1 {
          field: Abstract
          leaf: Int
        }
        interface Abstract2 {
          field: Abstract
          leaf: Int
        }
        type Concrete1 implements Abstract & Abstract1 {
          field: Abstract
          leaf: Int
        }
        type Concrete2 implements Abstract & Abstract2 {
          field: Abstract
          leaf: Int
        }
        type Query {
            field: Abstract
        }
    ",
        "schema.graphql",
    )
    .unwrap();
    let query = format!(
        "
        fragment multiply on Abstract {{
           field {{
             ... on Abstract1 {{ field {{ leaf }} }}
             ... on Abstract2 {{ field {{ leaf }} }}
             ... on Concrete1 {{ field {{ leaf }} }}
             ... on Concrete2 {{ field {{ leaf }} }}
           }}
        }}

        query DeepAbstractConcrete {{
            {open}{close}
        }}
    ",
        open = "field { ...multiply ".repeat(100),
        close = "}".repeat(100)
    );

    c.bench_function("many_types", move |b| {
        b.iter(|| {
            let doc =
                ExecutableDocument::parse_and_validate(&schema, &query, "query.graphql").unwrap();
            std::hint::black_box(doc);
        });
    });
}

fn bench_many_extensions(c: &mut Criterion) {
    let num_extensions = 10_000;
    let mut schema = String::new();
    schema.push_str("type Query { a: A }\n");
    for i in 1..=num_extensions {
        schema.push_str(&format!("interface I{i} {{ f{i}: String }}\n"));
    }
    schema.push_str("type A { f0: String }\n");
    for i in 1..=num_extensions {
        schema.push_str(&format!(
            "extend type A implements I{i} {{ f{i}: String }}\n"
        ));
    }
    let schema = Schema::parse_and_validate(&schema, "schema.graphql").unwrap();

    let mut query = String::new();
    query.push_str("{ a { ");
    for i in 1..=num_extensions {
        query.push_str(&format!("f{i} "));
    }
    query.push_str("} }");

    c.bench_function("many_extensions", move |b| {
        b.iter(|| {
            let doc =
                ExecutableDocument::parse_and_validate(&schema, &query, "query.graphql").unwrap();
            std::hint::black_box(doc);
        });
    });
}

criterion_group!(
    fields,
    bench_many_same_field,
    bench_many_same_nested_field,
    bench_many_arguments,
    bench_many_types,
    bench_many_extensions,
);
criterion_main!(fields);