refactor(BaseType) unify logic for types that have possible types

Author: rmosolgo

lib/graphql/base_type.rb

@@ -26,6 +26,35 @@ def unwrap
       end
     end
 
+    # Find out which possible type to use for `value`.
+    # Returns self if there are no possible types (ie, not Union or Interface)
+    def resolve_type(value)
+      self
+    end
+
+    module HasPossibleTypes
+      # Return the implementing type for `object`.
+      # The default implementation assumes that there's a type with the same name as `object.class.name`.
+      # Maybe you'll need to override this in your own interfaces!
+      #
+      # @param object [Object] the object which needs a type to expose it
+      # @return [GraphQL::ObjectType] the type which should expose `object`
+      def resolve_type(object)
+        instance_exec(object, &@resolve_type_proc)
+      end
+
+      # The default implementation of {#resolve_type} gets `object.class.name`
+      # and finds a type with the same name
+      DEFAULT_RESOLVE_TYPE = -> (object) {
+        type_name = object.class.name
+        possible_types.find {|t| t.name == type_name}
+      }
+
+      def resolve_type=(new_proc)
+        @resolve_type_proc = new_proc || DEFAULT_RESOLVE_TYPE
+      end
+    end
+
     # Print the human-readable name of this type
     def to_s
       Printer.instance.print(self)

lib/graphql/interface_type.rb

@@ -11,15 +11,9 @@
 #   end
 #
 class GraphQL::InterfaceType < GraphQL::BaseType
+  include GraphQL::BaseType::HasPossibleTypes
   defined_by_config :name, :description, :fields, :resolve_type
-  attr_accessor :name, :description, :fields, :resolve_type
-
-  # The default implementation of {#resolve_type} gets `object.class.name`
-  # and finds a type with the same name
-  DEFAULT_RESOLVE_TYPE = -> (object) {
-    type_name = object.class.name
-    possible_types.find {|t| t.name == type_name}
-  }
+  attr_accessor :name, :description, :fields
 
   def kind
     GraphQL::TypeKinds::INTERFACE
@@ -29,18 +23,4 @@ def kind
   def possible_types
     @possible_types ||= []
   end
-
-  # Return the implementing type for `object`.
-  # The default implementation assumes that there's a type with the same name as `object.class.name`.
-  # Maybe you'll need to override this in your own interfaces!
-  #
-  # @param object [Object] the object which needs a type to expose it
-  # @return [GraphQL::ObjectType] the type which should expose `object`
-  def resolve_type(object)
-    instance_exec(object, &@resolve_type_proc)
-  end
-
-  def resolve_type=(new_proc)
-    @resolve_type_proc = new_proc || DEFAULT_RESOLVE_TYPE
-  end
 end

lib/graphql/query/base_execution/value_resolution.rb

@@ -38,7 +38,7 @@ class ListResolution < BaseResolution
           def result
             wrapped_type = field_type.of_type
             value.map do |item|
-              resolved_type = wrapped_type.kind.resolve(wrapped_type, item)
+              resolved_type = wrapped_type.resolve_type(item)
               strategy_class = get_strategy_for_kind(resolved_type.kind)
               inner_strategy = strategy_class.new(item, resolved_type, target, parent_type, ast_field, query, execution_strategy)
               inner_strategy.result
@@ -62,7 +62,7 @@ def result
         class NonNullResolution < BaseResolution
           def result
             wrapped_type = field_type.of_type
-            resolved_type = wrapped_type.kind.resolve(wrapped_type, value)
+            resolved_type = wrapped_type.resolve_type(value)
             strategy_class = get_strategy_for_kind(resolved_type.kind)
             inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, query, execution_strategy)
             inner_strategy.result

lib/graphql/query/serial_execution/field_resolution.rb

@@ -22,7 +22,7 @@ def get_finished_value(raw_value)
           if raw_value.nil?
             nil
           else
-            resolved_type = field.type.kind.resolve(field.type, raw_value)
+            resolved_type = field.type.resolve_type(raw_value)
             strategy_class = GraphQL::Query::BaseExecution::ValueResolution.get_strategy_for_kind(resolved_type.kind)
             result_strategy = strategy_class.new(raw_value, resolved_type, target, parent_type, ast_node, query, execution_strategy)
             result_strategy.result

lib/graphql/type_kinds.rb

@@ -23,15 +23,6 @@ def input?;     @input;     end
     def to_s;       @name;      end
     # Is this TypeKind composed of many values?
     def composite?; @composite; end
-
-    # Get the implementing type for `value` from `type` (no-op for TypeKinds which don't `resolves?`)
-    def resolve(type, value)
-      if resolves?
-        type.resolve_type(value)
-      else
-        type
-      end
-    end
   end
 
   TYPE_KINDS = [

lib/graphql/union_type.rb

@@ -9,19 +9,11 @@
 #   end
 #
 class GraphQL::UnionType < GraphQL::BaseType
-  attr_accessor :name, :description, :possible_types, :resolve_type
+  include GraphQL::BaseType::HasPossibleTypes
+  attr_accessor :name, :description, :possible_types
   defined_by_config :name, :description, :possible_types, :resolve_type
 
   def kind
     GraphQL::TypeKinds::UNION
   end
-
-  # @see {InterfaceType#resolve_type}
-  def resolve_type(object)
-    instance_exec(object, &@resolve_type_proc)
-  end
-
-  def resolve_type=(new_proc)
-    @resolve_type_proc = new_proc || GraphQL::InterfaceType::DEFAULT_RESOLVE_TYPE
-  end
 end

readme.md

@@ -97,8 +97,6 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 - Code clean-up
   - Raise if you try to configure an attribute which doesn't suit the type
     - ie, if you try to define `resolve` on an ObjectType, it should somehow raise
-  - Make better inheritance between types
-    - Also move `TypeKind#resolve` ?
 - Big ideas:
   - Cook up some path other than "n+1s everywhere"
     - See Sangria's `project` approach ([in progress](https://github.com/rmosolgo/graphql-ruby/pull/15))