graphql 1.12.24 → 1.13.19

data/lib/graphql/schema/enum.rb

@@ -46,20 +46,70 @@ module GraphQL
         def value(*args, **kwargs, &block)
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
-          if own_values.key?(value.graphql_name)
-            raise ArgumentError, "#{value.graphql_name} is already defined for #{self.graphql_name}, please remove one of the definitions."
+          key = value.graphql_name
+          prev_value = own_values[key]
+          case prev_value
+          when nil
+            own_values[key] = value
+          when GraphQL::Schema::EnumValue
+            own_values[key] = [prev_value, value]
+          when Array
+            prev_value << value
+          else
+            raise "Invariant: Unexpected enum value for #{key.inspect}: #{prev_value.inspect}"
+          end
+          value
+        end
+
+        # @return [Array<GraphQL::Schema::EnumValue>] Possible values of this enum
+        def enum_values(context = GraphQL::Query::NullContext)
+          inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
+          visible_values = []
+          warden = Warden.from_context(context)
+          own_values.each do |key, values_entry|
+            if (v = Warden.visible_entry?(:visible_enum_value?, values_entry, context, warden))
+              visible_values << v
+            end
+          end
+
+          if inherited_values
+            # Local values take precedence over inherited ones
+            inherited_values.each do |i_val|
+              if !visible_values.any? { |v| v.graphql_name == i_val.graphql_name }
+                visible_values << i_val
+              end
+            end
+          end
+
+          visible_values
+        end
+
+        # @return [Array<Schema::EnumValue>] An unfiltered list of all definitions
+        def all_enum_value_definitions
+          all_defns = if superclass.respond_to?(:all_enum_value_definitions)
+            superclass.all_enum_value_definitions
+          else
+            []
+          end
+
+          @own_values && @own_values.each do |_key, value|
+            if value.is_a?(Array)
+              all_defns.concat(value)
+            else
+              all_defns << value
+            end
           end
-          own_values[value.graphql_name] = value
-          nil
+
+          all_defns
         end
 
-        # @return [Hash<String => GraphQL::Schema::Enum::Value>] Possible values of this enum, keyed by name
-        def values
-          inherited_values = superclass <= GraphQL::Schema::Enum ? superclass.values : {}
-          # Local values take precedence over inherited ones
-          inherited_values.merge(own_values)
+        # @return [Hash<String => GraphQL::Schema::EnumValue>] Possible values of this enum, keyed by name.
+        def values(context = GraphQL::Query::NullContext)
+          enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::EnumType]
         def to_graphql
           enum_type = GraphQL::EnumType.new
@@ -68,7 +118,7 @@ module GraphQL
           enum_type.introspection = introspection
           enum_type.ast_node = ast_node
           values.each do |name, val|
-            enum_type.add_value(val.to_graphql)
+            enum_type.add_value(val.deprecated_to_graphql)
           end
           enum_type.metadata[:type_class] = self
           enum_type
@@ -89,9 +139,8 @@ module GraphQL
           GraphQL::TypeKinds::ENUM
         end
 
-        def validate_non_null_input(value_name, ctx)
+        def validate_non_null_input(value_name, ctx, max_errors: nil)
           result = GraphQL::Query::InputValidationResult.new
-
           allowed_values = ctx.warden.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 

data/lib/graphql/schema/enum_value.rb

@@ -73,6 +73,8 @@ module GraphQL
         @value
       end
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       # @return [GraphQL::EnumType::EnumValue] A runtime-ready object derived from this object
       def to_graphql
         enum_value = GraphQL::EnumType::EnumValue.new
@@ -85,6 +87,10 @@ module GraphQL
         enum_value
       end
 
+      def inspect
+        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}>"
+      end
+
       def visible?(_ctx); true; end
       def accessible?(_ctx); true; end
       def authorized?(_ctx); true; end

data/lib/graphql/schema/field/connection_extension.rb

@@ -42,7 +42,7 @@ module GraphQL
               value.after_value ||= original_arguments[:after]
               value.last_value ||= original_arguments[:last]
               value.before_value ||= original_arguments[:before]
-              value.arguments ||= original_arguments
+              value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
               value.field ||= field
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size

data/lib/graphql/schema/field.rb

@@ -5,10 +5,6 @@ require "graphql/schema/field/scope_extension"
 module GraphQL
   class Schema
     class Field
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
@@ -20,6 +16,8 @@ module GraphQL
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
 
+      class FieldImplementationFailed < GraphQL::Error; end
+
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
       alias :graphql_name :name
@@ -40,7 +38,9 @@ module GraphQL
 
       # @return [Class] The GraphQL type this field belongs to. (For fields defined on mutations, it's the payload type)
       def owner_type
-        @owner_type ||= if owner < GraphQL::Schema::Mutation
+        @owner_type ||= if owner.nil?
+          raise GraphQL::InvariantError, "Field #{original_name.inspect} (graphql name: #{graphql_name.inspect}) has no owner, but all fields should have an owner. How did this happen?!"
+        elsif owner < GraphQL::Schema::Mutation
           owner.payload_type
         else
           owner
@@ -61,7 +61,7 @@ module GraphQL
       end
 
       def inspect
-        "#<#{self.class} #{path}#{arguments.any? ? "(...)" : ""}: #{type.to_type_signature}>"
+        "#<#{self.class} #{path}#{all_argument_definitions.any? ? "(...)" : ""}: #{type.to_type_signature}>"
       end
 
       alias :mutation :resolver
@@ -176,6 +176,8 @@ module GraphQL
 
       # @return Boolean
       attr_reader :relay_node_field
+      # @return Boolean
+      attr_reader :relay_nodes_field
 
       # @return [Boolean] Should we warn if this field's name conflicts with a built-in method?
       def method_conflict_warning?
@@ -190,6 +192,7 @@ module GraphQL
       # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message
       # @param method [Symbol] The method to call on the underlying object to resolve this field (defaults to `name`)
       # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+      # @param dig [Array<String, Symbol>] The nested hash keys to lookup on the underlying hash to resolve this field using dig
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
@@ -212,7 +215,7 @@ module GraphQL
       # @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
       # @param legacy_edge_class [Class, nil] (DEPRECATED) If present, pass this along to the legacy field definition
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: 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, legacy_edge_class: nil, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, resolve: 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, legacy_edge_class: nil, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -220,15 +223,13 @@ module GraphQL
           if type.nil?
             raise ArgumentError, "missing second `type` argument or keyword `type:`"
           end
-          if null.nil?
-            raise ArgumentError, "missing keyword argument null:"
-          end
         end
         if (field || function || resolve) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
         @original_name = name
         name_s = -name.to_s
+
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
         @description = description
@@ -241,8 +242,8 @@ module GraphQL
         @resolve = resolve
         self.deprecation_reason = deprecation_reason
 
-        if method && hash_key
-          raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
+        if method && hash_key && dig
+          raise ArgumentError, "Provide `method:`, `hash_key:` _or_ `dig:`, not multiple. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}, dig: #{dig.inspect}`)"
         end
 
         if resolver_method
@@ -250,13 +251,18 @@ module GraphQL
             raise ArgumentError, "Provide `method:` _or_ `resolver_method:`, not both. (called with: `method: #{method.inspect}, resolver_method: #{resolver_method.inspect}`)"
           end
 
-          if hash_key
-            raise ArgumentError, "Provide `hash_key:` _or_ `resolver_method:`, not both. (called with: `hash_key: #{hash_key.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          if hash_key || dig
+            raise ArgumentError, "Provide `hash_key:`, `dig:`, _or_ `resolver_method:`, not multiple. (called with: `hash_key: #{hash_key.inspect}, dig: #{dig.inspect}, resolver_method: #{resolver_method.inspect}`)"
           end
         end
 
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
         method_name = method || hash_key || name_s
+        @dig_keys = dig
+        if hash_key
+          @hash_key = hash_key
+        end
+
         resolver_method ||= name_s.to_sym
 
         @method_str = -method_name.to_s
@@ -281,10 +287,15 @@ module GraphQL
         @legacy_edge_class = legacy_edge_class
 
         arguments.each do |name, arg|
-          if arg.is_a?(Hash)
+          case arg
+          when Hash
             argument(name: name, **arg)
-          else
+          when GraphQL::Schema::Argument
             add_argument(arg)
+          when Array
+            arg.each { |a| add_argument(a) }
+          else
+            raise ArgumentError, "Unexpected argument config (#{arg.class}): #{arg.inspect}"
           end
         end
 
@@ -292,6 +303,7 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         @extensions = EMPTY_ARRAY
+        @call_after_define = false
         # This should run before connection extension,
         # but should it run after the definition block?
         if scoped?
@@ -324,6 +336,9 @@ module GraphQL
             instance_eval(&definition_block)
           end
         end
+
+        self.extensions.each(&:after_define_apply)
+        @call_after_define = true
       end
 
       # If true, subscription updates with this field can be shared between viewers
@@ -356,27 +371,20 @@ module GraphQL
       # @example adding an extension with options
       #   extensions([MyExtensionClass, { AnotherExtensionClass => { filter: true } }])
       #
-      # @param extensions [Array<Class, Hash<Class => Object>>] Add extensions to this field. For hash elements, only the first key/value is used.
+      # @param extensions [Array<Class, Hash<Class => Hash>>] Add extensions to this field. For hash elements, only the first key/value is used.
       # @return [Array<GraphQL::Schema::FieldExtension>] extensions to apply to this field
       def extensions(new_extensions = nil)
-        if new_extensions.nil?
-          # Read the value
-          @extensions
-        else
-          if @extensions.frozen?
-            @extensions = @extensions.dup
-          end
-          new_extensions.each do |extension|
-            if extension.is_a?(Hash)
-              extension = extension.to_a[0]
-              extension_class, options = *extension
-              @extensions << extension_class.new(field: self, options: options)
+        if new_extensions
+          new_extensions.each do |extension_config|
+            if extension_config.is_a?(Hash)
+              extension_class, options = *extension_config.to_a[0]
+              self.extension(extension_class, options)
             else
-              extension_class = extension
-              @extensions << extension_class.new(field: self, options: nil)
+              self.extension(extension_config)
             end
           end
         end
+        @extensions
       end
 
       # Add `extension` to this field, initialized with `options` if provided.
@@ -387,10 +395,19 @@ module GraphQL
       # @example adding an extension with options
       #   extension(MyExtensionClass, filter: true)
       #
-      # @param extension [Class] subclass of {Schema::Fieldextension}
-      # @param options [Object] if provided, given as `options:` when initializing `extension`.
-      def extension(extension, options = nil)
-        extensions([{extension => options}])
+      # @param extension_class [Class] subclass of {Schema::FieldExtension}
+      # @param options [Hash] if provided, given as `options:` when initializing `extension`.
+      # @return [void]
+      def extension(extension_class, options = nil)
+        extension_inst = extension_class.new(field: self, options: options)
+        if @extensions.frozen?
+          @extensions = @extensions.dup
+        end
+        if @call_after_define
+          extension_inst.after_define_apply
+        end
+        @extensions << extension_inst
+        nil
       end
 
       # Read extras (as symbols) from this field,
@@ -411,6 +428,71 @@ module GraphQL
         end
       end
 
+      def calculate_complexity(query:, nodes:, child_complexity:)
+        if respond_to?(:complexity_for)
+          lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
+          complexity_for(child_complexity: child_complexity, query: query, lookahead: lookahead)
+        elsif connection?
+          arguments = query.arguments_for(nodes.first, self)
+          max_possible_page_size = nil
+          if arguments.respond_to?(:[]) # It might have been an error
+            if arguments[:first]
+              max_possible_page_size = arguments[:first]
+            end
+
+            if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
+              max_possible_page_size = arguments[:last]
+            end
+          end
+
+          if max_possible_page_size.nil?
+            max_possible_page_size = max_page_size || query.schema.default_max_page_size
+          end
+
+          if max_possible_page_size.nil?
+            raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `max_page_size` or `default_max_page_size`"
+          else
+            metadata_complexity = 0
+            lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
+
+            if (page_info_lookahead = lookahead.selection(:page_info)).selected?
+              metadata_complexity += 1 # pageInfo
+              metadata_complexity += page_info_lookahead.selections.size # subfields
+            end
+
+            if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count)
+              metadata_complexity += 1
+            end
+
+            nodes_edges_complexity = 0
+            nodes_edges_complexity += 1 if lookahead.selects?(:edges)
+            nodes_edges_complexity += 1 if lookahead.selects?(:nodes)
+
+            # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be?
+            items_complexity = child_complexity - metadata_complexity - nodes_edges_complexity
+            # Add 1 for _this_ field
+            1 + (max_possible_page_size * items_complexity) + metadata_complexity + nodes_edges_complexity
+          end
+        else
+          defined_complexity = complexity
+          case defined_complexity
+          when Proc
+            arguments = query.arguments_for(nodes.first, self)
+            if arguments.is_a?(GraphQL::ExecutionError)
+              return child_complexity
+            elsif arguments.respond_to?(:keyword_arguments)
+              arguments = arguments.keyword_arguments
+            end
+
+            defined_complexity.call(query.context, arguments, child_complexity)
+          when Numeric
+            defined_complexity + child_complexity
+          else
+            raise("Invalid complexity: #{defined_complexity.inspect} on #{path} (#{inspect})")
+          end
+        end
+      end
+
       def complexity(new_complexity = nil)
         case new_complexity
         when Proc
@@ -439,6 +521,8 @@ module GraphQL
       # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
       attr_reader :max_page_size
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       # @return [GraphQL::Field]
       def to_graphql
         field_defn = if @field
@@ -493,9 +577,9 @@ module GraphQL
         field_defn.subscription_scope = @subscription_scope
         field_defn.ast_node = ast_node
 
-        arguments.each do |name, defn|
-          arg_graphql = defn.to_graphql
-          field_defn.arguments[arg_graphql.name] = arg_graphql
+        all_argument_definitions.each do |defn|
+          arg_graphql = defn.deprecated_to_graphql
+          field_defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         end
 
         # Support a passed-in proc, one way or another
@@ -556,13 +640,41 @@ module GraphQL
 
       def authorized?(object, args, context)
         if @resolver_class
-          # The resolver will check itself during `resolve()`
+          # The resolver _instance_ will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
-          # Faster than `.any?`
-          arguments.each_value do |arg|
-            if args.key?(arg.keyword) && !arg.authorized?(object, args[arg.keyword], context)
-              return false
+          if (arg_values = context[:current_arguments])
+            # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
+            using_arg_values = true
+            arg_values = arg_values.argument_values
+          else
+            arg_values = args
+            using_arg_values = false
+          end
+          if args.size > 0
+            args = context.warden.arguments(self)
+            args.each do |arg|
+              arg_key = arg.keyword
+              if arg_values.key?(arg_key)
+                arg_value = arg_values[arg_key]
+                if using_arg_values
+                  if arg_value.default_used?
+                    # pass -- no auth required for default used
+                    next
+                  else
+                    application_arg_value = arg_value.value
+                    if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
+                      application_arg_value.keyword_arguments
+                    end
+                  end
+                else
+                  application_arg_value = arg_value
+                end
+
+                if !arg.authorized?(object, application_arg_value, context)
+                  return false
+                end
+              end
             end
           end
           true
@@ -659,7 +771,7 @@ module GraphQL
           ruby_kwargs = graphql_args.to_kwargs
           maybe_lazies = []
           # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
-          arguments.each do |name, arg_defn|
+          arguments(field_ctx).each do |name, arg_defn|
             ruby_kwargs_key = arg_defn.keyword
 
             if ruby_kwargs.key?(ruby_kwargs_key)
@@ -704,51 +816,107 @@ module GraphQL
 
       def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
         with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
-          if @resolver_class
-            if obj.is_a?(GraphQL::Schema::Object)
-              obj = obj.object
-            end
-            obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
-          end
-
-          # Find a way to resolve this field, checking:
-          #
-          # - A method on the type instance;
-          # - Hash keys, if the wrapped object is a hash;
-          # - A method on the wrapped object;
-          # - Or, raise not implemented.
-          #
-          if obj.respond_to?(@resolver_method)
-            # Call the method with kwargs, if there are any
-            if ruby_kwargs.any?
-              obj.public_send(@resolver_method, **ruby_kwargs)
-            else
-              obj.public_send(@resolver_method)
+          begin
+            method_receiver = nil
+            method_to_call = nil
+            if @resolver_class
+              if obj.is_a?(GraphQL::Schema::Object)
+                obj = obj.object
+              end
+              obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
             end
-          elsif obj.object.is_a?(Hash)
-            inner_object = obj.object
-            if inner_object.key?(@method_sym)
-              inner_object[@method_sym]
+
+            # Find a way to resolve this field, checking:
+            #
+            # - A method on the type instance;
+            # - Hash keys, if the wrapped object is a hash or responds to `#[]`
+            # - A method on the wrapped object;
+            # - Or, raise not implemented.
+            #
+            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)
+              else
+                obj.public_send(@resolver_method)
+              end
+            elsif obj.object.is_a?(Hash)
+              inner_object = obj.object
+              if @dig_keys
+                inner_object.dig(*@dig_keys)
+              elsif inner_object.key?(@method_sym)
+                inner_object[@method_sym]
+              else
+                inner_object[@method_str]
+              end
+            elsif defined?(@hash_key) && obj.object.respond_to?(:[])
+              obj.object[@hash_key]
+            elsif obj.object.respond_to?(@method_sym)
+              method_to_call = @method_sym
+              method_receiver = obj.object
+              if ruby_kwargs.any?
+                obj.object.public_send(@method_sym, **ruby_kwargs)
+              else
+                obj.object.public_send(@method_sym)
+              end
             else
-              inner_object[@method_str]
+              raise <<-ERR
+            Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+
+            - `#{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
+
+            To implement this field, define one of the methods above (and check for typos)
+            ERR
             end
-          elsif obj.object.respond_to?(@method_sym)
-            if ruby_kwargs.any?
-              obj.object.public_send(@method_sym, **ruby_kwargs)
+          rescue ArgumentError
+            assert_satisfactory_implementation(method_receiver, method_to_call, ruby_kwargs)
+            # if the line above doesn't raise, re-raise
+            raise
+          end
+        end
+      end
+
+      def assert_satisfactory_implementation(receiver, method_name, ruby_kwargs)
+        method_defn = receiver.method(method_name)
+        unsatisfied_ruby_kwargs = ruby_kwargs.dup
+        unsatisfied_method_params = []
+        encountered_keyrest = false
+        method_defn.parameters.each do |(param_type, param_name)|
+          case param_type
+          when :key
+            unsatisfied_ruby_kwargs.delete(param_name)
+          when :keyreq
+            if unsatisfied_ruby_kwargs.key?(param_name)
+              unsatisfied_ruby_kwargs.delete(param_name)
             else
-              obj.object.public_send(@method_sym)
+              unsatisfied_method_params << "- `#{param_name}:` is required by Ruby, but not by GraphQL. Consider `#{param_name}: nil` instead, or making this argument required in GraphQL."
             end
-          else
-            raise <<-ERR
-          Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+          when :keyrest
+            encountered_keyrest = true
+          when :req
+            unsatisfied_method_params << "- `#{param_name}` is required by Ruby, but GraphQL doesn't pass positional arguments. If it's meant to be a GraphQL argument, use `#{param_name}:` instead. Otherwise, remove it."
+          when :opt, :rest
+            # This is fine, although it will never be present
+          end
+        end
+
+        if encountered_keyrest
+          unsatisfied_ruby_kwargs.clear
+        end
 
-          - `#{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
+        if unsatisfied_ruby_kwargs.any? || unsatisfied_method_params.any?
+          raise FieldImplementationFailed.new, <<-ERR
+Failed to call #{method_name} on #{receiver.inspect} because the Ruby method params were incompatible with the GraphQL arguments:
 
-          To implement this field, define one of the methods above (and check for typos)
-          ERR
-          end
+#{ unsatisfied_ruby_kwargs
+    .map { |key, value| "- `#{key}: #{value}` was given by GraphQL but not defined in the Ruby method. Add `#{key}:` to the method parameters." }
+    .concat(unsatisfied_method_params)
+    .join("\n") }
+ERR
         end
       end
 
@@ -762,8 +930,12 @@ module GraphQL
           # This is a hack to get the _last_ value for extended obj and args,
           # in case one of the extensions doesn't `yield`.
           # (There's another implementation that uses multiple-return, but I'm wary of the perf cost of the extra arrays)
-          extended = { args: args, obj: obj, memos: nil }
+          extended = { args: args, obj: obj, memos: nil, added_extras: nil }
           value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
+            if (added_extras = extended[:added_extras])
+              args = args.dup
+              added_extras.each { |e| args.delete(e) }
+            end
             yield(obj, args)
           end
 
@@ -792,6 +964,12 @@ module GraphQL
               memos = extended[:memos] ||= {}
               memos[idx] = memo
             end
+
+            if (extras = extension.added_extras)
+              ae = extended[:added_extras] ||= []
+              ae.concat(extras)
+            end
+
             extended[:obj] = extended_obj
             extended[:args] = extended_args
             run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }