Merge pull request #3916 from rmosolgo/resolver-dynamism

Make many Field properties delegate to @resolver_class instead of calling .field_options once

Author: rmosolgo

lib/graphql/schema/field.rb

@@ -29,7 +29,13 @@ class FieldImplementationFailed < GraphQL::Error; end
       attr_reader :method_str
 
       # @return [Symbol] The method on the type to look up
-      attr_reader :resolver_method
+      def resolver_method
+        if @resolver_class
+          @resolver_class.resolver_method
+        else
+          @resolver_method
+        end
+      end
 
       # @return [Class] The thing this field was defined on (type, mutation, resolver)
       attr_accessor :owner
@@ -68,7 +74,10 @@ def inspect
       attr_reader :trace
 
       # @return [String, nil]
-      attr_accessor :subscription_scope
+      def subscription_scope
+        @subscription_scope || (@resolver_class.respond_to?(:subscription_scope) ? @resolver_class.subscription_scope : nil)
+      end
+      attr_writer :subscription_scope
 
       # Create a field instance from a list of arguments, keyword arguments, and a block.
       #
@@ -82,11 +91,9 @@ def inspect
       # @return [GraphQL::Schema:Field] an instance of `self
       # @see {.initialize} for other options
       def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
-        if (parent_config = resolver || mutation || subscription)
-          # Get the parent config, merge in local overrides
-          kwargs = parent_config.field_options.merge(kwargs)
+        if (resolver_class = resolver || mutation || subscription)
           # Add a reference to that parent class
-          kwargs[:resolver_class] = parent_config
+          kwargs[:resolver_class] = resolver_class
         end
 
         if name
@@ -119,7 +126,9 @@ def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutatio
       def connection?
         if @connection.nil?
           # Provide default based on type name
-          return_type_name = if @return_type_expr
+          return_type_name = if @resolver_class && @resolver_class.type
+            Member::BuildType.to_type_name(@resolver_class.type)
+          elsif @return_type_expr
             Member::BuildType.to_type_name(@return_type_expr)
           else
             # As a last ditch, try to force loading the return type:
@@ -192,7 +201,7 @@ def method_conflict_warning?
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
-      def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -238,7 +247,9 @@ def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, d
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
         @introspection = introspection
         @extras = extras
-        @broadcastable = broadcastable
+        if !broadcastable.nil?
+          @broadcastable = broadcastable
+        end
         @resolver_class = resolver_class
         @scope = scope
         @trace = trace
@@ -282,6 +293,10 @@ def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, d
           self.extensions(extensions)
         end
 
+        if resolver_class && resolver_class.extensions.any?
+          self.extensions(resolver_class.extensions)
+        end
+
         if directives.any?
           directives.each do |(dir_class, options)|
             self.directive(dir_class, **options)
@@ -306,14 +321,22 @@ def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, d
       # @return [Boolean, nil]
       # @see GraphQL::Subscriptions::BroadcastAnalyzer
       def broadcastable?
-        @broadcastable
+        if defined?(@broadcastable)
+          @broadcastable
+        elsif @resolver_class
+          @resolver_class.broadcastable?
+        else
+          nil
+        end
       end
 
       # @param text [String]
       # @return [String]
       def description(text = nil)
         if text
           @description = text
+        elsif @resolver_class
+          @description || @resolver_class.description
         else
           @description
         end
@@ -379,7 +402,12 @@ def extension(extension_class, options = nil)
       def extras(new_extras = nil)
         if new_extras.nil?
           # Read the value
-          @extras
+          field_extras = @extras
+          if @resolver_class && @resolver_class.extras.any?
+            field_extras + @resolver_class.extras
+          else
+            field_extras
+          end
         else
           if @extras.frozen?
             @extras = @extras.dup
@@ -462,33 +490,43 @@ def complexity(new_complexity = nil)
         when Numeric
           @complexity = new_complexity
         when nil
-          @complexity
+          if @resolver_class
+            @complexity || @resolver_class.complexity || 1
+          else
+            @complexity || 1
+          end
         else
           raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
         end
       end
 
       # @return [Boolean] True if this field's {#max_page_size} should override the schema default.
       def has_max_page_size?
-        @has_max_page_size
+        @has_max_page_size || (@resolver_class && @resolver_class.has_max_page_size?)
       end
 
       # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
-      attr_reader :max_page_size
+      def max_page_size
+        @max_page_size || (@resolver_class && @resolver_class.max_page_size)
+      end
 
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 
       def type
-        @type ||= if @return_type_expr.nil?
-          # Not enough info to determine type
-          message = "Can't determine the return type for #{self.path}"
-          if @resolver_class
-            message += " (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
-          end
-          raise MissingReturnTypeError, message
+        if @resolver_class && (t = @resolver_class.type)
+          t
         else
-          Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          @type ||= if @return_type_expr.nil?
+            # Not enough info to determine type
+            message = "Can't determine the return type for #{self.path}"
+            if @resolver_class
+              message += " (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
+            end
+            raise MissingReturnTypeError, message
+          else
+            Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          end
         end
       rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up
@@ -618,14 +656,14 @@ def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
             # - A method on the wrapped object;
             # - Or, raise not implemented.
             #
-            if obj.respond_to?(@resolver_method)
-              method_to_call = @resolver_method
+            if obj.respond_to?(resolver_method)
+              method_to_call = resolver_method
               method_receiver = obj
               # Call the method with kwargs, if there are any
               if ruby_kwargs.any?
-                obj.public_send(@resolver_method, **ruby_kwargs)
+                obj.public_send(resolver_method, **ruby_kwargs)
               else
-                obj.public_send(@resolver_method)
+                obj.public_send(resolver_method)
               end
             elsif obj.object.is_a?(Hash)
               inner_object = obj.object
@@ -648,7 +686,7 @@ def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
               raise <<-ERR
             Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
-            - `#{obj.class}##{@resolver_method}`, which did not exist
+            - `#{obj.class}##{resolver_method}`, 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
 

lib/graphql/schema/member/has_arguments.rb

@@ -78,23 +78,44 @@ def #{method_owner}load_#{arg_defn.keyword}(value, _context = nil)
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
           @own_arguments ||= {}
-          prev_defn = own_arguments[arg_defn.name]
+          prev_defn = @own_arguments[arg_defn.name]
           case prev_defn
           when nil
-            own_arguments[arg_defn.name] = arg_defn
+            @own_arguments[arg_defn.name] = arg_defn
           when Array
             prev_defn << arg_defn
           when GraphQL::Schema::Argument
-            own_arguments[arg_defn.name] = [prev_defn, arg_defn]
+            @own_arguments[arg_defn.name] = [prev_defn, arg_defn]
           else
             raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
           end
           arg_defn
         end
 
+        def remove_argument(arg_defn)
+          prev_defn = @own_arguments[arg_defn.name]
+          case prev_defn
+          when nil
+            # done
+          when Array
+            prev_defn.delete(arg_defn)
+          when GraphQL::Schema::Argument
+            @own_arguments.delete(arg_defn.name)
+          else
+            raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
+          end
+          nil
+        end
+
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
         def arguments(context = GraphQL::Query::NullContext)
-          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments(context) : nil)
+          inherited_arguments = if self.is_a?(Class) && superclass.respond_to?(:arguments)
+            superclass.arguments(context)
+          elsif defined?(@resolver_class) && @resolver_class
+            @resolver_class.field_arguments(context)
+          else
+            nil
+          end
           # Local definitions override inherited ones
           if own_arguments.any?
             own_arguments_that_apply = {}
@@ -125,6 +146,10 @@ def all_argument_definitions
                 all_defns.merge!(ancestor.own_arguments)
               end
             end
+          elsif defined?(@resolver_class) && @resolver_class
+            all_defns = {}
+            all_defns.merge!(@resolver_class.own_field_arguments)
+            all_defns.merge!(own_arguments)
           else
             all_defns = own_arguments
           end
@@ -137,8 +162,13 @@ def all_argument_definitions
         def get_argument(argument_name, context = GraphQL::Query::NullContext)
           warden = Warden.from_context(context)
           if !self.is_a?(Class)
-            a = own_arguments[argument_name]
-            a && Warden.visible_entry?(:visible_argument?, a, context, warden)
+            if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
+              visible_arg
+            elsif defined?(@resolver_class) && @resolver_class
+              @resolver_class.get_field_argument(argument_name, context)
+            else
+              nil
+            end
           else
             for ancestor in ancestors
               if ancestor.respond_to?(:own_arguments) &&

lib/graphql/schema/relay_classic_mutation.rb

@@ -70,11 +70,32 @@ def resolve_with_support(**inputs)
       end
 
       class << self
+        def dummy
+          @dummy ||= begin
+            d = Class.new(GraphQL::Schema::Resolver)
+            d.argument_class(self.argument_class)
+            # TODO make this lazier?
+            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
+            d
+          end
+        end
+
+        def field_arguments(context = GraphQL::Query::NullContext)
+          dummy.arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext)
+          dummy.get_argument(name, context)
+        end
+
+        def own_field_arguments
+          dummy.own_arguments
+        end
 
         # Also apply this argument to the input type:
-        def argument(*args, **kwargs, &block)
+        def argument(*args, own_argument: false, **kwargs, &block)
           it = input_type # make sure any inherited arguments are already added to it
-          arg = super
+          arg = super(*args, **kwargs, &block)
 
           # This definition might be overriding something inherited;
           # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
@@ -114,27 +135,24 @@ def input_type(new_input_type = nil)
           @input_type ||= generate_input_type
         end
 
-        # Extend {Schema::Mutation.field_options} to add the `input` argument
-        def field_options
-          sig = super
-          # Arguments were added at the root, but they should be nested
-          sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
-          sig
-        end
-
         private
 
         # Generate the input type for the `input:` argument
         # To customize how input objects are generated, override this method
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
           mutation_args = all_argument_definitions
-          mutation_name = graphql_name
           mutation_class = self
           Class.new(input_object_class) do
-            graphql_name("#{mutation_name}Input")
-            description("Autogenerated input type of #{mutation_name}")
+            class << self
+              def default_graphql_name
+                "#{self.mutation.graphql_name}Input"
+              end
+
+              def description(new_desc = nil)
+                super || "Autogenerated input type of #{self.mutation.graphql_name}"
+              end
+            end
             mutation(mutation_class)
             # these might be inherited:
             mutation_args.each do |arg|