hive-router 0.2.0

GraphQL router for Federation, part of the Hive platform
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

use graphql_tools::parser::query::{
    Definition, Field, InlineFragment, OperationDefinition, Selection, SelectionSet,
};

use crate::query_planner::ast::normalization::{
    context::NormalizationContext, error::NormalizationError,
};

#[inline]
pub fn normalize_fields(ctx: &mut NormalizationContext) -> Result<(), NormalizationError> {
    for def in ctx.document.definitions.iter_mut() {
        match def {
            Definition::Operation(ref mut op) => match op {
                OperationDefinition::Query(ref mut q) => {
                    normalize_selection_set(&mut q.selection_set)?;
                }
                OperationDefinition::Mutation(ref mut m) => {
                    normalize_selection_set(&mut m.selection_set)?;
                }
                OperationDefinition::Subscription(ref mut s) => {
                    normalize_selection_set(&mut s.selection_set)?;
                }
                OperationDefinition::SelectionSet(ref mut s) => {
                    normalize_selection_set(s)?;
                }
            },
            Definition::Fragment(ref mut fr) => {
                normalize_selection_set(&mut fr.selection_set)?;
            }
        }
    }

    Ok(())
}

#[inline]
fn normalize_selection_set<'b, 'a>(
    selection_set: &'b mut SelectionSet<'a, String>,
) -> Result<(), NormalizationError> {
    for item in selection_set.items.iter_mut() {
        match item {
            Selection::Field(ref mut field) => {
                drop_name_equal_alias(field)?;
                sort_arguments(field)?;
                sort_field_directives(field)?;
            }
            Selection::InlineFragment(ref mut fr) => {
                normalize_selection_set(&mut fr.selection_set)?;
                sort_fragment_directives(fr)?;
            }
            Selection::FragmentSpread(_) => {
                // fragment definitions are handled at top level
            }
        }
    }

    Ok(())
}

#[inline]
fn drop_name_equal_alias<'b, 'a>(
    field: &'b mut Field<'a, String>,
) -> Result<(), NormalizationError> {
    if field
        .alias
        .as_ref()
        .is_none_or(|alias| alias != &field.name)
    {
        return Ok(());
    }

    field.alias = None;

    Ok(())
}

#[inline]
fn sort_arguments<'b, 'a>(field: &'b mut Field<'a, String>) -> Result<(), NormalizationError> {
    field.arguments.sort_by(|(a, _), (b, _)| a.cmp(b));

    Ok(())
}

#[inline]
fn sort_field_directives<'b, 'a>(
    field: &'b mut Field<'a, String>,
) -> Result<(), NormalizationError> {
    field.directives.sort_by(|a, b| a.name.cmp(&b.name));
    Ok(())
}

#[inline]
fn sort_fragment_directives<'b, 'a>(
    fragment: &'b mut InlineFragment<'a, String>,
) -> Result<(), NormalizationError> {
    fragment.directives.sort_by(|a, b| a.name.cmp(&b.name));
    Ok(())
}