fix(grpc): handle union shared fields (#2757)

Co-authored-by: Tushar Mathur <[email protected]>

src/core/blueprint/index.rs

@@ -66,6 +66,18 @@ impl Index {
     pub fn get_mutation(&self) -> Option<&str> {
         self.schema.mutation.as_deref()
     }
+
+    pub fn is_type_implements(&self, type_name: &str, type_or_interface: &str) -> bool {
+        if type_name == type_or_interface {
+            return true;
+        }
+
+        if let Some((Definition::Object(obj), _)) = self.map.get(type_name) {
+            obj.implements.contains(type_or_interface)
+        } else {
+            false
+        }
+    }
 }
 
 impl From<&Blueprint> for Index {
@@ -232,4 +244,13 @@ mod test {
         index.schema.mutation = None;
         assert_eq!(index.get_mutation(), None);
     }
+
+    #[test]
+    fn test_is_type_implements() {
+        let index = setup();
+
+        assert!(index.is_type_implements("User", "Node"));
+        assert!(index.is_type_implements("Post", "Post"));
+        assert!(!index.is_type_implements("Node", "User"));
+    }
 }

src/core/config/config.rs

@@ -962,6 +962,9 @@ impl Config {
                     stack.extend(field.args.values().map(|arg| arg.type_of.clone()));
                     stack.push(field.type_of.clone());
                 }
+                for interface in typ.implements.iter() {
+                    stack.push(interface.clone())
+                }
             }
         }
 

src/core/generator/from_proto.rs

@@ -127,7 +127,7 @@ impl Context {
 
         collect_types(
             type_name.clone(),
-            base_type,
+            base_type.clone(),
             &oneof_fields,
             &mut union_types,
         );
@@ -141,13 +141,17 @@ impl Context {
         }
 
         let mut union_ = Union::default();
+        let interface_name = format!("{type_name}__Interface");
 
-        for (type_name, ty) in union_types {
+        for (type_name, mut ty) in union_types {
+            ty.implements.insert(interface_name.clone());
             union_.types.insert(type_name.clone());
 
             self = self.insert_type(type_name, ty);
         }
 
+        // base interface type
+        self.config.types.insert(interface_name, base_type);
         self.config.unions.insert(type_name, union_);
 
         self

src/core/generator/snapshots/tailcall__core__generator__from_proto__test__oneof_types.snap

@@ -62,6 +62,14 @@ input oneof__Request__Var__Var1 {
   usual: String
 }
 
+interface oneof__Request__Interface {
+  usual: String
+}
+
+interface oneof__Response__Interface {
+  usual: Int
+}
+
 union oneof__Request = oneof__Request__Var0__Var | oneof__Request__Var0__Var0 | oneof__Request__Var0__Var1 | oneof__Request__Var1__Var | oneof__Request__Var1__Var0 | oneof__Request__Var1__Var1 | oneof__Request__Var__Var | oneof__Request__Var__Var0 | oneof__Request__Var__Var1
 
 union oneof__Response = oneof__Response__Var | oneof__Response__Var0 | oneof__Response__Var1 | oneof__Response__Var2
@@ -78,21 +86,21 @@ type oneof__Payload {
   payload: String
 }
 
-type oneof__Response__Var {
+type oneof__Response__Var implements oneof__Response__Interface {
   usual: Int
 }
 
-type oneof__Response__Var0 {
+type oneof__Response__Var0 implements oneof__Response__Interface {
   payload: oneof__Payload!
   usual: Int
 }
 
-type oneof__Response__Var1 {
+type oneof__Response__Var1 implements oneof__Response__Interface {
   command: oneof__Command!
   usual: Int
 }
 
-type oneof__Response__Var2 {
+type oneof__Response__Var2 implements oneof__Response__Interface {
   response: String!
   usual: Int
 }

src/core/ir/resolver_context_like.rs

@@ -96,8 +96,12 @@ impl SelectionField {
         field: &crate::core::jit::Field<Nested<ConstValue>, ConstValue>,
     ) -> SelectionField {
         let name = field.output_name.to_string();
+        let type_name = field.type_of.name();
         let selection_set = field
-            .nested_iter(field.type_of.name())
+            .iter_only(|field| match &field.type_condition {
+                Some(type_condition) => type_condition == type_name,
+                None => true,
+            })
             .map(Self::from_jit_field)
             .collect();
         let args = field

src/core/jit/builder.rs

@@ -220,7 +220,7 @@ impl Builder {
                                 .unwrap_or(field_name.to_owned()),
                             ir,
                             type_of,
-                            type_condition: type_condition.to_string(),
+                            type_condition: Some(type_condition.to_string()),
                             skip,
                             include,
                             args,
@@ -241,7 +241,9 @@ impl Builder {
                                 name: "String".to_owned(),
                                 non_null: true,
                             },
-                            type_condition: type_condition.to_string(),
+                            // __typename has a special meaning and could be applied
+                            // to any type
+                            type_condition: None,
                             skip,
                             include,
                             args: Vec::new(),

src/core/jit/exec.rs

@@ -94,13 +94,16 @@ where
             // Check if the value is an array
             if let Some(array) = value.as_array() {
                 join_all(array.iter().enumerate().map(|(index, value)| {
-                    let type_name = value.get_type_name().unwrap_or(field.type_of.name());
-
-                    join_all(field.nested_iter(type_name).map(|field| {
-                        let ctx = ctx.with_value_and_field(value, field);
-                        let data_path = data_path.clone().with_index(index);
-                        async move { self.execute(&ctx, data_path).await }
-                    }))
+                    join_all(
+                        self.request
+                            .plan()
+                            .field_iter_only(field, value)
+                            .map(|field| {
+                                let ctx = ctx.with_value_and_field(value, field);
+                                let data_path = data_path.clone().with_index(index);
+                                async move { self.execute(&ctx, data_path).await }
+                            }),
+                    )
                 }))
                 .await;
             }
@@ -111,13 +114,16 @@ where
         // TODO: Validate if the value is an Object
         // Has to be an Object, we don't do anything while executing if its a Scalar
         else {
-            let type_name = value.get_type_name().unwrap_or(field.type_of.name());
-
-            join_all(field.nested_iter(type_name).map(|child| {
-                let ctx = ctx.with_value_and_field(value, child);
-                let data_path = data_path.clone();
-                async move { self.execute(&ctx, data_path).await }
-            }))
+            join_all(
+                self.request
+                    .plan()
+                    .field_iter_only(field, value)
+                    .map(|child| {
+                        let ctx = ctx.with_value_and_field(value, child);
+                        let data_path = data_path.clone();
+                        async move { self.execute(&ctx, data_path).await }
+                    }),
+            )
             .await;
         }
 

src/core/jit/model.rs

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use super::Error;
 use crate::core::blueprint::Index;
 use crate::core::ir::model::IR;
+use crate::core::ir::TypedValue;
 use crate::core::json::JsonLike;
 
 #[derive(Debug, Deserialize, Clone)]
@@ -65,6 +66,14 @@ impl<Extensions, Input> Field<Extensions, Input> {
 
         skip == include
     }
+
+    /// Returns the __typename of the value related to this field
+    pub fn value_type<'a, Output>(&'a self, value: &'a Output) -> &'a str
+    where
+        Output: TypedValue<'a>,
+    {
+        value.get_type_name().unwrap_or(self.type_of.name())
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -138,7 +147,7 @@ pub struct Field<Extensions, Input> {
     /// The type could be anything from graphql type system:
     /// interface, type, union, input type.
     /// See [spec](https://spec.graphql.org/October2021/#sec-Type-Conditions)
-    pub type_condition: String,
+    pub type_condition: Option<String>,
     pub skip: Option<Variable>,
     pub include: Option<Variable>,
     pub args: Vec<Arg<Input>>,
@@ -234,27 +243,15 @@ impl<Input> Field<Flat, Input> {
 }
 
 impl<Input> Field<Nested<Input>, Input> {
-    /// iters over children fields that are
-    /// related to passed `type_name` either
-    /// as direct field of the queried type or
-    /// field from fragment on type `type_name`
-    pub fn nested_iter<'a>(
+    /// iters over children fields that satisfies
+    /// passed filter_fn
+    pub fn iter_only<'a>(
         &'a self,
-        type_name: &'a str,
+        mut filter_fn: impl FnMut(&'a Field<Nested<Input>, Input>) -> bool + 'a,
     ) -> impl Iterator<Item = &Field<Nested<Input>, Input>> + 'a {
         self.extensions
             .as_ref()
-            .map(move |nested| {
-                nested
-                    .0
-                    .iter()
-                    // TODO: handle Interface and Union types here
-                    // Right now only exact type name is used to check the set of fields
-                    // but with Interfaces/Unions we need to check if that specific type
-                    // is member of some Interface/Union and if so call the fragments for
-                    // the related Interfaces/Unions
-                    .filter(move |field| field.type_condition == type_name)
-            })
+            .map(move |nested| nested.0.iter().filter(move |&field| filter_fn(field)))
             .into_iter()
             .flatten()
     }
@@ -351,7 +348,6 @@ pub struct OperationPlan<Input> {
     flat: Vec<Field<Flat, Input>>,
     operation_type: OperationType,
     nested: Vec<Field<Nested<Input>, Input>>,
-
     // TODO: drop index from here. Embed all the necessary information in each field of the plan.
     pub index: Arc<Index>,
 }
@@ -409,30 +405,37 @@ impl<Input> OperationPlan<Input> {
         Self { flat: fields, nested, operation_type, index }
     }
 
+    /// Returns a graphQL operation type
     pub fn operation_type(&self) -> OperationType {
         self.operation_type
     }
 
+    /// Check if current graphQL operation is query
     pub fn is_query(&self) -> bool {
         self.operation_type == OperationType::Query
     }
 
+    /// Returns a nested [Field] representation
     pub fn as_nested(&self) -> &[Field<Nested<Input>, Input>] {
         &self.nested
     }
 
+    /// Returns an owned version of [Field] representation
     pub fn into_nested(self) -> Vec<Field<Nested<Input>, Input>> {
         self.nested
     }
 
+    /// Returns a flat [Field] representation
     pub fn as_parent(&self) -> &[Field<Flat, Input>] {
         &self.flat
     }
 
+    /// Search for a field with a specified [FieldId]
     pub fn find_field(&self, id: FieldId) -> Option<&Field<Flat, Input>> {
         self.flat.iter().find(|field| field.id == id)
     }
 
+    /// Search for a field by specified path of nested fields
     pub fn find_field_path<S: AsRef<str>>(&self, path: &[S]) -> Option<&Field<Flat, Input>> {
         match path.split_first() {
             None => None,
@@ -447,25 +450,48 @@ impl<Input> OperationPlan<Input> {
         }
     }
 
+    /// Returns number of fields in plan
     pub fn size(&self) -> usize {
         self.flat.len()
     }
 
+    /// Check if the field is of scalar type
     pub fn field_is_scalar<Extensions>(&self, field: &Field<Extensions, Input>) -> bool {
         self.index.type_is_scalar(field.type_of.name())
     }
 
+    /// Check if the field is of enum type
     pub fn field_is_enum<Extensions>(&self, field: &Field<Extensions, Input>) -> bool {
         self.index.type_is_enum(field.type_of.name())
     }
 
+    /// Validate the value against enum variants of the field
     pub fn field_validate_enum_value<Extensions>(
         &self,
         field: &Field<Extensions, Input>,
         value: &str,
     ) -> bool {
         self.index.validate_enum_value(field.type_of.name(), value)
     }
+
+    /// Iterate over nested fields that are related to the __typename of the
+    /// value
+    pub fn field_iter_only<'a, Output>(
+        &'a self,
+        field: &'a Field<Nested<Input>, Input>,
+        value: &'a Output,
+    ) -> impl Iterator<Item = &'a Field<Nested<Input>, Input>>
+    where
+        Output: TypedValue<'a>,
+    {
+        let value_type = field.value_type(value);
+
+        field.iter_only(move |field| match &field.type_condition {
+            Some(type_condition) => self.index.is_type_implements(value_type, type_condition),
+            // if there is no type_condition restriction then use this field
+            None => true,
+        })
+    }
 }
 
 #[derive(Clone, Debug)]

src/core/jit/snapshots/tailcall__core__jit__builder__tests__alias_query.snap

@@ -9,7 +9,9 @@ expression: plan.into_nested()
         output_name: "articles",
         ir: "Some(..)",
         type_of: [Post],
-        type_condition: "Query",
+        type_condition: Some(
+            "Query",
+        ),
         extensions: Some(
             Nested(
                 [
@@ -19,7 +21,9 @@ expression: plan.into_nested()
                         output_name: "author",
                         ir: "Some(..)",
                         type_of: User,
-                        type_condition: "Post",
+                        type_condition: Some(
+                            "Post",
+                        ),
                         extensions: Some(
                             Nested(
                                 [
@@ -28,7 +32,9 @@ expression: plan.into_nested()
                                         name: "id",
                                         output_name: "identifier",
                                         type_of: ID!,
-                                        type_condition: "User",
+                                        type_condition: Some(
+                                            "User",
+                                        ),
                                         directives: [],
                                     },
                                 ],