Merge pull request #497 from supabase/merge_fields_fix

Fix slow introspection queries

Author: olirice

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pg_graphql"
-version = "1.5.0"
+version = "1.5.1-mergeless"
 edition = "2021"
 
 [lib]

Cargo.toml

@@ -1,7 +1,6 @@
-use crate::graphql::*;
+use crate::graphql::{EnumSource, __InputValue, __Type, ___Type};
 use crate::gson;
 use graphql_parser::query::*;
-use graphql_parser::Pos;
 use std::collections::HashMap;
 
 pub fn alias_or_name<'a, T>(query_field: &graphql_parser::query::Field<'a, T>) -> String
@@ -15,221 +14,34 @@ where
         .unwrap_or_else(|| query_field.name.as_ref().to_string())
 }
 
-pub fn merge_fields<'a, T, I>(
-    target_fields: &mut Vec<Field<'a, T>>,
-    next_fields: I,
-    type_name: &str,
-    field_map: &HashMap<String, __Field>,
-) -> Result<(), String>
-where
-    T: Text<'a> + Eq + AsRef<str> + std::fmt::Debug + Clone,
-    I: IntoIterator<Item = Field<'a, T>>,
-{
-    for field in next_fields {
-        merge_field(target_fields, field, type_name, field_map)?
-    }
-    Ok(())
-}
-
-pub fn merge_field<'a, T>(
-    target_fields: &mut Vec<Field<'a, T>>,
-    mut field: Field<'a, T>,
-    type_name: &str,
-    field_map: &HashMap<String, __Field>,
-) -> Result<(), String>
-where
-    T: Text<'a> + Eq + AsRef<str> + std::fmt::Debug + Clone,
-{
-    let Some((matching_idx, matching_field)) = target_fields
-        .iter()
-        .enumerate()
-        .find(|(_, target)| alias_or_name(target) == alias_or_name(&field))
-    else {
-        target_fields.push(field);
-        return Ok(());
-    };
-
-    can_fields_merge(matching_field, &field, type_name, field_map)?;
-
-    field.position = field.position.min(matching_field.position);
-
-    field.selection_set.span =
-        min_encapsulating_span(field.selection_set.span, matching_field.selection_set.span);
-
-    // Subfields will be normalized and properly merged on a later pass.
-    field
-        .selection_set
-        .items
-        .extend(matching_field.selection_set.items.clone());
-
-    target_fields[matching_idx] = field;
-
-    Ok(())
-}
-
-pub fn can_fields_merge<'a, T>(
-    field_a: &Field<'a, T>,
-    field_b: &Field<'a, T>,
-    type_name: &str,
-    field_map: &HashMap<String, __Field>,
-) -> Result<(), String>
-where
-    T: Text<'a> + Eq + AsRef<str> + std::fmt::Debug + Clone,
-{
-    let Some(_field_a) = field_map.get(field_a.name.as_ref()) else {
-        return Err(format!(
-            "Unknown field '{}' on type '{}'",
-            field_a.name.as_ref(),
-            type_name
-        ));
-    };
-    let Some(_field_b) = field_map.get(field_b.name.as_ref()) else {
-        return Err(format!(
-            "Unknown field '{}' on type '{}'",
-            field_b.name.as_ref(),
-            type_name
-        ));
-    };
-
-    has_same_type_shape(
-        &alias_or_name(field_a),
-        type_name,
-        &_field_a.type_,
-        &_field_b.type_,
-    )?;
-
-    if field_a.name != field_b.name {
-        return Err(format!(
-            "Fields '{}' on type '{}' conflict because '{}' and '{}' are different fields",
-            alias_or_name(field_a),
-            type_name,
-            field_a.name.as_ref(),
-            field_b.name.as_ref(),
-        ));
-    }
-
-    for (arg_a_name, arg_a_value) in field_a.arguments.iter() {
-        let arg_b_value = field_b.arguments.iter().find_map(|(name, value)| {
-            if name == arg_a_name {
-                Some(value)
-            } else {
-                None
-            }
-        });
-        let args_match = match arg_b_value {
-            None => false,
-            Some(arg_b_value) => arg_b_value == arg_a_value,
-        };
-        if !args_match {
-            return Err(format!(
-                "Fields '{}' on type '{}' conflict because they have differing arguments",
-                alias_or_name(field_a),
-                type_name,
-            ));
-        }
-    }
-
-    Ok(())
-}
-
-pub fn has_same_type_shape(
-    field_name: &str,
-    type_name: &str,
-    type_a: &__Type,
-    type_b: &__Type,
-) -> Result<(), String> {
-    let mut type_a = type_a;
-    let mut type_b = type_b;
-
-    if matches!(type_a, __Type::NonNull(_)) || matches!(type_b, __Type::NonNull(_)) {
-        if let (__Type::NonNull(nullable_type_a), __Type::NonNull(nullable_type_b)) =
-            (type_a, type_b)
-        {
-            type_a = nullable_type_a.type_.as_ref();
-            type_b = nullable_type_b.type_.as_ref();
-        } else {
-            return Err(format!(
-                "Fields '{}' on type '{}' conflict because only one is non nullable",
-                field_name, type_name,
-            ));
-        }
-    }
-
-    if matches!(type_a, __Type::List(_)) || matches!(type_b, __Type::List(_)) {
-        if let (__Type::List(list_type_a), __Type::List(list_type_b)) = (type_a, type_b) {
-            type_a = list_type_a.type_.as_ref();
-            type_b = list_type_b.type_.as_ref();
-        } else {
-            return Err(format!(
-                "Fields '{}' on type '{}' conflict because only one is a list type",
-                field_name, type_name,
-            ));
-        }
-
-        return has_same_type_shape(field_name, type_name, type_a, type_b);
-    }
-
-    if matches!(type_a, __Type::Enum(_))
-        || matches!(type_b, __Type::Enum(_))
-        || matches!(type_a, __Type::Scalar(_))
-        || matches!(type_b, __Type::Scalar(_))
-    {
-        return if type_a == type_b {
-            Ok(())
-        } else {
-            Err(format!(
-                "Fields '{}' on type '{}' conflict due to mismatched types",
-                field_name, type_name,
-            ))
-        };
-    }
-
-    // TODO handle composite types?
-
-    // Subfield type shapes will be checked on a later pass.
-    Ok(())
-}
-
-pub fn min_encapsulating_span(a: (Pos, Pos), b: (Pos, Pos)) -> (Pos, Pos) {
-    (a.0.min(b.0), a.1.max(b.1))
-}
-
-pub fn normalize_selection_set<'a, T>(
-    selection_set: &SelectionSet<'a, T>,
-    fragment_definitions: &Vec<FragmentDefinition<'a, T>>,
+pub fn normalize_selection_set<'a, 'b, T>(
+    selection_set: &'b SelectionSet<'a, T>,
+    fragment_definitions: &'b Vec<FragmentDefinition<'a, T>>,
     type_name: &String,            // for inline fragments
     variables: &serde_json::Value, // for directives
-    field_type: &__Type,
-) -> Result<Vec<Field<'a, T>>, String>
+) -> Result<Vec<&'b Field<'a, T>>, String>
 where
-    T: Text<'a> + Eq + AsRef<str> + std::fmt::Debug + Clone,
+    T: Text<'a> + Eq + AsRef<str>,
 {
-    let mut normalized_fields: Vec<Field<'a, T>> = vec![];
-
-    let field_map = field_map(&field_type.unmodified_type());
+    let mut selections: Vec<&'b Field<'a, T>> = vec![];
 
     for selection in &selection_set.items {
-        match normalize_selection(
-            selection,
-            fragment_definitions,
-            type_name,
-            variables,
-            field_type,
-        ) {
-            Ok(fields) => merge_fields(&mut normalized_fields, fields, type_name, &field_map)?,
+        let sel = selection;
+        match normalize_selection(sel, fragment_definitions, type_name, variables) {
+            Ok(sels) => selections.extend(sels),
             Err(err) => return Err(err),
         }
     }
-    Ok(normalized_fields)
+    Ok(selections)
 }
 
 /// Combines @skip and @include
-pub fn selection_is_skipped<'a, T>(
-    query_selection: &Selection<'a, T>,
+pub fn selection_is_skipped<'a, 'b, T>(
+    query_selection: &'b Selection<'a, T>,
     variables: &serde_json::Value,
 ) -> Result<bool, String>
 where
-    T: Text<'a> + Eq + AsRef<str> + std::fmt::Debug,
+    T: Text<'a> + Eq + AsRef<str>,
 {
     let directives = match query_selection {
         Selection::Field(x) => &x.directives,
@@ -318,27 +130,24 @@ where
 }
 
 /// Normalizes literal selections, fragment spreads, and inline fragments
-pub fn normalize_selection<'a, T>(
-    query_selection: &Selection<'a, T>,
-    fragment_definitions: &Vec<FragmentDefinition<'a, T>>,
+pub fn normalize_selection<'a, 'b, T>(
+    query_selection: &'b Selection<'a, T>,
+    fragment_definitions: &'b Vec<FragmentDefinition<'a, T>>,
     type_name: &String,            // for inline fragments
     variables: &serde_json::Value, // for directives
-    field_type: &__Type,           // for field merging shape check
-) -> Result<Vec<Field<'a, T>>, String>
+) -> Result<Vec<&'b Field<'a, T>>, String>
 where
-    T: Text<'a> + Eq + AsRef<str> + std::fmt::Debug + Clone,
+    T: Text<'a> + Eq + AsRef<str>,
 {
-    let mut normalized_fields: Vec<Field<'a, T>> = vec![];
+    let mut selections: Vec<&Field<'a, T>> = vec![];
 
     if selection_is_skipped(query_selection, variables)? {
-        return Ok(normalized_fields);
+        return Ok(selections);
     }
 
-    let field_map = field_map(&field_type.unmodified_type());
-
     match query_selection {
         Selection::Field(field) => {
-            merge_field(&mut normalized_fields, field.clone(), type_name, &field_map)?;
+            selections.push(field);
         }
         Selection::FragmentSpread(fragment_spread) => {
             let frag_name = &fragment_spread.fragment_name;
@@ -364,15 +173,14 @@ where
             };
 
             // TODO handle directives?
-            let frag_fields = normalize_selection_set(
+            let frag_selections = normalize_selection_set(
                 &frag_def.selection_set,
                 fragment_definitions,
                 type_name,
                 variables,
-                field_type,
             );
-            match frag_fields {
-                Ok(fields) => merge_fields(&mut normalized_fields, fields, type_name, &field_map)?,
+            match frag_selections {
+                Ok(sels) => selections.extend(sels.iter()),
                 Err(err) => return Err(err),
             };
         }
@@ -385,19 +193,18 @@ where
             };
 
             if inline_fragment_applies {
-                let infrag_fields = normalize_selection_set(
+                let infrag_selections = normalize_selection_set(
                     &inline_fragment.selection_set,
                     fragment_definitions,
                     type_name,
                     variables,
-                    field_type,
                 )?;
-                merge_fields(&mut normalized_fields, infrag_fields, type_name, &field_map)?;
+                selections.extend(infrag_selections.iter());
             }
         }
     }
 
-    Ok(normalized_fields)
+    Ok(selections)
 }
 
 pub fn to_gson<'a, T>(
@@ -406,7 +213,7 @@ pub fn to_gson<'a, T>(
     variable_definitions: &Vec<VariableDefinition<'a, T>>,
 ) -> Result<gson::Value, String>
 where
-    T: Text<'a> + AsRef<str> + std::fmt::Debug,
+    T: Text<'a> + AsRef<str>,
 {
     let result = match graphql_value {
         Value::Null => gson::Value::Null,
@@ -466,6 +273,7 @@ where
 }
 
 pub fn validate_arg_from_type(type_: &__Type, value: &gson::Value) -> Result<gson::Value, String> {
+    use crate::graphql::Scalar;
     use crate::gson::Number as GsonNumber;
     use crate::gson::Value as GsonValue;
 
@@ -676,6 +484,7 @@ pub fn validate_arg_from_input_object(
     input_type: &__Type,
     value: &gson::Value,
 ) -> Result<gson::Value, String> {
+    use crate::graphql::__TypeKind;
     use crate::gson::Value as GsonValue;
 
     let input_type_name = input_type.name().unwrap_or_default();