added PossibleFragmentSpreads

fixes for extensions

Author: dotansimha

README.md

@@ -54,7 +54,7 @@ cargo add graphql-tools
 - [x] UniqueFragmentNames
 - [x] KnownFragmentNames
 - [x] NoUnusedFragments
-- [ ] PossibleFragmentSpreads
+- [x] PossibleFragmentSpreads
 - [x] NoFragmentCycles
 - [ ] UniqueVariableNames
 - [ ] NoUndefinedVariables

src/ast/collect_fields.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use super::{AbstractTypeDefinitionExtension, TypeInfoRegistry};
-use crate::ast::ext::{TypeDefinitionExtension, UnionTypeExtension};
+use crate::ast::ext::{SubTypeExtension, TypeDefinitionExtension};
 use crate::static_graphql::{
     query::{self, Selection, TypeCondition},
     schema::{self, TypeDefinition},

src/ast/ext.rs

@@ -3,7 +3,7 @@ use crate::static_graphql::schema::{
     self, Field, InterfaceType, ObjectType, TypeDefinition, UnionType,
 };
 
-use super::{get_named_type, TypeInfoElementRef};
+use super::{get_named_type, TypeInfoElementRef, TypeInfoRegistry};
 
 pub trait AstNodeWithFields {
     fn find_field(&self, name: String) -> Option<&Field>;
@@ -70,6 +70,14 @@ impl CompositeType {
             _ => None,
         }
     }
+
+    pub fn as_type_definition(&self) -> schema::TypeDefinition {
+        match self {
+            CompositeType::Object(o) => schema::TypeDefinition::Object(o.clone()),
+            CompositeType::Interface(o) => schema::TypeDefinition::Interface(o.clone()),
+            CompositeType::Union(o) => schema::TypeDefinition::Union(o.clone()),
+        }
+    }
 }
 
 pub trait AbstractTypeDefinitionExtension {
@@ -86,6 +94,7 @@ pub trait TypeDefinitionExtension {
 
 pub trait ImplementingInterfaceExtension {
     fn interfaces(&self) -> Vec<String>;
+    fn has_sub_type(&self, other_type: &TypeDefinition) -> bool;
 }
 
 impl ImplementingInterfaceExtension for TypeDefinition {
@@ -96,25 +105,86 @@ impl ImplementingInterfaceExtension for TypeDefinition {
             _ => vec![],
         }
     }
+
+    fn has_sub_type(&self, other_type: &TypeDefinition) -> bool {
+        match self {
+            TypeDefinition::Interface(interface_type) => {
+                return interface_type.is_implemented_by(other_type)
+            }
+            TypeDefinition::Union(union_type) => {
+                return union_type.has_sub_type(&other_type.name())
+            }
+            _ => return false,
+        }
+    }
+}
+
+pub trait PossibleTypesExtension<'a> {
+    fn possible_types(&self, type_info_registry: &TypeInfoRegistry) -> Vec<ObjectType>;
+}
+
+impl<'a> PossibleTypesExtension<'a> for TypeDefinition {
+    fn possible_types(&self, type_info_registry: &TypeInfoRegistry) -> Vec<ObjectType> {
+        match self {
+            TypeDefinition::Object(_) => vec![],
+            TypeDefinition::InputObject(_) => vec![],
+            TypeDefinition::Enum(_) => vec![],
+            TypeDefinition::Scalar(_) => vec![],
+            TypeDefinition::Interface(i) => type_info_registry
+                .type_by_name
+                .iter()
+                .filter_map(|(_type_name, type_def)| {
+                    if let TypeDefinition::Object(o) = type_def {
+                        if i.is_implemented_by(*type_def) {
+                            return Some(o.clone());
+                        }
+                    }
+
+                    None
+                })
+                .collect(),
+            TypeDefinition::Union(u) => u
+                .types
+                .iter()
+                .filter_map(|type_name| {
+                    if let Some(TypeDefinition::Object(o)) =
+                        type_info_registry.type_by_name.get(type_name)
+                    {
+                        return Some(o.clone());
+                    }
+
+                    None
+                })
+                .collect(),
+        }
+    }
 }
 
 impl ImplementingInterfaceExtension for InterfaceType {
     fn interfaces(&self) -> Vec<String> {
         self.implements_interfaces.clone()
     }
+
+    fn has_sub_type(&self, other_type: &TypeDefinition) -> bool {
+        self.is_implemented_by(other_type)
+    }
 }
 
 impl ImplementingInterfaceExtension for ObjectType {
     fn interfaces(&self) -> Vec<String> {
         self.implements_interfaces.clone()
     }
+
+    fn has_sub_type(&self, _other_type: &TypeDefinition) -> bool {
+        false
+    }
 }
 
-pub trait UnionTypeExtension {
+pub trait SubTypeExtension {
     fn has_sub_type(&self, other_type_name: &String) -> bool;
 }
 
-impl UnionTypeExtension for UnionType {
+impl SubTypeExtension for UnionType {
     fn has_sub_type(&self, other_type_name: &String) -> bool {
         self.types.iter().find(|v| other_type_name.eq(*v)).is_some()
     }

src/ast/utils.rs

@@ -1,4 +1,9 @@
-use crate::static_graphql::schema;
+use crate::ast::ext::{
+    ImplementingInterfaceExtension, PossibleTypesExtension, TypeDefinitionExtension,
+};
+use crate::static_graphql::schema::{self, TypeDefinition};
+
+use super::TypeInfoRegistry;
 
 pub struct DefaultVisitorContext;
 
@@ -12,10 +17,56 @@ pub fn find_schema_definition(schema: &schema::Document) -> Option<&schema::Sche
         })
 }
 
+/**
+ * Extracts nested NamedType from a potentially recursive wrapped definition.
+ *
+ * Example: Returns String from [String] or String!
+ */
 pub fn get_named_type(t: &schema::Type) -> String {
     match t {
         schema::Type::NamedType(name) => name.clone(),
         schema::Type::ListType(inner_type) => get_named_type(inner_type),
         schema::Type::NonNullType(inner_type) => get_named_type(inner_type),
     }
 }
+
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ */
+pub fn do_types_overlap(
+    type_info_registry: &TypeInfoRegistry,
+    t1: &schema::TypeDefinition,
+    t2: &schema::TypeDefinition,
+) -> bool {
+    if t1.name().eq(&t2.name()) {
+        return true;
+    }
+
+    if t1.is_abstract_type() {
+        if t2.is_abstract_type() {
+            let possible_types = t1.possible_types(type_info_registry);
+
+            return possible_types
+                .into_iter()
+                .filter(|possible_type| {
+                    t2.has_sub_type(&TypeDefinition::Object(possible_type.clone()))
+                })
+                .count()
+                > 0;
+        }
+
+        return t1.has_sub_type(t2);
+    }
+
+    if t2.is_abstract_type() {
+        return t2.has_sub_type(t1);
+    }
+
+    false
+}

src/validation/rules/defaults.rs

@@ -2,8 +2,9 @@ use crate::validation::validate::ValidationPlan;
 
 use super::{
     FieldsOnCorrectType, FragmentsOnCompositeTypes, KnownFragmentNames, KnownTypeNames,
-    LeafFieldSelections, LoneAnonymousOperation, NoUnusedFragments, OverlappingFieldsCanBeMerged,
-    SingleFieldSubscriptions, UniqueFragmentNames, UniqueOperationNames, VariablesAreInputTypes,
+    LeafFieldSelections, LoneAnonymousOperation, NoFragmentsCycle, NoUnusedFragments,
+    OverlappingFieldsCanBeMerged, PossibleFragmentSpreads, SingleFieldSubscriptions,
+    UniqueFragmentNames, UniqueOperationNames, VariablesAreInputTypes,
 };
 
 pub fn default_rules_validation_plan() -> ValidationPlan {
@@ -21,6 +22,8 @@ pub fn default_rules_validation_plan() -> ValidationPlan {
     plan.add_rule(Box::new(KnownFragmentNames {}));
     plan.add_rule(Box::new(NoUnusedFragments {}));
     plan.add_rule(Box::new(OverlappingFieldsCanBeMerged {}));
+    plan.add_rule(Box::new(NoFragmentsCycle {}));
+    plan.add_rule(Box::new(PossibleFragmentSpreads {}));
 
     plan
 }

src/validation/rules/mod.rs

@@ -8,6 +8,7 @@ pub mod lone_anonymous_operation;
 pub mod no_fragments_cycle;
 pub mod no_unused_fragments;
 pub mod overlapping_fields_can_be_merged;
+pub mod possible_fragment_spreads;
 /// Utilities validating GraphQL documents/operations
 pub mod rule;
 pub mod single_field_subscriptions;
@@ -25,6 +26,7 @@ pub use self::lone_anonymous_operation::*;
 pub use self::no_fragments_cycle::*;
 pub use self::no_unused_fragments::*;
 pub use self::overlapping_fields_can_be_merged::*;
+pub use self::possible_fragment_spreads::*;
 pub use self::rule::*;
 pub use self::single_field_subscriptions::*;
 pub use self::unique_fragment_names::*;

src/validation/rules/no_fragments_cycle.rs

@@ -20,7 +20,6 @@ pub struct NoFragmentsCycle;
 
 struct NoFragmentsCycleHelper<'a> {
     visited_fragments: HashMap<String, bool>,
-
     errors_context: ValidationErrorContext<'a>,
 }