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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use graphql_tools::parser::query::{
    Definition, Directive, FragmentDefinition, Mutation, OperationDefinition, Query, Selection,
    SelectionSet, Subscription, Value,
};

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

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

    Ok(())
}

#[inline]
fn handle_selection_set<'a>(
    selection_set: &mut SelectionSet<'a, String>,
) -> Result<(), NormalizationError> {
    if selection_set.items.is_empty() {
        return Ok(());
    }

    let original_items = std::mem::take(&mut selection_set.items);
    let mut new_items = Vec::with_capacity(original_items.len());

    for mut current_item_candidate in original_items {
        let should_add = match &mut current_item_candidate {
            Selection::Field(field) => {
                let should_add = should_keep(&field.directives);

                if should_add {
                    handle_selection_set(&mut field.selection_set)?;
                }

                should_add
            }
            Selection::InlineFragment(inline_frag) => {
                let should_add = should_keep(&inline_frag.directives);

                if should_add {
                    handle_selection_set(&mut inline_frag.selection_set)?;
                }

                should_add
            }
            Selection::FragmentSpread(spread) => should_keep(&spread.directives),
        };

        if should_add {
            new_items.push(current_item_candidate);
        }
    }

    selection_set.items = new_items;

    Ok(())
}

#[inline]
fn should_keep(directives: &Vec<Directive<'_, String>>) -> bool {
    if extract_condition_directive("skip", directives).is_some_and(|skip| skip) {
        return false;
    }

    if extract_condition_directive("include", directives).is_some_and(|include| !include) {
        return false;
    }

    true
}

#[inline]
fn extract_condition_directive(
    directive_name: &str,
    directives: &Vec<Directive<'_, String>>,
) -> Option<bool> {
    directives.iter().find_map(|d| {
        if d.name != directive_name {
            return None;
        }
        d.arguments.iter().find_map(|(name, value)| {
            if name != "if" {
                return None;
            }

            match value {
                Value::Boolean(b) => Some(*b),
                _ => None,
            }
        })
    })
}