libgraphql-parser 0.0.5

A blazing fast, error-focused, lossless GraphQL parser for schema, executable, and mixed documents.
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

//! Property tests verifying round-trip fidelity of the parser.
//!
//! Round-trip testing ensures that:
//! 1. Source-slice round trip: `parse(src).to_source(Some(src))`
//!    reproduces the original source exactly (validates span tracking)
//! 2. Re-parse stability: the reconstructed source parses without
//!    errors (validates `AstNode::to_source` correctness)
//!
//! Written by Claude Code, reviewed by a human.

use proptest::prelude::*;

use crate::ast::AstNode;
use crate::tests::property_tests::generators::documents::arb_executable_document;
use crate::tests::property_tests::generators::documents::arb_schema_document;
use crate::tests::property_tests::proptest_config;
use crate::GraphQLParser;

proptest! {
    #![proptest_config(proptest_config())]

    /// Verifies source-slice round trip for schema documents:
    /// `parse(src).to_source(Some(src))` should reproduce the
    /// original source exactly.
    ///
    /// When `to_source` is given the original source text, it uses
    /// byte spans to slice out the original text — so the output
    /// should be character-for-character identical.
    ///
    /// Written by Claude Code, reviewed by a human.
    #[test]
    fn schema_source_slice_round_trip(source in arb_schema_document(4)) {
        let result = GraphQLParser::new(&source).parse_schema_document();
        prop_assert!(
            !result.has_errors(),
            "Generated schema document should parse without errors.\n\
             Source:\n{}",
            source,
        );
        let doc = result.into_ast();
        let reconstructed = doc.to_source(Some(&source));
        prop_assert_eq!(
            &reconstructed,
            &source,
            "Source-slice round trip failed for schema document.",
        );
    }

    /// Verifies source-slice round trip for executable documents.
    ///
    /// Written by Claude Code, reviewed by a human.
    #[test]
    fn executable_source_slice_round_trip(
        source in arb_executable_document(4)
    ) {
        let result = GraphQLParser::new(&source).parse_executable_document();
        prop_assert!(
            !result.has_errors(),
            "Generated executable document should parse without errors.\n\
             Source:\n{}",
            source,
        );
        let doc = result.into_ast();
        let reconstructed = doc.to_source(Some(&source));
        prop_assert_eq!(
            &reconstructed,
            &source,
            "Source-slice round trip failed for executable document.",
        );
    }

    /// Verifies re-parse stability for schema documents:
    /// `parse(src) -> to_source(Some(src)) -> re-parse -> no errors`.
    ///
    /// Even if `to_source` doesn't produce identical output (e.g., in
    /// synthetic mode without source), the reconstructed text should
    /// still be valid GraphQL.
    ///
    /// Written by Claude Code, reviewed by a human.
    #[test]
    fn schema_reparse_stability(source in arb_schema_document(4)) {
        let result = GraphQLParser::new(&source).parse_schema_document();
        prop_assert!(
            !result.has_errors(),
            "Generated schema document should parse without errors.\n\
             Source:\n{}",
            source,
        );
        let doc = result.into_ast();
        let reconstructed = doc.to_source(Some(&source));
        let reparse_result = GraphQLParser::new(&reconstructed)
            .parse_schema_document();
        prop_assert!(
            !reparse_result.has_errors(),
            "Re-parse of reconstructed schema document failed.\n\
             Original:\n{}\n\n\
             Reconstructed:\n{}\n\n\
             Errors:\n{}",
            source,
            reconstructed,
            reparse_result.formatted_errors(),
        );
    }

    /// Verifies re-parse stability for executable documents.
    ///
    /// Written by Claude Code, reviewed by a human.
    #[test]
    fn executable_reparse_stability(
        source in arb_executable_document(4)
    ) {
        let result = GraphQLParser::new(&source).parse_executable_document();
        prop_assert!(
            !result.has_errors(),
            "Generated executable document should parse without errors.\n\
             Source:\n{}",
            source,
        );
        let doc = result.into_ast();
        let reconstructed = doc.to_source(Some(&source));
        let reparse_result = GraphQLParser::new(&reconstructed)
            .parse_executable_document();
        prop_assert!(
            !reparse_result.has_errors(),
            "Re-parse of reconstructed executable document failed.\n\
             Original:\n{}\n\n\
             Reconstructed:\n{}\n\n\
             Errors:\n{}",
            source,
            reconstructed,
            reparse_result.formatted_errors(),
        );
    }

}