feat: Add support for interpreter runtime (#65)

* First crack at supporting the new interpreter

* Refactor to avoid referencing Schema instance vars

* Fix rubocop errors

* 🎨 Cleanup

* Fix compatibility with graphql-ruby 1.9

* FIx rubocop error

Author: rylanc

example/accounts.rb

@@ -48,6 +48,8 @@ def me
 end
 
 class AccountSchema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   include ApolloFederation::Schema
 
   query(Query)

example/inventory.rb

@@ -42,6 +42,8 @@ def shipping_estimate
 end
 
 class InventorySchema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   include ApolloFederation::Schema
 
   orphan_types Product

lib/apollo-federation/entities_field.rb

@@ -13,7 +13,14 @@ def self.included(base)
     module ClassMethods
       extend GraphQL::Schema::Member::HasFields
 
-      def define_entities_field(entity_type)
+      def define_entities_field(possible_entities)
+        # If there are any "entities", define the Entity union and and the Query._entities field
+        return if possible_entities.empty?
+
+        entity_type = Class.new(Entity) do
+          possible_types(*possible_entities)
+        end
+
         field(:_entities, [entity_type, null: true], null: false) do
           argument :representations, [Any], required: true
           extension(EntityTypeResolutionExtension)
@@ -32,8 +39,8 @@ def _entities(representations:)
                 ' but no object type of that name was found in the schema'
         end
 
-        # TODO: Handle non-class types?
-        type_class = type.metadata[:type_class]
+        # TODO: What if the type is an interface?
+        type_class = type.is_a?(GraphQL::ObjectType) ? type.metadata[:type_class] : type
         if type_class.respond_to?(:resolve_reference)
           result = type_class.resolve_reference(reference, context)
         else

lib/apollo-federation/federated_document_from_schema_definition.rb

@@ -23,17 +23,17 @@ def build_object_type_node(object_type)
         end
         federation_fields.each { |field| object_node = object_node.delete_child(field) }
       end
-      merge_directives(object_node, object_type.metadata[:federation_directives])
+      merge_directives(object_node, object_type)
     end
 
     def build_interface_type_node(interface_type)
       field_node = super
-      merge_directives(field_node, interface_type.metadata[:federation_directives])
+      merge_directives(field_node, interface_type)
     end
 
     def build_field_node(field_type)
       field_node = super
-      merge_directives(field_node, field_type.metadata[:federation_directives])
+      merge_directives(field_node, field_type)
     end
 
     def build_type_definition_nodes(types)
@@ -53,7 +53,15 @@ def query_type?(type)
       type == warden.root_type_for_operation('query')
     end
 
-    def merge_directives(node, directives)
+    def merge_directives(node, type)
+      if type.is_a?(ApolloFederation::HasDirectives)
+        directives = type.federation_directives
+      elsif type.is_a?(GraphQL::Define::InstanceDefinable)
+        directives = type.metadata[:federation_directives]
+      else
+        directives = []
+      end
+
       (directives || []).each do |directive|
         node = node.merge_directive(
           name: directive[:name],

lib/apollo-federation/has_directives.rb

@@ -2,6 +2,8 @@
 
 module ApolloFederation
   module HasDirectives
+    attr_reader :federation_directives
+
     def add_directive(name:, arguments: nil)
       @federation_directives ||= []
       @federation_directives << { name: name, arguments: arguments }

lib/apollo-federation/schema.rb

@@ -8,52 +8,94 @@
 module ApolloFederation
   module Schema
     def self.included(klass)
-      klass.extend(ClassMethods)
+      if Gem::Version.new(GraphQL::VERSION) >= Gem::Version.new('1.10.0')
+        klass.extend(OneTenMethods)
+      else
+        klass.extend(OneNineMethods)
+      end
+    end
+
+    module CommonMethods
+      def federation_sdl(context: nil)
+        document_from_schema = FederatedDocumentFromSchemaDefinition.new(self, context: context)
+        GraphQL::Language::Printer.new.print(document_from_schema.document)
+      end
+
+      private
+
+      def federation_query(query_obj)
+        # Build the new query object with the '_service' field
+        if query_obj.nil?
+          base = GraphQL::Schema::Object
+        elsif Gem::Version.new(GraphQL::VERSION) >= Gem::Version.new('1.10.0')
+          base = query_obj
+        else
+          base = query_obj.metadata[:type_class]
+        end
+
+        Class.new(base) do
+          # TODO: Maybe the name should inherit from the original Query name
+          # Or MAYBE we should just modify the original class?
+          graphql_name 'Query'
+
+          include EntitiesField
+          include ServiceField
+        end
+      end
     end
 
-    module ClassMethods
+    # TODO: Remove these once we drop support for graphql 1.9
+    module OneNineMethods
+      include CommonMethods
+
       def to_graphql
         orig_defn = super
+        @query_object = federation_query(query)
 
         possible_entities = orig_defn.types.values.select do |type|
           !type.introspection? && !type.default_scalar? && type.is_a?(GraphQL::ObjectType) &&
             type.metadata[:federation_directives]&.any? { |directive| directive[:name] == 'key' }
         end
-
-        @query_object = federation_query
-
-        if !possible_entities.empty?
-          entity_type = Class.new(Entity) do
-            possible_types(*possible_entities)
-          end
-          # TODO: Should/can we encapsulate all of this inside the module? What's the best/most Ruby
-          # way to split this out?
-          @query_object.define_entities_field(entity_type)
-        end
+        @query_object.define_entities_field(possible_entities)
 
         super
       end
+    end
 
-      def federation_query
-        if query.nil?
-          base = GraphQL::Schema::Object
-        elsif Gem::Version.new(GraphQL::VERSION) >= Gem::Version.new('1.10.0')
-          base = query
+    module OneTenMethods
+      include CommonMethods
+
+      def query(new_query_object = nil)
+        if new_query_object
+          @orig_query_object = new_query_object
         else
-          base = query.metadata[:type_class]
-        end
+          if !@federation_query_object
+            @federation_query_object = federation_query(@orig_query_object)
+            @federation_query_object.define_entities_field(schema_entities)
 
-        Class.new(base) do
-          graphql_name 'Query'
+            super(@federation_query_object)
+          end
 
-          include EntitiesField
-          include ServiceField
+          super
         end
       end
 
-      def federation_sdl(context: nil)
-        document_from_schema = FederatedDocumentFromSchemaDefinition.new(self, context: context)
-        GraphQL::Language::Printer.new.print(document_from_schema.document)
+      private
+
+      def schema_entities
+        # Create a temporary schema that inherits from this one to extract the types
+        types_schema = Class.new(self)
+        # Add the original query objects to the types. We have to use orphan_types here to avoid
+        # infinite recursion
+        types_schema.orphan_types(@orig_query_object)
+
+        # Walk through all of the types and determine which ones are entities (any type with a
+        # "key" directive)
+        types_schema.types.values.select do |type|
+          # TODO: Interfaces can have a key...
+          !type.introspection? && type.include?(ApolloFederation::Object) &&
+            type.federation_directives&.any? { |directive| directive[:name] == 'key' }
+        end
       end
     end
   end

lib/apollo-federation/service_field.rb

@@ -10,7 +10,8 @@ module ServiceField
     field(:_service, Service, null: false)
 
     def _service
-      { sdl: context.schema.class.federation_sdl(context: context) }
+      schema_class = context.schema.is_a?(GraphQL::Schema) ? context.schema.class : context.schema
+      { sdl: schema_class.federation_sdl(context: context) }
     end
   end
 end