graphql 1.12.18 → 1.13.0

data/lib/graphql/schema/member/has_arguments.rb

@@ -78,30 +78,72 @@ module GraphQL
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
           @own_arguments ||= {}
-          own_arguments[arg_defn.name] = arg_defn
+          prev_defn = own_arguments[arg_defn.name]
+          case prev_defn
+          when nil
+            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]
+          else
+            raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
+          end
           arg_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
-        def arguments
-          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : nil)
+        def arguments(context = GraphQL::Query::NullContext)
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments(context) : nil)
           # Local definitions override inherited ones
+          if own_arguments.any?
+            own_arguments_that_apply = {}
+            own_arguments.each do |name, args_entry|
+              if (visible_defn = Warden.visible_entry?(:visible_argument?, args_entry, context))
+                own_arguments_that_apply[visible_defn.graphql_name] = visible_defn
+              end
+            end
+          end
+
           if inherited_arguments
-            inherited_arguments.merge(own_arguments)
+            if own_arguments_that_apply
+              inherited_arguments.merge(own_arguments_that_apply)
+            else
+              inherited_arguments
+            end
           else
-            own_arguments
+            # might be nil if there are actually no arguments
+            own_arguments_that_apply || own_arguments
           end
         end
 
-        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
-        def get_argument(argument_name)
-          a = own_arguments[argument_name]
+        def all_argument_definitions
+          if self.is_a?(Class)
+            all_defns = {}
+            ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_arguments)
+                all_defns.merge!(ancestor.own_arguments)
+              end
+            end
+          else
+            all_defns = own_arguments
+          end
+          all_defns = all_defns.values
+          all_defns.flatten!
+          all_defns
+        end
 
-          if a || !self.is_a?(Class)
-            a
+        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
+        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)
           else
             for ancestor in ancestors
-              if ancestor.respond_to?(:own_arguments) && a = ancestor.own_arguments[argument_name]
+              if ancestor.respond_to?(:own_arguments) &&
+                (a = ancestor.own_arguments[argument_name]) &&
+                (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
                 return a
               end
             end
@@ -125,7 +167,7 @@ module GraphQL
         # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
         def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
-          arg_defns = self.arguments
+          arg_defns = self.arguments(context)
           total_args_count = arg_defns.size
 
           finished_args = nil
@@ -191,7 +233,7 @@ module GraphQL
         def arguments_statically_coercible?
           return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
 
-          @arguments_statically_coercible = arguments.each_value.all?(&:statically_coercible?)
+          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
         end
 
         module ArgumentClassAccessor
@@ -254,11 +296,17 @@ module GraphQL
                       if authed
                         application_object
                       else
-                        raise GraphQL::UnauthorizedError.new(
+                        err = GraphQL::UnauthorizedError.new(
                           object: application_object,
                           type: class_based_type,
                           context: context,
                         )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
                       end
                     end
                   else

data/lib/graphql/schema/member/has_deprecation_reason.rb

@@ -7,7 +7,7 @@ module GraphQL
         # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
         def deprecation_reason
           dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
-          dir && dir.arguments[:reason]
+          dir && dir.arguments[:reason] # rubocop:disable Development/ContextIsPassedCop -- definition-related
         end
 
         # Set the deprecation reason for this member, or remove it by assigning `nil`

data/lib/graphql/schema/member/has_fields.rb

@@ -3,7 +3,7 @@
 module GraphQL
   class Schema
     class Member
-      # Shared code for Object and Interface
+      # Shared code for Objects, Interfaces, Mutations, Subscriptions
       module HasFields
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
@@ -15,28 +15,39 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-        def fields
+        def fields(context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          is_object = self.respond_to?(:kind) && self.kind.object?
           # Local overrides take precedence over inherited fields
-          all_fields = {}
-          ancestors.reverse_each do |ancestor|
-            if ancestor.respond_to?(:own_fields)
-              all_fields.merge!(ancestor.own_fields)
+          visible_fields = {}
+          for ancestor in ancestors
+            if ancestor.respond_to?(:own_fields) &&
+                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true)
+
+              ancestor.own_fields.each do |field_name, fields_entry|
+                # Choose the most local definition that passes `.visible?` --
+                # stop checking for fields by name once one has been found.
+                if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
+                  visible_fields[field_name] = f
+                end
+              end
             end
           end
-          all_fields
+          visible_fields
         end
 
-        def get_field(field_name)
-          if (f = own_fields[field_name])
-            f
-          else
-            for ancestor in ancestors
-              if ancestor.respond_to?(:own_fields) && f = ancestor.own_fields[field_name]
-                return f
-              end
+        def get_field(field_name, context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          is_object = self.respond_to?(:kind) && self.kind.object?
+          for ancestor in ancestors
+            if ancestor.respond_to?(:own_fields) &&
+                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true) &&
+                (f_entry = ancestor.own_fields[field_name]) &&
+                (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
+              return f
             end
-            nil
           end
+          nil
         end
 
         # A list of Ruby keywords.
@@ -64,7 +75,19 @@ module GraphQL
           if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
             warn(conflict_field_name_warning(field_defn))
           end
-          own_fields[field_defn.name] = field_defn
+          prev_defn = own_fields[field_defn.name]
+
+          case prev_defn
+          when nil
+            own_fields[field_defn.name] = field_defn
+          when Array
+            prev_defn << field_defn
+          when GraphQL::Schema::Field
+            own_fields[field_defn.name] = [prev_defn, field_defn]
+          else
+            raise "Invariant: unexpected previous field definition for #{field_defn.name.inspect}: #{prev_defn.inspect}"
+          end
+
           nil
         end
 
@@ -87,13 +110,48 @@ module GraphQL
           end
         end
 
-        # @return [Array<GraphQL::Schema::Field>] Fields defined on this class _specifically_, not parent classes
+        # @return [Hash<String => GraphQL::Schema::Field, Array<GraphQL::Schema::Field>>] Fields defined on this class _specifically_, not parent classes
         def own_fields
           @own_fields ||= {}
         end
 
+        def all_field_definitions
+          all_fields = {}
+          ancestors.reverse_each do |ancestor|
+            if ancestor.respond_to?(:own_fields)
+              all_fields.merge!(ancestor.own_fields)
+            end
+          end
+          all_fields = all_fields.values
+          all_fields.flatten!
+          all_fields
+        end
+
         private
 
+        # If `type` is an interface, and `self` has a type membership for `type`, then make sure it's visible.
+        def visible_interface_implementation?(type, context, warden)
+          if type.respond_to?(:kind) && type.kind.interface?
+            implements_this_interface = false
+            implementation_is_visible = false
+            interface_type_memberships.each do |tm|
+              if tm.abstract_type == type
+                implements_this_interface ||= true
+                if warden.visible_type_membership?(tm, context)
+                  implementation_is_visible = true
+                  break
+                end
+              end
+            end
+            # It's possible this interface came by way of `include` in another interface which this
+            # object type _does_ implement, and that's ok
+            implements_this_interface ? implementation_is_visible : true
+          else
+            # If there's no implementation, then we're looking at Ruby-style inheritance instead
+            true
+          end
+        end
+
         # @param [GraphQL::Schema::Field]
         # @return [String] A warning to give when this field definition might conflict with a built-in method
         def conflict_field_name_warning(field_defn)

data/lib/graphql/schema/member/has_interfaces.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasInterfaces
+        def implements(*new_interfaces, **options)
+          new_memberships = []
+          new_interfaces.each do |int|
+            if int.is_a?(Module)
+              unless int.include?(GraphQL::Schema::Interface)
+                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+              end
+
+              new_memberships << int.type_membership_class.new(int, self, **options)
+
+              # Include the methods here,
+              # `.fields` will use the inheritance chain
+              # to find inherited fields
+              include(int)
+
+              # If this interface has interfaces of its own, add those, too
+              int.interfaces.each do |next_interface|
+                implements(next_interface)
+              end
+            elsif int.is_a?(GraphQL::InterfaceType)
+              new_memberships << int.type_membership_class.new(int, self, **options)
+            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
+              if options.any?
+                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
+              end
+              new_memberships << int
+            else
+              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
+            end
+          end
+
+          # Remove any String or late-bound interfaces which are being replaced
+          own_interface_type_memberships.reject! { |old_i_m|
+            if !(old_i_m.respond_to?(:abstract_type) && old_i_m.abstract_type.is_a?(Module))
+              old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
+              old_name = Schema::Member::BuildType.to_type_name(old_int_type)
+
+              new_memberships.any? { |new_i_m|
+                new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
+                new_name = Schema::Member::BuildType.to_type_name(new_int_type)
+
+                new_name == old_name
+              }
+            end
+          }
+          own_interface_type_memberships.concat(new_memberships)
+        end
+
+        def own_interface_type_memberships
+          @own_interface_type_memberships ||= []
+        end
+
+        def interface_type_memberships
+          own_interface_type_memberships + ((self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships)) ? superclass.interface_type_memberships : [])
+        end
+
+        # param context [Query::Context] If omitted, skip filtering.
+        def interfaces(context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          visible_interfaces = []
+          own_interface_type_memberships.each do |type_membership|
+            # During initialization, `type_memberships` can hold late-bound types
+            case type_membership
+            when String, Schema::LateBoundType
+              visible_interfaces << type_membership
+            when Schema::TypeMembership
+              if warden.visible_type_membership?(type_membership, context)
+                visible_interfaces << type_membership.abstract_type
+              end
+            else
+              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
+            end
+          end
+
+          if self.is_a?(Class) && superclass <= GraphQL::Schema::Object
+            visible_interfaces.concat(superclass.interfaces(context))
+          end
+
+          visible_interfaces
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -6,6 +6,7 @@ require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_directives'
 require 'graphql/schema/member/has_deprecation_reason'
+require 'graphql/schema/member/has_interfaces'
 require 'graphql/schema/member/has_path'
 require 'graphql/schema/member/has_unresolved_type_error'
 require 'graphql/schema/member/has_validators'

data/lib/graphql/schema/object.rb

@@ -7,6 +7,7 @@ module GraphQL
     class Object < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::HasInterfaces
 
       # @return [Object] the application object this type is wrapping
       attr_reader :object
@@ -103,84 +104,16 @@ module GraphQL
           super
         end
 
-        def implements(*new_interfaces, **options)
-          new_memberships = []
-          new_interfaces.each do |int|
-            if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
-              end
-
-              new_memberships << int.type_membership_class.new(int, self, **options)
-
-              # Include the methods here,
-              # `.fields` will use the inheritance chain
-              # to find inherited fields
-              include(int)
-            elsif int.is_a?(GraphQL::InterfaceType)
-              new_memberships << int.type_membership_class.new(int, self, **options)
-            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
-              if options.any?
-                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
-              end
-              new_memberships << int
-            else
-              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
-            end
-          end
-
-          # Remove any interfaces which are being replaced (late-bound types are updated in place this way)
-          own_interface_type_memberships.reject! { |old_i_m|
-            old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
-            old_name = Schema::Member::BuildType.to_type_name(old_int_type)
-
-            new_memberships.any? { |new_i_m|
-              new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
-              new_name = Schema::Member::BuildType.to_type_name(new_int_type)
-
-              new_name == old_name
-            }
-          }
-          own_interface_type_memberships.concat(new_memberships)
-        end
-
-        def own_interface_type_memberships
-          @own_interface_type_memberships ||= []
-        end
-
-        def interface_type_memberships
-          own_interface_type_memberships + (superclass.respond_to?(:interface_type_memberships) ? superclass.interface_type_memberships : [])
-        end
-
-        # param context [Query::Context] If omitted, skip filtering.
-        def interfaces(context = GraphQL::Query::NullContext)
-          visible_interfaces = []
-          unfiltered = context == GraphQL::Query::NullContext
-          own_interface_type_memberships.each do |type_membership|
-            # During initialization, `type_memberships` can hold late-bound types
-            case type_membership
-            when String, Schema::LateBoundType
-              visible_interfaces << type_membership
-            when Schema::TypeMembership
-              if unfiltered || type_membership.visible?(context)
-                visible_interfaces << type_membership.abstract_type
-              end
-            else
-              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
-            end
-          end
-          visible_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces(context) : [])
-        end
-
         # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
         # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
-        def fields
+        def fields(context = GraphQL::Query::NullContext)
           all_fields = super
+          # This adds fields from legacy-style interfaces only.
+          # Multi-fields are not supported here.
           interfaces.each do |int|
-            # Include legacy-style interfaces, too
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
-              int.fields.each do |name, legacy_field|
+              int.fields.each do |name, legacy_field| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
                 int_f[name] = field_class.from_options(name, field: legacy_field)
               end
               all_fields = int_f.merge(all_fields)
@@ -198,9 +131,9 @@ module GraphQL
           obj_type.introspection = introspection
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node
-          fields.each do |field_name, field_inst|
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
             field_defn = field_inst.to_graphql
-            obj_type.fields[field_defn.name] = field_defn
+            obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
 
           obj_type.metadata[:type_class] = self

data/lib/graphql/schema/printer.rb

@@ -56,7 +56,7 @@ module GraphQL
       def self.print_introspection_schema
         query_root = Class.new(GraphQL::Schema::Object) do
           graphql_name "Root"
-          field :throwaway_field, String, null: true
+          field :throwaway_field, String
         end
         schema = Class.new(GraphQL::Schema) { query(query_root) }
 

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -22,7 +22,7 @@ module GraphQL
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
       # The payload should always include this field
-      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", null: true)
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
       # Relay classic default:
       null(true)
 
@@ -81,6 +81,31 @@ module GraphQL
       end
 
       class << self
+
+        # Also apply this argument to the input type:
+        def argument(*args, **kwargs, &block)
+          it = input_type # make sure any inherited arguments are already added to it
+          arg = super
+
+          # 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
+          prev_args = it.own_arguments[arg.graphql_name]
+          case prev_args
+          when GraphQL::Schema::Argument
+            if prev_args.owner != self
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          when Array
+            prev_args.reject! { |a| a.owner != self }
+            if prev_args.empty?
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          end
+
+          it.add_argument(arg)
+          arg
+        end
+
         # The base class for generated input object types
         # @param new_class [Class] The base class to use for generating input object definitions
         # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
@@ -115,14 +140,15 @@ module GraphQL
         # To customize how input objects are generated, override this method
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
-          mutation_args = arguments
+          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}")
             mutation(mutation_class)
-            mutation_args.each do |_name, arg|
+            # these might be inherited:
+            mutation_args.each do |arg|
               add_argument(arg)
             end
             argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -38,6 +38,9 @@ module GraphQL
         # @return [Class]
         def object_class(new_class = nil)
           if new_class
+            if defined?(@payload_type)
+              raise "Can't configure `object_class(...)` after the payload type has already been initialized. Move this configuration higher up the class definition."
+            end
             @object_class = new_class
           else
             @object_class || find_inherited_value(:object_class, GraphQL::Schema::Object)
@@ -46,6 +49,28 @@ module GraphQL
 
         NO_INTERFACES = [].freeze
 
+        def field(*args, **kwargs, &block)
+          pt = payload_type # make sure it's initialized with any inherited fields
+          field_defn = super
+
+          # Remove any inherited fields to avoid false conflicts at runtime
+          prev_fields = pt.own_fields[field_defn.graphql_name]
+          case prev_fields
+          when GraphQL::Schema::Field
+            if prev_fields.owner != self
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          when Array
+            prev_fields.reject! { |f| f.owner != self }
+            if prev_fields.empty?
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          end
+
+          pt.add_field(field_defn, method_conflict_warning: false)
+          field_defn
+        end
+
         private
 
         # Build a subclass of {.object_class} based on `self`.
@@ -53,11 +78,11 @@ module GraphQL
         # Override this hook to customize return type generation.
         def generate_payload_type
           resolver_name = graphql_name
-          resolver_fields = fields
+          resolver_fields = all_field_definitions
           Class.new(object_class) do
             graphql_name("#{resolver_name}Payload")
             description("Autogenerated return type of #{resolver_name}")
-            resolver_fields.each do |name, f|
+            resolver_fields.each do |f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)
               # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.

data/lib/graphql/schema/resolver.rb

@@ -37,7 +37,7 @@ module GraphQL
         @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
-        self.class.arguments.each do |name, arg|
+        self.class.arguments(context).each do |name, arg|
           @arguments_by_keyword[arg.keyword] = arg
         end
         @prepared_arguments = nil
@@ -145,7 +145,7 @@ module GraphQL
       # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
       # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
       def authorized?(**inputs)
-        self.class.arguments.each_value do |argument|
+        self.class.arguments(context).each_value do |argument|
           arg_keyword = argument.keyword
           if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
             arg_auth, err = argument.authorized?(self, arg_value, context)
@@ -160,6 +160,16 @@ module GraphQL
         end
       end
 
+      # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
+      #
+      # By default, the error is re-raised and passed along to {{Schema.unauthorized_object}}.
+      #
+      # Any value returned here will be used _instead of_ of the loaded object.
+      # @param err [GraphQL::UnauthorizedError]
+      def unauthorized_object(err)
+        raise err
+      end
+
       private
 
       def load_arguments(args)
@@ -189,8 +199,8 @@ module GraphQL
         end
       end
 
-      def get_argument(name)
-        self.class.get_argument(name)
+      def get_argument(name, context = GraphQL::Query::NullContext)
+        self.class.get_argument(name, context)
       end
 
       class << self
@@ -295,13 +305,27 @@ module GraphQL
         end
 
         def field_options
+
+          all_args = {}
+          all_argument_definitions.each do |arg|
+            if (prev_entry = all_args[arg.graphql_name])
+              if prev_entry.is_a?(Array)
+                prev_entry << arg
+              else
+                all_args[arg.graphql_name] = [prev_entry, arg]
+              end
+            else
+              all_args[arg.graphql_name] = arg
+            end
+          end
+
           field_opts = {
             type: type_expr,
             description: description,
             extras: extras,
             resolver_method: :resolve_with_support,
             resolver_class: self,
-            arguments: arguments,
+            arguments: all_args,
             null: null,
             complexity: complexity,
             broadcastable: broadcastable?,