Support super on object fields

Author: rmosolgo

lib/graphql/schema/field.rb

@@ -232,39 +232,49 @@ def resolve_field(obj, args, ctx)
           inner_obj = obj && obj.object
           prev_resolve.call(inner_obj, args, ctx)
         else
-          resolve_field_dynamic(obj, args, ctx)
+          public_send_field(obj, @method_sym, args, ctx)
         end
       end
 
-      private
-
-      # Try a few ways to resolve the field
-      # @api private
-      def resolve_field_dynamic(obj, args, ctx)
-        if obj.respond_to?(@method_sym)
-          public_send_field(obj, @method_sym, args, ctx)
-        elsif obj.object.is_a?(Hash)
+      # Find a way to resolve this field, checking:
+      #
+      # - Hash keys, if the wrapped object is a hash;
+      # - A method on the wrapped object;
+      # - Or, raise not implemented.
+      #
+      # This can be overridden by defining a method on the object type.
+      # @param obj [GraphQL::Schema::Object]
+      # @param ruby_kwargs [Hash<Symbol => Object>]
+      # @param ctx [GraphQL::Query::Context]
+      def resolve_field_method(obj, ruby_kwargs, ctx)
+        if obj.object.is_a?(Hash)
           inner_object = obj.object
           if inner_object.key?(@method_sym)
             inner_object[@method_sym]
           else
             inner_object[@method_str]
           end
         elsif obj.object.respond_to?(@method_sym)
-          public_send_field(obj.object, @method_sym, args, ctx)
+          if ruby_kwargs.any?
+            obj.object.public_send(@method_sym, **ruby_kwargs)
+          else
+            obj.object.public_send(@method_sym)
+          end
         else
           raise <<-ERR
-Failed to implement #{ctx.irep_node.owner_type.name}.#{ctx.field.name}, tried:
+        Failed to implement #{ctx.irep_node.owner_type.name}.#{ctx.field.name}, tried:
 
-- `#{obj.class}##{@method_sym}`, which did not exist
-- `#{obj.object.class}##{@method_sym}`, which did not exist
-- Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+        - `#{obj.class}##{@method_sym}`, which did not exist
+        - `#{obj.object.class}##{@method_sym}`, which did not exist
+        - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
 
-To implement this field, define one of the methods above (and check for typos)
-ERR
+        To implement this field, define one of the methods above (and check for typos)
+        ERR
         end
       end
 
+      private
+
       NO_ARGS = {}.freeze
 
       def public_send_field(obj, method_name, graphql_args, field_ctx)

lib/graphql/schema/member/has_fields.rb

@@ -25,11 +25,21 @@ def fields
           all_fields
         end
 
-        # Register this field with the class, overriding a previous one if needed
+        # Register this field with the class, overriding a previous one if needed.
+        # Also, add a parent method for resolving this field.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
           own_fields[field_defn.name] = field_defn
+          if defined?(self::DefaultResolve)
+            field_key = field_defn.name.inspect
+            self::DefaultResolve.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{field_defn.method_sym}(**args)
+                field_inst = self.class.fields[#{field_key}] || raise(%|Failed to find field #{field_key} for \#{self.class} among \#{self.class.fields.keys}|)
+                field_inst.resolve_field_method(self, args, context)
+              end
+            RUBY
+          end
           nil
         end
 

lib/graphql/schema/object.rb

@@ -71,6 +71,16 @@ def to_graphql
 
           obj_type
         end
+
+        # When a subclass is created, give it a DefaultResolve module.
+        # That module has the base methods for executing fields.
+        # That way, later method definitions can call `super` to get the default behavior.
+        def inherited(child_class)
+          default_resolve_module = Module.new
+          child_class.const_set(:DefaultResolve, default_resolve_module)
+          child_class.include(default_resolve_module)
+          super
+        end
       end
     end
   end

spec/support/jazz.rb

@@ -302,6 +302,11 @@ def self.resolve_type(object, context)
 
   class HashKeyTest < BaseObject
     field :falsey, Boolean, null: false
+
+    def falsey
+      # test that super can be used in objects
+      super
+    end
   end
 
   # Another new-style definition, with method overrides