apollo-federation 2.13.1

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

use apollo_compiler::ast::OperationType;

use crate::error::CompositionError;
use crate::subgraph::typestate::HasMetadata;
use crate::subgraph::typestate::Subgraph;

/// We rename root types to their default names prior to merging, so we should never get an error
/// from this validation.
///
/// See [`crate::subgraph::typestate::Subgraph<Upgraded>::normalize_root_types()`].
pub(crate) fn validate_consistent_root_fields<T: HasMetadata>(
    subgraphs: &[Subgraph<T>],
) -> Result<(), Vec<CompositionError>> {
    if subgraphs.is_empty() {
        return Ok(());
    }

    let mut errors = Vec::with_capacity(3);
    if !is_operation_name_consistent(OperationType::Mutation, subgraphs) {
        errors.push(CompositionError::InternalError {
            message: "Should not have incompatible root type for Mutation".to_string(),
        });
    }
    if !is_operation_name_consistent(OperationType::Query, subgraphs) {
        errors.push(CompositionError::InternalError {
            message: "Should not have incompatible root type for Query".to_string(),
        });
    }
    if !is_operation_name_consistent(OperationType::Subscription, subgraphs) {
        errors.push(CompositionError::InternalError {
            message: "Should not have incompatible root type for Subscription".to_string(),
        });
    }

    if errors.is_empty() {
        Ok(())
    } else {
        Err(errors)
    }
}

fn is_operation_name_consistent<T: HasMetadata>(
    operation_type: OperationType,
    subgraphs: &[Subgraph<T>],
) -> bool {
    let mut operation_name = None;

    for subgraph in subgraphs {
        if let Some(name) = subgraph.schema().schema().root_operation(operation_type) {
            if let Some(existing_name) = operation_name {
                if existing_name != name {
                    return false;
                }
            } else {
                operation_name = Some(name);
            }
        }
    }

    true
}

#[cfg(test)]
mod tests {
    use itertools::Itertools;

    use super::*;
    use crate::subgraph::typestate::Subgraph;

    #[test]
    fn reports_inconsistent_root_field_types() {
        let s1 = Subgraph::parse(
            "s1",
            "",
            r#"
            type Mutation {
                data: String
            }

            type Query {
                data: String
            }

            type Subscription {
                data: String
            }
        "#,
        )
        .unwrap()
        .assume_expanded()
        .unwrap()
        .assume_validated();

        let s2 = Subgraph::parse(
            "s2",
            "",
            r#"
            extend schema {
                mutation: MyMutation
                query: MyQuery
                subscription: MySubscription
            }

            type MyMutation {
                data: String
            }

            type MyQuery {
                data: String
            }

            type MySubscription {
                data: String
            }
        "#,
        )
        .unwrap()
        .assume_expanded()
        .unwrap()
        .assume_validated();

        let res = validate_consistent_root_fields(&[s1, s2]).unwrap_err();
        let errors = res.iter().map(|e| e.to_string()).collect_vec();
        assert_eq!(
            errors,
            vec![
                "Should not have incompatible root type for Mutation".to_string(),
                "Should not have incompatible root type for Query".to_string(),
                "Should not have incompatible root type for Subscription".to_string()
            ]
        );
    }
}