Centralize default resolve in HasFields

Author: rmosolgo

lib/graphql/introspection/base_object.rb

@@ -9,6 +9,7 @@ def self.field(*args, **kwargs, &block)
 
       def self.inherited(child_class)
         child_class.introspection(true)
+        super
       end
     end
   end

lib/graphql/schema/interface.rb

@@ -29,10 +29,6 @@ def included(child_class)
             child_class.own_interfaces.each do |interface_defn|
               child_class.extend(interface_defn::DefinitionMethods)
             end
-            # Also, prepare a place for default field implementations
-            default_resolve_module = Module.new
-            child_class.const_set(:DefaultResolve, default_resolve_module)
-            child_class.include(default_resolve_module)
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
             backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}

lib/graphql/schema/member/has_fields.rb

@@ -4,6 +4,42 @@ class Schema
     class Member
       # Shared code for Object and Interface
       module HasFields
+        class << self
+          # When this module is added to a class,
+          # add a place for that class's default behaviors
+          def self.extended(child_class)
+            add_default_resolve_module(child_class)
+            super
+          end
+
+          def add_default_resolve_module(child_class)
+            if child_class.instance_variable_get(:@_default_resolve)
+              # This can happen when an object implements an interface,
+              # since that interface has the `included` hook above.
+              return
+            end
+
+            default_resolve_module = Module.new
+            child_class.instance_variable_set(:@_default_resolve, default_resolve_module)
+            child_class.include(default_resolve_module)
+          end
+        end
+
+        # When this is included into interfaces,
+        # add a place for default field behaviors
+        def included(child_class)
+          HasFields.add_default_resolve_module(child_class)
+          # Also, prepare a place for default field implementations
+          super
+        end
+
+        # When a subclass of objects are created,
+        # add a place for that subclass's default field behaviors
+        def inherited(child_class)
+          HasFields.add_default_resolve_module(child_class)
+          super
+        end
+
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
         # @return [void]
@@ -31,15 +67,23 @@ def fields
         # @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
+          # Add a `super` method for implementing this field:
+          field_key = field_defn.name.inspect
+          default_resolve_module = self.instance_variable_get(:@_default_resolve)
+          if default_resolve_module.nil?
+            # This should have been set up in one of the inherited or included hooks above,
+            # if it wasn't, it's because those hooks weren't called because `super` wasn't present.
+            raise <<-ERR
+Uh oh! #{self} doesn't have a default resolve module. This probably means that an `inherited` hook didn't call super.
+Check `inherited` on #{self}'s superclasses.
+ERR
           end
+          default_resolve_module.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
           nil
         end
 

lib/graphql/schema/mutation.rb

@@ -85,6 +85,7 @@ def resolve(**args)
       class << self
         def inherited(base)
           base.null(null)
+          super
         end
 
         # Override the method from HasFields to support `field: Mutation.field`, for backwards compat.

lib/graphql/schema/object.rb

@@ -71,16 +71,6 @@ 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

lib/graphql/schema/relay_classic_mutation.rb

@@ -26,6 +26,7 @@ class RelayClassicMutation < GraphQL::Schema::Mutation
       class << self
         def inherited(base)
           base.null(true)
+          super
         end
 
         # The base class for generated input object types