getting there

Author: dotansimha

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/safe_merge.rs

@@ -409,7 +409,7 @@ mod tests {
         let mut merger = SafeSelectionSetMerger::default();
         let merge_locations = merger.merge_selection_set(&mut a, &b, (false, true), false);
         assert_eq!(merge_locations.len(), 1);
-        insta::assert_snapshot!(merge_locations[0].0, @"''->p.a");
+        insta::assert_snapshot!(merge_locations[0].0, @"p.a");
         insta::assert_snapshot!(merge_locations[0].1, @"_internal_qp_alias_0");
     }
 }

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

@@ -268,7 +268,7 @@ fn create_noop_fetch_step(
             selection_set: SelectionSet::default(),
             type_name: "*".to_string(),
         },
-        output_new: FetchStepSelections::empty(),
+        output_new: FetchStepSelections::new_empty(),
         used_for_requires: created_from_requires,
         condition: None,
         kind: FetchStepKind::Root,
@@ -745,10 +745,6 @@ fn process_entity_move_edge(
         fetch_path,
     )?;
 
-    println!(
-        "process_children_for_fetch_steps: output_type_name={}, response_path={}",
-        output_type_name, response_path
-    );
     process_children_for_fetch_steps(
         graph,
         fetch_graph,

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

@@ -57,7 +57,7 @@ impl<State> Display for FetchStepData<State> {
             write!(f, "{}/{} ", def_name, selections)?;
         }
 
-        write!(f, " at $.{}", self.response_path.join("."));
+        write!(f, " at $.{}", self.response_path.join("."))?;
 
         if self.used_for_requires {
             write!(f, " [@requires]")?;
@@ -106,31 +106,13 @@ impl<State> FetchStepData<State> {
     }
 }
 
-impl FetchStepData<SingleTypeFetchStep> {
-    pub fn into_multi_type(self) -> FetchStepData<MultiTypeFetchStep> {
-        FetchStepData::<MultiTypeFetchStep> {
-            service_name: self.service_name,
-            response_path: self.response_path,
-            input: self.input,
-            output_new: self.output_new.into_multi_type(),
-            kind: self.kind,
-            used_for_requires: self.used_for_requires,
-            condition: self.condition,
-            variable_usages: self.variable_usages,
-            variable_definitions: self.variable_definitions,
-            mutation_field_position: self.mutation_field_position,
-            input_rewrites: self.input_rewrites,
-            output_rewrites: self.output_rewrites,
-            internal_aliases_locations: self.internal_aliases_locations,
-        }
-    }
-
+impl FetchStepData<MultiTypeFetchStep> {
     pub fn can_merge(
         &self,
         self_index: NodeIndex,
         other_index: NodeIndex,
         other: &Self,
-        fetch_graph: &FetchGraph<SingleTypeFetchStep>,
+        fetch_graph: &FetchGraph<MultiTypeFetchStep>,
     ) -> bool {
         if self_index == other_index {
             return false;
@@ -191,3 +173,23 @@ impl FetchStepData<SingleTypeFetchStep> {
         true
     }
 }
+
+impl FetchStepData<SingleTypeFetchStep> {
+    pub fn into_multi_type(self) -> FetchStepData<MultiTypeFetchStep> {
+        FetchStepData::<MultiTypeFetchStep> {
+            service_name: self.service_name,
+            response_path: self.response_path,
+            input: self.input,
+            output_new: self.output_new.into_multi_type(),
+            kind: self.kind,
+            used_for_requires: self.used_for_requires,
+            condition: self.condition,
+            variable_usages: self.variable_usages,
+            variable_definitions: self.variable_definitions,
+            mutation_field_position: self.mutation_field_position,
+            input_rewrites: self.input_rewrites,
+            output_rewrites: self.output_rewrites,
+            internal_aliases_locations: self.internal_aliases_locations,
+        }
+    }
+}

lib/query-planner/src/planner/fetch/optimize/apply_internal_aliases_patching.rs

@@ -7,10 +7,10 @@ use crate::{
         selection_item::SelectionItem,
         type_aware_selection::find_selection_set_by_path_mut,
     },
-    planner::fetch::{error::FetchGraphError, fetch_graph::FetchGraph},
+    planner::fetch::{error::FetchGraphError, fetch_graph::FetchGraph, state::MultiTypeFetchStep},
 };
 
-impl FetchGraph {
+impl FetchGraph<MultiTypeFetchStep> {
     /// This method applies internal aliasing for fields in the fetch graph.
     /// In case a fetch step contains a record of alias made to an output field, it needs to be propagated to all descendants steps that depends on this
     /// output field, in multiple locations:
@@ -132,13 +132,7 @@ impl FetchGraph {
                                         new_path.get_mut(segment_idx_to_patch)
                                     {
                                         *name = new_name.clone();
-                                        decendent.response_path = MergePath::new(
-                                            decendent
-                                                .response_path
-                                                .entrypoint_definition_name
-                                                .clone(),
-                                            new_path,
-                                        );
+                                        decendent.response_path = MergePath::new(new_path);
                                     }
                                 }
                             }

lib/query-planner/src/planner/fetch/optimize/deduplicate_and_prune_fetch_steps.rs

@@ -6,10 +6,10 @@ use tracing::{instrument, trace};
 
 use crate::planner::fetch::{
     error::FetchGraphError, fetch_graph::FetchGraph,
-    optimize::utils::is_reachable_via_alternative_upstream_path,
+    optimize::utils::is_reachable_via_alternative_upstream_path, state::MultiTypeFetchStep,
 };
 
-impl FetchGraph {
+impl FetchGraph<MultiTypeFetchStep> {
     /// Removes redundant direct dependencies from a FetchStep graph.
     ///
     /// ```text

lib/query-planner/src/planner/fetch/optimize/merge_children_with_parents.rs

@@ -5,9 +5,10 @@ use tracing::{instrument, trace};
 
 use crate::planner::fetch::{
     error::FetchGraphError, fetch_graph::FetchGraph, optimize::utils::perform_fetch_step_merge,
+    state::MultiTypeFetchStep,
 };
 
-impl FetchGraph {
+impl FetchGraph<MultiTypeFetchStep> {
     #[instrument(level = "trace", skip_all)]
     pub(crate) fn merge_children_with_parents(&mut self) -> Result<(), FetchGraphError> {
         let root_index = self

lib/query-planner/src/planner/fetch/optimize/merge_leafs.rs

@@ -5,17 +5,17 @@ use crate::{
     ast::type_aware_selection::find_arguments_conflicts,
     planner::fetch::{
         error::FetchGraphError, fetch_graph::FetchGraph, fetch_step_data::FetchStepData,
-        optimize::utils::perform_fetch_step_merge,
+        optimize::utils::perform_fetch_step_merge, state::MultiTypeFetchStep,
     },
 };
 
-impl FetchStepData {
+impl FetchStepData<MultiTypeFetchStep> {
     pub fn can_merge_leafs(
         &self,
         self_index: NodeIndex,
         other_index: NodeIndex,
         other: &Self,
-        fetch_graph: &FetchGraph,
+        fetch_graph: &FetchGraph<MultiTypeFetchStep>,
     ) -> bool {
         if self_index == other_index {
             return false;
@@ -66,7 +66,7 @@ impl FetchStepData {
     }
 }
 
-impl FetchGraph {
+impl FetchGraph<MultiTypeFetchStep> {
     #[instrument(level = "trace", skip_all)]
     /// This optimization is about merging leaf nodes in the fetch nodes with other nodes.
     /// It reduces the number of fetch steps, without degrading the query performance.