ok

ok

ok step 1

ok

ok

ok display works

maybeeeeee

ok

ok this is better and more readable

wip

FUCK

fix

ok

fuck this

temp

ok

ok back to all passing expect bench

ok

ok

ok

fix

ok build works

ok

ok

ok

getting there

ok

fix

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 {