graphql 2.0.0 → 2.0.3

data/lib/graphql/schema/argument.rb

@@ -75,7 +75,10 @@ module GraphQL
           end
         end
 
-        self.validates(validates)
+        if validates && !validates.empty?
+          self.validates(validates)
+        end
+
         if required == :nullable
           self.owner.validates(required: { argument: arg_name })
         end
@@ -247,24 +250,30 @@ module GraphQL
         end
 
         loaded_value = nil
-        coerced_value = context.schema.error_handler.with_error_handling(context) do
+        coerced_value = begin
           type.coerce_input(value, context)
+        rescue StandardError => err
+          context.schema.handle_or_reraise(context, err)
         end
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
         # If it _is_ lazy, then we write the lazy to the hash, then update it later
         argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
           if loads && !from_resolver?
-            loaded_value = context.query.with_error_handling do
+            loaded_value = begin
               load_and_authorize_value(owner, coerced_value, context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
           end
 
           maybe_loaded_value = loaded_value || resolved_coerced_value
           context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
             owner.validate_directive_argument(self, resolved_loaded_value)
-            prepared_value = context.schema.error_handler.with_error_handling(context) do
+            prepared_value = begin
               prepare_value(parent_object, resolved_loaded_value, context: context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
 
             # TODO code smell to access such a deeply-nested constant in a distant module

data/lib/graphql/schema/enum.rb

@@ -123,16 +123,14 @@ module GraphQL
         end
 
         def validate_non_null_input(value_name, ctx)
-          result = GraphQL::Query::InputValidationResult.new
-
           allowed_values = ctx.warden.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 
           if matching_value.nil?
-            result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
+            GraphQL::Query::InputValidationResult.from_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
+          else
+            nil
           end
-
-          result
         end
 
         def coerce_result(value, ctx)

data/lib/graphql/schema/field.rb

@@ -29,7 +29,13 @@ module GraphQL
       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 @@ module GraphQL
       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 @@ module GraphQL
       # @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
@@ -101,8 +108,8 @@ module GraphQL
 
             kwargs[:description] = desc
             kwargs[:type] = type
-          elsif (kwargs[:field] || kwargs[:function] || resolver || mutation) && type.is_a?(String)
-            # The return type should be copied from `field` or `function`, and the second positional argument is the description
+          elsif (resolver || mutation) && type.is_a?(String)
+            # The return type should be copied from the resolver, and the second positional argument is the description
             kwargs[:description] = type
           else
             kwargs[:type] = type
@@ -119,8 +126,8 @@ module GraphQL
       def connection?
         if @connection.nil?
           # Provide default based on type name
-          return_type_name = if (contains_type = @field || @function)
-            Member::BuildType.to_type_name(contains_type.type)
+          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
@@ -138,8 +145,18 @@ module GraphQL
         if !@scope.nil?
           # The default was overridden
           @scope
+        elsif @return_type_expr
+          # Detect a list return type, but don't call `type` since that may eager-load an otherwise lazy-loaded type
+          @return_type_expr.is_a?(Array) ||
+            (@return_type_expr.is_a?(String) && @return_type_expr.include?("[")) ||
+            connection?
+        elsif @resolver_class
+          resolver_type = @resolver_class.type_expr
+          resolver_type.is_a?(Array) ||
+            (resolver_type.is_a?(String) && resolver_type.include?("[")) ||
+            connection?
         else
-          @return_type_expr && (@return_type_expr.is_a?(Array) || (@return_type_expr.is_a?(String) && @return_type_expr.include?("[")) || connection?)
+          false
         end
       end
 
@@ -181,9 +198,6 @@ module GraphQL
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
       # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
-      # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
-      # @param field [GraphQL::Field, GraphQL::Schema::Field] **deprecated** for compatibility with <1.8.0
-      # @param function [GraphQL::Function] **deprecated** for compatibility with <1.8.0
       # @param resolver_class [Class] (Private) A {Schema::Resolver} which this field was derived from. Use `resolver:` to create a field with a resolver.
       # @param arguments [{String=>GraphQL::Schema::Argument, Hash}] Arguments for this field (may be added in the block, also)
       # @param camelize [Boolean] If true, the field name will be camelized when building the schema
@@ -197,30 +211,22 @@ module GraphQL
       # @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, 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, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, description: :not_given, 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
-        if !(field || function || resolver_class)
+        if !(resolver_class)
           if type.nil?
             raise ArgumentError, "missing second `type` argument or keyword `type:`"
           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
-        if field.is_a?(GraphQL::Schema::Field)
-          raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
-        else
-          @field = field
+        if description != :not_given
+          @description = description
         end
-        @function = function
-        @resolve = resolve
         self.deprecation_reason = deprecation_reason
 
         if method && hash_key && dig
@@ -253,7 +259,9 @@ module GraphQL
         @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
@@ -297,13 +305,19 @@ module GraphQL
           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)
           end
         end
 
-        self.validates(validates)
+        if !validates.empty?
+          self.validates(validates)
+        end
 
         if definition_block
           if definition_block.arity == 1
@@ -321,7 +335,13 @@ module GraphQL
       # @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]
@@ -329,8 +349,12 @@ module GraphQL
       def description(text = nil)
         if text
           @description = text
-        else
+        elsif defined?(@description)
           @description
+        elsif @resolver_class
+          @description || @resolver_class.description
+        else
+          nil
         end
       end
 
@@ -394,7 +418,12 @@ module GraphQL
       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
@@ -477,7 +506,11 @@ module GraphQL
         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
@@ -485,29 +518,31 @@ module GraphQL
 
       # @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 @function
-          Member::BuildType.parse_type(@function.type, null: false)
-        elsif @field
-          Member::BuildType.parse_type(@field.type, null: false)
-        elsif @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}`, consider configuration a `type ...` for that class)"
+        if @return_type_expr.nil?
+          if @resolver_class && (t = @resolver_class.type)
+            t
+          else
+            # 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
           end
-          raise MissingReturnTypeError, message
         else
-          Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
         end
       rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up
@@ -578,31 +613,94 @@ module GraphQL
       # @param object [GraphQL::Schema::Object] An instance of some type class, wrapping an application object
       # @param args [Hash] A symbol-keyed hash of Ruby keyword arguments. (Empty if no args)
       # @param ctx [GraphQL::Query::Context]
-      def resolve(object, args, ctx)
-        if @resolve_proc
-          raise "Can't run resolve proc for #{path} when using GraphQL::Execution::Interpreter"
-        end
-        begin
-          # Unwrap the GraphQL object to get the application object.
-          application_object = object.object
+      def resolve(object, args, query_ctx)
+        # Unwrap the GraphQL object to get the application object.
+        application_object = object.object
+        method_receiver = nil
+        method_to_call = nil
+        method_args = nil
+
+        Schema::Validator.validate!(validators, application_object, query_ctx, args)
+
+        query_ctx.schema.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
+          if is_authorized
+            with_extensions(object, args, query_ctx) do |obj, ruby_kwargs|
+              method_args = 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)
+                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 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
+                raise <<-ERR
+              Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
-          Schema::Validator.validate!(validators, application_object, ctx, args)
+              - `#{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
 
-          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
-            if is_authorized
-              public_send_field(object, args, ctx)
-            else
-              raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              To implement this field, define one of the methods above (and check for typos)
+              ERR
+              end
             end
+          else
+            raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: query_ctx, field: self)
           end
-        rescue GraphQL::UnauthorizedFieldError => err
-          err.field ||= self
-          ctx.schema.unauthorized_field(err)
-        rescue GraphQL::UnauthorizedError => err
-          ctx.schema.unauthorized_object(err)
-        end
-      rescue GraphQL::ExecutionError => err
-        err
+        end
+      rescue GraphQL::UnauthorizedFieldError => err
+        err.field ||= self
+        begin
+          query_ctx.schema.unauthorized_field(err)
+        rescue GraphQL::ExecutionError => err
+          err
+        end
+      rescue GraphQL::UnauthorizedError => err
+        begin
+          query_ctx.schema.unauthorized_object(err)
+        rescue GraphQL::ExecutionError => err
+          err
+        end
+      rescue ArgumentError
+        if method_receiver && method_to_call
+          assert_satisfactory_implementation(method_receiver, method_to_call, method_args)
+        end
+        # if the line above doesn't raise, re-raise
+        raise
       end
 
       # @param ctx [GraphQL::Query::Context]
@@ -618,70 +716,6 @@ module GraphQL
 
       private
 
-      def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
-        with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
-          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
-
-            # 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)
-              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 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
-              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
-          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

data/lib/graphql/schema/input_object.rb

@@ -127,19 +127,15 @@ module GraphQL
         INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
 
         def validate_non_null_input(input, ctx)
-          result = GraphQL::Query::InputValidationResult.new
-
           warden = ctx.warden
 
           if input.is_a?(Array)
-            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-            return result
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
           if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
             # We're not sure it'll act like a hash, so reject it:
-            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-            return result
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
           # Inject missing required arguments
@@ -151,18 +147,22 @@ module GraphQL
             m
           end
 
-
+          result = nil
           [input, missing_required_inputs].each do |args_to_validate|
             args_to_validate.each do |argument_name, value|
               argument = warden.get_argument(self, argument_name)
               # Items in the input that are unexpected
-              unless argument
+              if argument.nil?
+                result ||= Query::InputValidationResult.new
                 result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-                next
+              else
+                # Items in the input that are expected, but have invalid values
+                argument_result = argument.type.validate_input(value, ctx)
+                result ||= Query::InputValidationResult.new
+                if !argument_result.valid?
+                  result.merge_result!(argument_name, argument_result)
+                end
               end
-              # Items in the input that are expected, but have invalid values
-              argument_result = argument.type.validate_input(value, ctx)
-              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
             end
           end
 

data/lib/graphql/schema/list.rb

@@ -46,10 +46,11 @@ module GraphQL
       end
 
       def validate_non_null_input(value, ctx)
-        result = GraphQL::Query::InputValidationResult.new
+        result = nil
         ensure_array(value).each_with_index do |item, index|
           item_result = of_type.validate_input(item, ctx)
           if !item_result.valid?
+            result ||= GraphQL::Query::InputValidationResult.new
             result.merge_result!(index, item_result)
           end
         end

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

@@ -78,23 +78,44 @@ module GraphQL
         # @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 @@ module GraphQL
                 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 @@ module GraphQL
         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) &&

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

@@ -11,7 +11,7 @@ module GraphQL
         # @return [void]
         def directive(dir_class, **options)
           @own_directives ||= []
-          remove_directive(dir_class)
+          remove_directive(dir_class) unless dir_class.repeatable?
           @own_directives << dir_class.new(self, **options)
           nil
         end

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

@@ -80,7 +80,7 @@ module GraphQL
             visible_interfaces.concat(superclass.interfaces(context))
           end
 
-          visible_interfaces
+          visible_interfaces.uniq
         end
       end
     end