feat(qp): introduce single/multi state for fetch-step and selections, replace output

Author: dotansimha

bin/dev-cli/src/main.rs

@@ -9,6 +9,7 @@ use query_planner::graph::PlannerOverrideContext;
 use query_planner::planner::best::find_best_combination;
 use query_planner::planner::fetch::fetch_graph::build_fetch_graph_from_query_tree;
 use query_planner::planner::fetch::fetch_graph::FetchGraph;
+use query_planner::planner::fetch::state::MultiTypeFetchStep;
 use query_planner::planner::plan_nodes::QueryPlan;
 use query_planner::planner::query_plan::build_query_plan_from_fetch_graph;
 use query_planner::planner::tree::query_tree::QueryTree;
@@ -124,7 +125,10 @@ fn process_consumer_schema(path: &str) {
     println!("{}", consumer_schema.document);
 }
 
-fn process_fetch_graph(supergraph_path: &str, operation_path: &str) -> FetchGraph {
+fn process_fetch_graph(
+    supergraph_path: &str,
+    operation_path: &str,
+) -> FetchGraph<MultiTypeFetchStep> {
     let (graph, query_tree, supergraph_state) =
         process_merged_tree(supergraph_path, operation_path);
 

lib/query-planner/src/ast/minification/error.rs

@@ -6,6 +6,6 @@ pub enum MinificationError {
     FieldNotFound(String, String),
     #[error("Unsupported fragment spread")]
     UnsupportedFragmentSpread,
-    #[error("Unsupported field in `_entities`: {0}")]
-    UnsupportedFieldInEntities(String),
+    #[error("Unsupported field in `_entities`: {0}.{1}")]
+    UnsupportedFieldInEntities(String, String),
 }

lib/query-planner/src/ast/minification/stats.rs

@@ -90,6 +90,7 @@ fn walk_and_collect_stats(
                                 }
 
                                 return Err(MinificationError::UnsupportedFieldInEntities(
+                                    type_def.name().to_string(),
                                     field.name.clone(),
                                 ));
                             }

lib/query-planner/src/ast/minification/transform.rs

@@ -185,6 +185,7 @@ fn transform_field(
                     }
 
                     return Err(MinificationError::UnsupportedFieldInEntities(
+                        type_name.to_string(),
                         field.name.clone(),
                     ));
                 }

lib/query-planner/src/ast/mismatch_finder.rs

@@ -7,8 +7,8 @@ use crate::{
         merge_path::{MergePath, Segment},
         selection_item::SelectionItem,
         selection_set::{FieldSelection, SelectionSet},
-        type_aware_selection::TypeAwareSelection,
     },
+    planner::fetch::{selections::FetchStepSelections, state::MultiTypeFetchStep},
     state::{
         subgraph_state::{SubgraphDefinition, SubgraphState},
         supergraph_state::{SubgraphName, SupergraphState, TypeNode},
@@ -20,46 +20,42 @@ pub struct SelectionMismatchFinder<'a> {
     supergraph_state: &'a SupergraphState,
 }
 
-type MismatchesFound = Vec<MergePath>;
+type MismatchesFound = Vec<(String, MergePath)>;
 
 impl<'a> SelectionMismatchFinder<'a> {
     pub fn new(supergraph_state: &'a SupergraphState) -> Self {
         Self { supergraph_state }
     }
 
-    #[instrument(level = "trace", skip_all, fields(
-      subgraph_name,
-      selection = format!("{}", selection_set)
-    ))]
+    #[instrument(level = "trace", skip_all, fields(subgraph_name,))]
     pub fn find_mismatches_in_node(
         &self,
         subgraph_name: &SubgraphName,
-        selection_set: &TypeAwareSelection,
+        selections: &FetchStepSelections<MultiTypeFetchStep>,
     ) -> MismatchesFound {
+        let mut mismtaches_found = MismatchesFound::new();
         let subgraph_state = self
             .supergraph_state
             .subgraphs_state
             .get(subgraph_name)
             .unwrap();
 
-        let entrypoint_type = subgraph_state
-            .definitions
-            .get(&selection_set.type_name)
-            .unwrap();
-
-        let mut mismtaches_found = MismatchesFound::new();
-        let start_path = MergePath::default();
-
-        handle_selection_set(
-            self.supergraph_state,
-            subgraph_state,
-            entrypoint_type,
-            &selection_set.selection_set,
-            start_path,
-            &mut mismtaches_found,
-        );
-
-        trace!("found total of {} mismatches", mismtaches_found.len(),);
+        for (definition_name, selection_set) in selections.iter_selections() {
+            let entrypoint_type = subgraph_state.definitions.get(definition_name).unwrap();
+            let start_path = MergePath::default();
+
+            handle_selection_set(
+                definition_name,
+                self.supergraph_state,
+                subgraph_state,
+                entrypoint_type,
+                selection_set,
+                start_path,
+                &mut mismtaches_found,
+            );
+
+            trace!("found total of {} mismatches", mismtaches_found.len());
+        }
 
         mismtaches_found
     }
@@ -73,6 +69,7 @@ impl<'a> SelectionMismatchFinder<'a> {
   selection = format!("{}", selection_set)
 ))]
 fn handle_selection_set<'field, 'schema>(
+    root_def_type_name: &str,
     supergraph_state: &'schema SupergraphState,
     subgraph_state: &'schema SubgraphState,
     parent_def: &'schema SubgraphDefinition,
@@ -105,6 +102,7 @@ fn handle_selection_set<'field, 'schema>(
                     ));
 
                     let next_parent_type_name = handle_field(
+                        root_def_type_name,
                         supergraph_state,
                         type_def,
                         field,
@@ -117,6 +115,7 @@ fn handle_selection_set<'field, 'schema>(
                         next_parent_type_name.and_then(|n| subgraph_state.definitions.get(n))
                     {
                         handle_selection_set(
+                            root_def_type_name,
                             supergraph_state,
                             subgraph_state,
                             next_parent_def,
@@ -156,6 +155,7 @@ fn handle_selection_set<'field, 'schema>(
 ///
 /// Returns the return type of the selection, if the inner selection needs to be processed (in case nested selections are defined).
 fn handle_field<'field, 'schema>(
+    root_def_type_name: &str,
     state: &'schema SupergraphState,
     parent_def: &'schema SubgraphDefinition,
     field: &'field FieldSelection,
@@ -201,7 +201,7 @@ fn handle_field<'field, 'schema>(
                   field_path,
               );
 
-                mismatches_found.push(field_path.clone());
+                mismatches_found.push((root_def_type_name.to_string(), field_path.clone()));
             }
         }
     } else {

lib/query-planner/src/ast/type_aware_selection.rs

@@ -2,18 +2,11 @@ use std::{fmt::Display, hash::Hash};
 
 use crate::ast::{
     merge_path::{Condition, Segment},
-    safe_merge::{AliasesRecords, SafeSelectionSetMerger},
     selection_set::{FieldSelection, InlineFragmentSelection},
 };
 
 use super::{merge_path::MergePath, selection_item::SelectionItem, selection_set::SelectionSet};
 
-#[derive(Debug, Clone, thiserror::Error)]
-pub enum TypeAwareSelectionError {
-    #[error("Failed to locate path '{0}' in selection set '{1}'")]
-    PathNotFound(String, String),
-}
-
 #[derive(Debug, Clone)]
 pub struct TypeAwareSelection {
     pub type_name: String,
@@ -75,62 +68,6 @@ impl TypeAwareSelection {
     pub fn add(&mut self, to_add: &Self) {
         merge_selection_set(&mut self.selection_set, &to_add.selection_set, false);
     }
-
-    pub fn add_at_path(
-        &mut self,
-        to_add: &Self,
-        add_at_fetch_path: MergePath,
-        as_first: bool,
-    ) -> Result<(), TypeAwareSelectionError> {
-        if let Some(source) =
-            find_selection_set_by_path_mut(&mut self.selection_set, &add_at_fetch_path)
-        {
-            merge_selection_set(source, &to_add.selection_set, as_first);
-
-            Ok(())
-        } else {
-            Err(TypeAwareSelectionError::PathNotFound(
-                add_at_fetch_path.to_string(),
-                self.selection_set.to_string(),
-            ))
-        }
-    }
-
-    pub fn add_at_path_and_solve_conflicts(
-        &mut self,
-        to_add: &Self,
-        add_at_fetch_path: MergePath,
-        (self_used_for_requires, other_used_for_requires): (bool, bool),
-        as_first: bool,
-    ) -> Option<AliasesRecords> {
-        if let Some(source) =
-            find_selection_set_by_path_mut(&mut self.selection_set, &add_at_fetch_path)
-        {
-            let mut merger = SafeSelectionSetMerger::default();
-            let aliases_made = merger.merge_selection_set(
-                source,
-                &to_add.selection_set,
-                (self_used_for_requires, other_used_for_requires),
-                as_first,
-            );
-
-            if !aliases_made.is_empty() {
-                return Some(aliases_made);
-            }
-        }
-
-        None
-    }
-
-    pub fn has_typename_at_path(&self, lookup_path: &MergePath) -> bool {
-        find_selection_set_by_path(
-            &self.selection_set,
-            // We pass None for the condition, because we are checking
-            // the presence of __typename at the given path, not type __typename with a condition.
-            &lookup_path.push(Segment::Field("__typename".to_string(), 0, None)),
-        )
-        .is_some()
-    }
 }
 
 fn selection_item_is_subset_of(source: &SelectionItem, target: &SelectionItem) -> bool {
@@ -154,15 +91,15 @@ fn selection_item_is_subset_of(source: &SelectionItem, target: &SelectionItem) -
     }
 }
 
-fn selection_items_are_subset_of(source: &[SelectionItem], target: &[SelectionItem]) -> bool {
+pub fn selection_items_are_subset_of(source: &[SelectionItem], target: &[SelectionItem]) -> bool {
     target.iter().all(|target_node| {
         source
             .iter()
             .any(|source_node| selection_item_is_subset_of(source_node, target_node))
     })
 }
 
-fn merge_selection_set(target: &mut SelectionSet, source: &SelectionSet, as_first: bool) {
+pub fn merge_selection_set(target: &mut SelectionSet, source: &SelectionSet, as_first: bool) {
     if source.items.is_empty() {
         return;
     }
@@ -217,80 +154,6 @@ fn merge_selection_set(target: &mut SelectionSet, source: &SelectionSet, as_firs
     }
 }
 
-pub fn find_selection_set_by_path<'a>(
-    root_selection_set: &'a SelectionSet,
-    path: &MergePath,
-) -> Option<&'a SelectionSet> {
-    let mut current_selection_set = root_selection_set;
-
-    for path_element in path.inner.iter() {
-        match path_element {
-            Segment::List => {
-                continue;
-            }
-            Segment::Cast(type_name, condition) => {
-                let next_selection_set_option =
-                    current_selection_set
-                        .items
-                        .iter()
-                        .find_map(|item| match item {
-                            SelectionItem::Field(_) => None,
-                            SelectionItem::InlineFragment(f) => {
-                                if f.type_condition.eq(type_name)
-                                    && fragment_condition_equal(condition, f)
-                                {
-                                    Some(&f.selections)
-                                } else {
-                                    None
-                                }
-                            }
-                            SelectionItem::FragmentSpread(_) => None,
-                        });
-
-                match next_selection_set_option {
-                    Some(next_set) => {
-                        current_selection_set = next_set;
-                    }
-                    None => {
-                        return None;
-                    }
-                }
-            }
-            Segment::Field(field_name, args_hash, condition) => {
-                let next_selection_set_option =
-                    current_selection_set
-                        .items
-                        .iter()
-                        .find_map(|item| match item {
-                            SelectionItem::Field(field) => {
-                                if &field.name == field_name
-                                    && field.arguments_hash() == *args_hash
-                                    && field_condition_equal(condition, field)
-                                {
-                                    Some(&field.selections)
-                                } else {
-                                    None
-                                }
-                            }
-                            SelectionItem::InlineFragment(..) => None,
-                            SelectionItem::FragmentSpread(_) => None,
-                        });
-
-                match next_selection_set_option {
-                    Some(next_set) => {
-                        current_selection_set = next_set;
-                    }
-                    None => {
-                        return None;
-                    }
-                }
-            }
-        }
-    }
-
-    Some(current_selection_set)
-}
-
 pub fn find_selection_set_by_path_mut<'a>(
     root_selection_set: &'a mut SelectionSet,
     path: &MergePath,

lib/query-planner/src/planner/fetch/error.rs

@@ -1,7 +1,6 @@
 use crate::{
-    ast::type_aware_selection::TypeAwareSelectionError,
     graph::{error::GraphError, node::Node},
-    planner::walker::error::WalkOperationError,
+    planner::{fetch::selections::FetchStepSelectionsError, walker::error::WalkOperationError},
 };
 
 #[derive(Debug, thiserror::Error)]
@@ -47,7 +46,7 @@ pub enum FetchGraphError {
     #[error("Expected @requires")]
     MissingRequires,
     #[error(transparent)]
-    SelectionSetManipulationError(#[from] TypeAwareSelectionError),
+    SelectionSetManipulationError(#[from] FetchStepSelectionsError),
 }
 
 impl From<GraphError> for FetchGraphError {