start on abstract types support

Author: rmosolgo

lib/graphql/execution/next.rb

@@ -21,7 +21,7 @@ def initialize(schema, document, context, variables, root_object)
           @data = {}
         end
 
-        attr_reader :steps_queue, :schema, :context
+        attr_reader :steps_queue, :schema, :context, :document
 
         def execute
           operation = @document.definitions.first # TODO select named operation
@@ -148,6 +148,16 @@ def execute
 
           private
 
+          def type_condition_applies?(type_name)
+            if type_name == @parent_type.graphql_name
+              true
+            else
+              abs_t = @runner.schema.get_type(type_name, @runner.context)
+              p_types = @runner.schema.possible_types(abs_t, @runner.context)
+              p_types.include?(@parent_type)
+            end
+          end
+
           def gather_selections(ast_selections, into:)
             ast_selections.each do |ast_selection|
               case ast_selection
@@ -166,9 +176,15 @@ def gather_selections(ast_selections, into:)
                 step.append_selection(ast_selection)
               when GraphQL::Language::Nodes::InlineFragment
                 type_condition = ast_selection.type.name
-                if type_condition == @parent_type.graphql_name
+                if type_condition_applies?(type_condition)
                   gather_selections(ast_selection.selections, into: into)
                 end
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment_definition = @runner.document.definitions.find { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
+                type_condition = fragment_definition.type.name
+                if type_condition_applies?(type_condition)
+                  gather_selections(fragment_definition.selections, into: into)
+                end
               else
                 raise ArgumentError, "Unsupported graphql selection node: #{ast_selection.class} (#{ast_selection.inspect})"
               end

spec/graphql/execution/next_spec.rb

@@ -26,6 +26,11 @@ class BaseObject < GraphQL::Schema::Object
       field_class BaseField
     end
 
+    module BaseInterface
+      include GraphQL::Schema::Interface
+      field_class BaseField
+    end
+
     ALL_FAMILIES = [
       OpenStruct.new(name: "Legumes", grows_in: ["SPRING", "SUMMER", "FALL"], species: [OpenStruct.new(name: "Snow Pea")]),
       OpenStruct.new(name: "Nightshades", grows_in: ["SUMMER"], species: [OpenStruct.new(name: "Tomato")]),
@@ -39,16 +44,34 @@ class Season < GraphQL::Schema::Enum
       value "FALL"
     end
 
-    class PlantSpecies < BaseObject
+    module Nameable
+      include BaseInterface
       field :name, String, object_method: :name
+
+      def self.resolve_type(obj, ctx)
+        if obj.respond_to?(:grows_in)
+          PlantFamily
+        else
+          PlantSpecies
+        end
+      end
+    end
+
+    class PlantSpecies < BaseObject
+      implements Nameable
+      field :poisonous, Boolean, value: false
     end
 
     class PlantFamily < BaseObject
-      field :name, String, object_method: :name
+      implements Nameable
       field :grows_in, Season, object_method: :grows_in
       field :species, [PlantSpecies], object_method: :species
     end
 
+    class Thing < GraphQL::Schema::Union
+      possible_types(PlantFamily, PlantSpecies)
+    end
+
 
     class Query < BaseObject
       field :families, [PlantFamily], value: ALL_FAMILIES
@@ -72,6 +95,8 @@ def self.all_find_species(objects, context, name:)
         end
         Array.new(objects.length, species)
       end
+
+      field :all_things, [Thing], value: ALL_FAMILIES + ALL_FAMILIES.map { |f| f.species }.flatten
     end
 
     query(Query)
@@ -86,14 +111,28 @@ def run_next(query_str, root_object: nil)
     result = run_next("{
       str
       families {
-        name
+        ... on Nameable { name }
         ... on PlantFamily { growsIn }
       }
       families { species { name } }
-      t: findSpecies(name: \"Tomato\") { name }
-      c: findSpecies(name: \"Cucumber\") { name }
+      t: findSpecies(name: \"Tomato\") { ...SpeciesInfo  ... NameableInfo }
+      c: findSpecies(name: \"Cucumber\") { name ...SpeciesInfo }
       x: findSpecies(name: \"Blue Rasperry\") { name }
-    }", root_object: "Abc")
+      allThings {
+        # __typename
+        ... on Nameable { name }
+        ... on PlantFamily { growsIn }
+      }
+    }
+
+    fragment SpeciesInfo on PlantSpecies {
+      poisonous
+    }
+
+    fragment NameableInfo on Nameable {
+      name
+    }
+    ", root_object: "Abc")
     expected_result = {
       "data" => {
         "str" => "String",
@@ -102,9 +141,17 @@ def run_next(query_str, root_object: nil)
           {"name" => "Nightshades", "growsIn" => ["SUMMER"], "species" => [{"name" => "Tomato"}]},
           {"name" => "Curcurbits", "growsIn" => ["SUMMER"], "species" => [{"name" => "Cucumber"}]}
         ],
-        "t" => { "name" => "Tomato" },
-        "c" => { "name" => "Cucumber" },
-        "x" => nil
+        "t" => { "name" => "Tomato", "poisonous" => false  },
+        "c" => { "name" => "Cucumber", "poisonous" => false },
+        "x" => nil,
+        "allThings" => [
+          {"name" => "Legumes", "growsIn" => ["SPRING", "SUMMER", "FALL"]},
+          {"name" => "Nightshades", "growsIn" => ["SUMMER"]},
+          {"name" => "Curcurbits", "growsIn" => ["SUMMER"]},
+          {"name" => "Snow Pea"},
+          {"name" => "Tomato"},
+          {"name" => "Cucumber"},
+        ]
       }
     }
     assert_equal(expected_result, result)