graphql-schema-validation 0.1.3

A spec compliant implementation of GraphQL SDL schema validation
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

use super::*;

/// First pass: resolve all definitions and their extensions.
pub(crate) fn validate_type_definition<'a>(typedef: &'a Positioned<ast::TypeDefinition>, ctx: &mut Context<'a>) {
    let type_name = typedef.node.name.node.as_str();

    if !typedef.node.extend && is_builtin_scalar(type_name) {
        let labels = vec![miette::LabeledSpan::new_with_span(
            None,
            (
                ctx.miette_pos(typedef.node.name.pos),
                miette::SourceOffset::from(typedef.node.name.node.len()),
            ),
        )];

        ctx.push_error(miette::miette! {
            labels = labels,
            "`{type_name}` is a reserved name.",
        });
    }

    if type_name.starts_with("__") {
        diagnostics::double_underscore_name(type_name, typedef.node.name.pos, ctx);
    }

    if typedef.node.extend {
        match &typedef.node.kind {
            ast::TypeKind::Object(obj) => {
                ctx.extended_fields.entry(type_name).or_default().push(&obj.fields);
                ctx.extended_interface_implementations
                    .entry(type_name)
                    .or_default()
                    .extend(obj.implements.iter());
            }
            ast::TypeKind::Interface(iface) => {
                ctx.extended_fields.entry(type_name).or_default().push(&iface.fields);
                ctx.extended_interface_implementations
                    .entry(type_name)
                    .or_default()
                    .extend(iface.implements.iter());
            }
            ast::TypeKind::Enum(enm) => {
                ctx.extended_enums.entry(type_name).or_default().push(&enm.values);
            }
            ast::TypeKind::Union(union) => {
                ctx.extended_unions.entry(type_name).or_default().push(&union.members);
            }
            _ => (),
        }
        return;
    }

    if let Some(existing_typedef) = ctx.definition_names.insert(type_name, typedef) {
        let labels = vec![
            miette::LabeledSpan::new_with_span(
                Some("Previous definition".to_owned()),
                miette::SourceSpan::new(
                    ctx.miette_pos(existing_typedef.node.name.pos),
                    existing_typedef.node.name.node.len().into(),
                ),
            ),
            miette::LabeledSpan::new_with_span(
                Some("Second definition".to_owned()),
                miette::SourceSpan::new(
                    ctx.miette_pos(typedef.node.name.pos),
                    typedef.node.name.node.len().into(),
                ),
            ),
        ];

        ctx.push_error(miette::miette! {
            labels = labels,
            r#"Duplicate definition. There can only be one typed name "{type_name}""#,
        });
    }
}

/// Second pass, after all the definitions have been traversed once.
pub(crate) fn validate_definitions_second_pass<'a>(ast: &'a ast::ServiceDocument, ctx: &mut Context<'a>) {
    for def in &ast.definitions {
        match def {
            ast::TypeSystemDefinition::Schema(_) | ast::TypeSystemDefinition::Directive(_) => (),
            ast::TypeSystemDefinition::Type(typedef) => {
                let type_name = typedef.node.name.node.as_str();
                let is_extension = typedef.node.extend;

                match &typedef.node.kind {
                    ast::TypeKind::Object(obj) if is_extension => {
                        validate_object_extension(type_name, typedef, obj, ctx);
                    }
                    ast::TypeKind::Object(obj) => {
                        validate_object(type_name, typedef, obj, ctx);
                    }

                    ast::TypeKind::Interface(iface) if is_extension => {
                        validate_interface_extension(type_name, typedef, iface, ctx);
                    }
                    ast::TypeKind::Interface(iface) => validate_interface(type_name, typedef, iface, ctx),

                    ast::TypeKind::InputObject(input_object) if is_extension => {
                        validate_input_object_extension(type_name, typedef, input_object, ctx);
                    }
                    ast::TypeKind::InputObject(input_object) => {
                        validate_input_object(type_name, typedef, input_object, ctx);
                    }

                    ast::TypeKind::Union(_) if is_extension => validate_union_extension(type_name, typedef, ctx),
                    ast::TypeKind::Union(union) => {
                        validate_union_members(type_name, typedef, union, ctx);
                    }

                    ast::TypeKind::Enum(_) if is_extension => validate_enum_extension(type_name, typedef, ctx),
                    ast::TypeKind::Enum(enm) => {
                        validate_enum_members(type_name, typedef, enm, ctx);
                    }

                    ast::TypeKind::Scalar if is_extension => validate_scalar_extension(type_name, typedef, ctx),
                    ast::TypeKind::Scalar => (),
                }
            }
        }
    }
}