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

Author: dotansimha

Cargo.lock

@@ -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);
 

bin/dev-cli/src/main.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/error.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/stats.rs

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

lib/query-planner/src/ast/minification/transform.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,43 @@ 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 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 subgraph_state = self
+                .supergraph_state
+                .subgraphs_state
+                .get(subgraph_name)
+                .unwrap();
+
+            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 +70,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 +103,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 +116,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 +156,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 +202,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/mismatch_finder.rs

@@ -2,7 +2,7 @@ use std::{fmt::Display, hash::Hash};
 
 use crate::ast::{
     merge_path::{Condition, Segment},
-    safe_merge::{AliasesRecords, SafeSelectionSetMerger},
+    // safe_merge::{AliasesRecords, SafeSelectionSetMerger},
     selection_set::{FieldSelection, InlineFragmentSelection},
 };
 
@@ -96,31 +96,31 @@ impl TypeAwareSelection {
         }
     }
 
-    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 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(
@@ -154,15 +154,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;
     }