rubocop-graphql 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a19f13dab5d269042eab2a3dfb06746f70d78ebd512e4656cb384d1e2f0a77c
-  data.tar.gz: e67b156307473082e114b860097ca80d1ba23c9987359ad6ee6c56d7641552d3
+  metadata.gz: 8ff189b7091fa3e71688dcb2a2ef36b15edbe018796943ef3b3dfee85b1c32f8
+  data.tar.gz: 2d2ffa4470e74e3ae9d90fac4fc85a173db7d95eb2d5a6bfd844759fad59c514
 SHA512:
-  metadata.gz: 412c2b4547281975d17d77cbff5a40e737d49a597747bdd85ccba722dfac63c35f30e33027bb252c3ad6939d43348609ac291baeb37f7f4c2f187e4e427635f6
-  data.tar.gz: '080b77b04d717024d92a79ec83635b1f43e56412240a6a4d6068bec5060a65c5365438158742d579c1fe9d4fd77636ddd19d02055b0003a9d6083c6da15d5d59'
+  metadata.gz: 1651ab77310a0146fe7847161a6a18afa0c5d83148eca7701def628f66d31b24cfa4760fe94843d9c10db45ca43aa7b7c0d0539901c71be89bf5b3299242caca
+  data.tar.gz: 8b2d079c283776eaac5fdd151fc589d9f29e7afe7826657f23f577a98882166f1a31c57727a1f8dca90a49c058b9def85d3026be5fa483b11227fc81006be50f

data/README.md

@@ -2,7 +2,10 @@
 
 [Rubocop](https://github.com/rubocop-hq/rubocop) extension for enforcing [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) best practices.
 
-You can support my open–source work [here](https://boosty.to/dmitry_tsepelev).
+## Professional Support
+
+Need help with your GraphQL API architecture, schema design, or performance?
+I'm available for consulting — [get in touch](https://dmitrytsepelev.dev/consulting).
 
 ## Installation
 

data/config/default.yml

@@ -117,6 +117,11 @@ GraphQL/MaxDepthSchema:
   Include:
     - '**/graphql/**/*_schema.rb'
 
+GraphQL/MethodShadowedByResolverMethod:
+  Enabled: true
+  VersionAdded: '<<next>>'
+  Description: 'Checks for method definitions shadowed by the field''s effective resolver_method'
+
 GraphQL/MultipleFieldDefinitions:
   Enabled: true
   VersionAdded: '0.15.0'
@@ -182,3 +187,8 @@ GraphQL/UnnecessaryFieldCamelize:
   Enabled: true
   VersionAdded: '0.18.0'
   Description: "Camelize isn't necessary if the field name doesn't contain underscores"
+
+GraphQL/UselessMethodOption:
+  Enabled: true
+  VersionAdded: '<<next>>'
+  Description: 'Checks for resolver_method:/method: made ineffective by resolver:, or method: shadowed by a same-named def'

data/lib/rubocop/cop/graphql/method_shadowed_by_resolver_method.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop detects method definitions that are never called because
+      #  the field's effective `resolver_method` points somewhere else.
+      #
+      #  graphql-ruby only ever calls a single method on the type instance:
+      #  the field's `resolver_method` (which is the resolver class's own
+      #  method when `resolver:` is set, the explicit `resolver_method:`
+      #  value when given, or the field name otherwise). Any other
+      #  same-named method left on the type is unreachable:
+      #
+      #  - When `resolver:` is set, the resolver class handles resolution
+      #    entirely, so neither the field name, `resolver_method:`, nor
+      #    `method:` (if also given) is ever dispatched to a method on the type.
+      #  - When only `resolver_method:` is set, that name is the one
+      #    actually called -- a leftover method matching the plain field
+      #    name is never reached.
+      #
+      # @example
+      #   # good
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, resolver: Resolvers::AuthorResolver
+      #   end
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, String, null: true, resolver_method: :fetch_author
+      #
+      #     def fetch_author
+      #       object.author
+      #     end
+      #   end
+      #
+      #   # bad
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, resolver: Resolvers::AuthorResolver
+      #
+      #     def author
+      #       object.author
+      #     end
+      #   end
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, String, null: true, resolver_method: :fetch_author
+      #
+      #     def author
+      #       object.author
+      #     end
+      #
+      #     def fetch_author
+      #       object.author
+      #     end
+      #   end
+      #
+      class MethodShadowedByResolverMethod < Base
+        include RuboCop::GraphQL::NodePattern
+
+        RESOLVER_MSG = "Remove this method, it is never called: `resolver: %<resolver>s` " \
+                       "resolves this field instead."
+        RESOLVER_METHOD_MSG = "Remove this method, it is never called: " \
+                              "`resolver_method: :%<resolver_method>s` is called instead."
+        RESTRICT_ON_SEND = %i[field].freeze
+
+        def on_send(node)
+          return unless field_definition?(node)
+
+          field = RuboCop::GraphQL::Field.new(node)
+
+          if field.kwargs.resolver
+            register_resolver_offenses(field)
+          else
+            register_resolver_method_offense(field)
+          end
+        end
+
+        private
+
+        # Neither `resolver_method:` nor `method:` has any effect once `resolver:` is
+        # set (graphql-ruby always calls the resolver class's own resolver_method), so
+        # a method matching the field's own name, an explicit `resolver_method:`, or
+        # an explicit `method:` is equally unreachable.
+        def register_resolver_offenses(field)
+          resolver_source = field.kwargs.resolver.value.source
+          message = format(RESOLVER_MSG, resolver: resolver_source)
+
+          candidate_names = [
+            field.name, field.kwargs.resolver_method_name, method_kwarg_name(field)
+          ].compact.uniq
+          candidate_names.each do |method_name|
+            shadowed_method = field.schema_member.find_method_definition(method_name)
+            add_offense(shadowed_method.loc.name, message: message) if shadowed_method
+          end
+        end
+
+        # The `resolver_method:`-named method is the one actually called; only a
+        # leftover method matching the plain field name is dead.
+        def register_resolver_method_offense(field)
+          resolver_method_kwarg = field.kwargs.resolver_method_name
+          return unless resolver_method_kwarg && resolver_method_kwarg != field.name
+
+          shadowed_method = field.schema_member.find_method_definition(field.name)
+          return unless shadowed_method
+
+          message = format(RESOLVER_METHOD_MSG, resolver_method: resolver_method_kwarg)
+          add_offense(shadowed_method.loc.name, message: message)
+        end
+
+        def method_kwarg_name(field)
+          pair = field.kwargs.method
+          return nil unless pair
+
+          value_node = pair.value
+          value_node.value if value_node.sym_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/graphql/ordered_fields.rb

@@ -50,7 +50,26 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          field_declarations(node).each_cons(2) do |previous, current|
+          check_field_ordering(direct_field_declarations(node))
+        end
+
+        alias on_module on_class
+
+        def on_block(node)
+          return if node.method?(:field)
+          return unless node.each_ancestor(:class, :module).any?
+
+          fields = field_declarations(node).select { |f| f.each_ancestor(:block).first == node }
+          check_field_ordering(fields)
+        end
+
+        alias on_itblock on_block
+        alias on_numblock on_block
+
+        private
+
+        def check_field_ordering(fields)
+          fields.each_cons(2) do |previous, current|
             next unless consecutive_fields(previous, current)
             next if correct_order?(field_name(previous), field_name(current))
 
@@ -58,9 +77,19 @@ module RuboCop
           end
         end
 
-        alias on_module on_class
+        def direct_field_declarations(node)
+          field_declarations(node).select { |field| direct_child_field?(field, node) }
+        end
 
-        private
+        def direct_child_field?(field_node, class_node)
+          return false unless field_node.each_ancestor(:class, :module).first == class_node
+
+          field_node.each_ancestor(:block).none? do |block_ancestor|
+            next false if block_ancestor.each_ancestor(:class, :module).first != class_node
+
+            !block_ancestor.method?(:field)
+          end
+        end
 
         def consecutive_fields(previous, current)
           return true if cop_config["Groups"] == false

data/lib/rubocop/cop/graphql/useless_method_option.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop detects `resolver_method:` or `method:` options that have no
+      #  effect, either because:
+      #
+      #  - the same field also sets `resolver:` -- graphql-ruby always calls
+      #    the resolver class's own resolver_method once `resolver:` is set,
+      #    silently ignoring both `resolver_method:` and `method:` regardless
+      #    of whether a method by either name exists; or
+      #  - a method matching the field's own plain name is also defined on the
+      #    type -- that method is checked (and wins) before `method:` is ever
+      #    considered, since `method:` is only consulted as a fallback when no
+      #    such method exists. This only applies to `method:`: `resolver_method:`
+      #    redirects which name is checked instead of competing with it, so it
+      #    can't be shadowed by a same-named `def` the way `method:` can.
+      #
+      # @example
+      #   # good
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, resolver: Resolvers::AuthorResolver
+      #   end
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, String, null: true, method: :ghostwriter
+      #   end
+      #
+      #   # bad
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, resolver: Resolvers::AuthorResolver, resolver_method: :fetch_author
+      #   end
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, resolver: Resolvers::AuthorResolver, method: :ghostwriter
+      #   end
+      #
+      #   class Types::PostType < Types::BaseObject
+      #     field :author, String, null: true, method: :ghostwriter
+      #
+      #     def author
+      #       object.author
+      #     end
+      #   end
+      #
+      class UselessMethodOption < Base
+        include RuboCop::GraphQL::NodePattern
+
+        RESOLVER_MSG = "Remove `%<option>s:`, it has no effect: `resolver: %<resolver>s` " \
+                       "always takes precedence."
+        DEF_MSG = "Remove `method:`, it has no effect: `def %<field_name>s` on the type " \
+                  "always takes precedence."
+        RESTRICT_ON_SEND = %i[field].freeze
+
+        # @!method resolver_method_pair(node)
+        def_node_search :resolver_method_pair, "(pair (sym :resolver_method) ...)"
+
+        # @!method method_pair(node)
+        def_node_search :method_pair, "(pair (sym :method) ...)"
+
+        def on_send(node)
+          return unless field_definition?(node)
+
+          field = RuboCop::GraphQL::Field.new(node)
+
+          if field.kwargs.resolver
+            register_resolver_offenses(node, field)
+          else
+            register_method_shadowed_by_def_offense(node, field)
+          end
+        end
+
+        private
+
+        def register_resolver_offenses(node, field)
+          resolver_source = field.kwargs.resolver.value.source
+
+          [resolver_method_pair(node).first, method_pair(node).first].compact.each do |pair|
+            message = format(RESOLVER_MSG, option: pair.key.value, resolver: resolver_source)
+            add_offense(pair, message: message)
+          end
+        end
+
+        def register_method_shadowed_by_def_offense(node, field)
+          pair = method_pair(node).first
+          return unless pair
+
+          shadowed_def = field.schema_member.find_method_definition(field.name)
+          return unless shadowed_def
+
+          message = format(DEF_MSG, field_name: field.name)
+          add_offense(pair, message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/graphql_cops.rb

@@ -16,6 +16,7 @@ require_relative "graphql/graphql_name"
 require_relative "graphql/legacy_dsl"
 require_relative "graphql/max_complexity_schema"
 require_relative "graphql/max_depth_schema"
+require_relative "graphql/method_shadowed_by_resolver_method"
 require_relative "graphql/multiple_field_definitions"
 require_relative "graphql/not_authorized_node_type"
 require_relative "graphql/resolver_method_length"
@@ -27,3 +28,4 @@ require_relative "graphql/unused_argument"
 require_relative "graphql/unnecessary_argument_camelize"
 require_relative "graphql/unnecessary_field_alias"
 require_relative "graphql/unnecessary_field_camelize"
+require_relative "graphql/useless_method_option"

data/lib/rubocop/graphql/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module GraphQL
-    VERSION = "1.6.0".freeze
+    VERSION = "1.7.0".freeze
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-graphql
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Dmitry Tsepelev
 bindir: bin
 cert_chain: []
-date: 2026-02-14 00:00:00.000000000 Z
+date: 2026-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,7 @@ files:
 - lib/rubocop/cop/graphql/legacy_dsl.rb
 - lib/rubocop/cop/graphql/max_complexity_schema.rb
 - lib/rubocop/cop/graphql/max_depth_schema.rb
+- lib/rubocop/cop/graphql/method_shadowed_by_resolver_method.rb
 - lib/rubocop/cop/graphql/multiple_field_definitions.rb
 - lib/rubocop/cop/graphql/not_authorized_node_type.rb
 - lib/rubocop/cop/graphql/object_description.rb
@@ -124,6 +125,7 @@ files:
 - lib/rubocop/cop/graphql/unnecessary_field_alias.rb
 - lib/rubocop/cop/graphql/unnecessary_field_camelize.rb
 - lib/rubocop/cop/graphql/unused_argument.rb
+- lib/rubocop/cop/graphql/useless_method_option.rb
 - lib/rubocop/cop/graphql_cops.rb
 - lib/rubocop/graphql.rb
 - lib/rubocop/graphql/argument.rb