rubocop-graphql 0.19.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80b3609f1de18b1e5db7198fdf29f7deed28cfe0e505c9485203dd38172ff4f9
-  data.tar.gz: 0d894dad1bc37192b76372d235d10fab4181e171574f471091e9bad0033212d2
+  metadata.gz: 1307db3b7122e5a576ca03bbaecbb5798b03a927718aa85fa25fd5a9afe1ec07
+  data.tar.gz: ea58763eb067a3e576149ebe41830a7ca7210e080e61382011fab9707ceaf2b9
 SHA512:
-  metadata.gz: 3c2b2d1bcbae2e53e28567c0f13397f77427cc0b9d87a96171cd27fec5d33649568366a623c6ea7c6960f452709d02081c04e3dae1368b465da4fad304ae9ce5
-  data.tar.gz: b6b5588432b38eaa545bff20b2f52d966859ba1fac6fcad5004f22405fd4d1dab56c04238124f99f3ff1df860b385773e539981221b94d0e8c4c27266d4a7c9e
+  metadata.gz: 86d2c4c34918bb8713b15c4485b681d62b8b8c74b894aefbfb4d12e1d364ef2eff48c6c5562ca5b10690195b8f8403dacac73552b0cdfa2960f64fde07b63e3c
+  data.tar.gz: 784d752ff412289d3eeeabdd204939bef5ad946e6cd5f40c8cc2ccfd1ebe4b7ec657f8ebe44c3d14fc7d8b50508891bc9b945f732b1b25c1a9dff6d6751ce87f

data/config/default.yml

@@ -8,123 +8,168 @@ GraphQL:
 
 GraphQL/ArgumentDescription:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.2.0'
   Description: 'Ensures all arguments have a description'
 
 GraphQL/ArgumentName:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.2.0'
   Description: 'This cop checks whether argument names are snake_case'
 
 GraphQL/ArgumentUniqueness:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.11.0'
   Description: 'This cop enforces arguments to be defined once per block'
 
-GraphQL/ResolverMethodLength:
+GraphQL/ExtractInputType:
   Enabled: true
-  VersionAdded: '0.80'
-  Description: 'Checks resolver methods are not too long'
-  Max: 10
-  CountComments: false
-  ExcludedMethods: []
+  VersionAdded: '0.2.0'
+  Description: 'Suggests using input type instead of many arguments'
+  MaxArguments: 2
+  Include:
+    - '**/graphql/mutations/**/*.rb'
+
+GraphQL/ExtractType:
+  Enabled: true
+  VersionAdded: '0.2.0'
+  Description: 'Suggests extracting fields with common prefixes to the separate type'
+  MaxFields: 2
+  Prefixes:
+    - is
+    - has
+    - with
+    - avg
+    - min
+    - max
 
 GraphQL/FieldDefinitions:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.1.0'
   Description: 'Checks consistency of field definitions'
   EnforcedStyle: group_definitions
   SupportedStyles:
     - group_definitions
     - define_resolver_after_definition
 
-GraphQL/MultipleFieldDefinitions:
-  Enabled: true
-  Description: 'Ensures that fields with multiple definitions are grouped together'
-
 GraphQL/FieldDescription:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.1.0'
   Description: 'Ensures all fields have a description'
 
 GraphQL/FieldHashKey:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.4.0'
   Description: 'Checks :hash_key option is used for appropriate fields'
 
 GraphQL/FieldMethod:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.2.0'
   Description: 'Checks :method option is used for appropriate fields'
 
 GraphQL/FieldName:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.2.0'
   Description: 'This cop checks whether field names are snake_case'
   SafeAutoCorrect: false
 
 GraphQL/FieldUniqueness:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.11.0'
   Description: 'This cop enforces fields to be defined once'
 
-GraphQL/ExtractInputType:
+GraphQL/GraphqlName:
   Enabled: true
-  VersionAdded: '0.80'
-  Description: 'Suggests using input type instead of many arguments'
-  MaxArguments: 2
+  VersionAdded: '1.0.0'
+  Description: 'This cop check proper configuration of graphql_name'
   Include:
-    - '**/graphql/mutations/**/*.rb'
-
-GraphQL/ExtractType:
-  Enabled: true
-  VersionAdded: '0.80'
-  Description: 'Suggests extracting fields with common prefixes to the separate type'
-  MaxFields: 2
-  Prefixes:
-    - is
-    - has
-    - with
-    - avg
-    - min
-    - max
+    - "**/graphql/types/**/*"
+    - "**/graphql/mutations/**/*"
+  EnforcedStyle: only_override
+  SupportedStyles:
+    - required
+    - only_override
 
 GraphQL/LegacyDsl:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.9.0'
   Description: 'Checks that types are defined with class-based API'
 
+GraphQL/MaxComplexitySchema:
+  Enabled: true
+  VersionAdded: '1.0.0'
+  Description: 'Enforces max_complexity configuration in schema'
+  Include:
+    - '**/graphql/**/*_schema.rb'
+
+GraphQL/MaxDepthSchema:
+  Enabled: true
+  VersionAdded: '1.0.0'
+  Description: 'Enforces max_depth configuration in schema'
+  Include:
+    - '**/graphql/**/*_schema.rb'
+
+GraphQL/MultipleFieldDefinitions:
+  Enabled: true
+  VersionAdded: '0.15.0'
+  Description: 'Ensures that fields with multiple definitions are grouped together'
+
+GraphQL/NotAuthorizedNodeType:
+  Enabled: true
+  VersionAdded: '1.0.0'
+  Description: 'Detects types that implement Node interface and not have `.authorized?` check'
+  Include:
+    - '**/graphql/types/**/*'
+  SafeBaseClasses: []
+
+GraphQL/ResolverMethodLength:
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Description: 'Checks resolver methods are not too long'
+  Max: 10
+  CountComments: false
+  ExcludedMethods: []
+  CountAsOne: []
+
 GraphQL/ObjectDescription:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.3.0'
   Description: 'Ensures all types have a description'
   Exclude:
+    - "spec/**/*"
+    - "test/**/*"
     - '**/*_schema.rb'
     - '**/base_*.rb'
     - '**/graphql/query_context.rb'
 
 GraphQL/OrderedArguments:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.7.0'
   Description: 'Arguments should be alphabetically sorted within groups'
+  Order: null
 
 GraphQL/OrderedFields:
   Enabled: true
-  VersionAdded: '0.80'
+  VersionAdded: '0.5.0'
   Description: 'Fields should be alphabetically sorted within groups'
+  Groups: true
+  Order: null
 
 GraphQL/UnusedArgument:
   Enabled: true
+  VersionAdded: '0.12.0'
   Description: 'Arguments should either be listed explicitly or **rest should be in the resolve signature'
 
 GraphQL/UnnecessaryFieldAlias:
   Enabled: true
+  VersionAdded: '0.18.0'
   Description: 'Field aliases should be different than their field names'
 
 GraphQL/UnnecessaryArgumentCamelize:
   Enabled: true
+  VersionAdded: '0.18.0'
   Description: "Camelize isn't necessary if the argument name doesn't contain underscores"
 
 GraphQL/UnnecessaryFieldCamelize:
   Enabled: true
+  VersionAdded: '0.18.0'
   Description: "Camelize isn't necessary if the field name doesn't contain underscores"

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

@@ -22,6 +22,7 @@ module RuboCop
         include RuboCop::GraphQL::NodePattern
 
         MSG = "Missing argument description"
+        RESTRICT_ON_SEND = %i[argument].freeze
 
         def on_send(node)
           return unless argument?(node)

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

@@ -20,6 +20,7 @@ module RuboCop
       #
       class ArgumentName < Base
         include RuboCop::GraphQL::NodePattern
+        RESTRICT_ON_SEND = %i[argument].freeze
 
         using RuboCop::GraphQL::Ext::SnakeCase
 

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

@@ -52,6 +52,8 @@ module RuboCop
         include RuboCop::GraphQL::Sorbet
         include RuboCop::GraphQL::Heredoc
 
+        RESTRICT_ON_SEND = %i[field].freeze
+
         # @!method field_kwargs(node)
         def_node_matcher :field_kwargs, <<~PATTERN
           (send nil? :field
@@ -80,6 +82,16 @@ module RuboCop
           end
         end
 
+        def on_module(node)
+          return if style != :group_definitions
+
+          schema_member = RuboCop::GraphQL::SchemaMember.new(node)
+
+          if (body = schema_member.body)
+            check_grouped_field_declarations(body)
+          end
+        end
+
         private
 
         GROUP_DEFS_MSG = "Group all field definitions together."
@@ -100,7 +112,6 @@ module RuboCop
 
         def group_field_declarations(corrector, node)
           field = RuboCop::GraphQL::Field.new(node)
-
           first_field = field.schema_member.body.find do |node|
             field_definition?(node) || field_definition_with_body?(node)
           end
@@ -211,7 +222,7 @@ module RuboCop
 
         def remove_old_resolver(corrector, resolver_definition)
           range_to_remove = range_with_surrounding_space(
-            range: resolver_definition.loc.expression, side: :left
+            range: resolver_definition.source_range, side: :left
           )
           corrector.remove(range_to_remove)
 
@@ -220,7 +231,7 @@ module RuboCop
           return unless resolver_signature
 
           range_to_remove = range_with_surrounding_space(
-            range: resolver_signature.loc.expression, side: :left
+            range: resolver_signature.source_range, side: :left
           )
           corrector.remove(range_to_remove)
         end

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

@@ -22,6 +22,7 @@ module RuboCop
         include RuboCop::GraphQL::NodePattern
 
         MSG = "Missing field description"
+        RESTRICT_ON_SEND = %i[field].freeze
 
         def on_send(node)
           return unless field_definition?(node)

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

@@ -41,6 +41,7 @@ module RuboCop
         PATTERN
 
         MSG = "Use hash_key: %<hash_key>p"
+        RESTRICT_ON_SEND = %i[field].freeze
 
         def on_send(node)
           return unless field_definition?(node)
@@ -74,11 +75,11 @@ module RuboCop
           suggested_hash_key_name = hash_key_to_use(method_definition)
 
           corrector.insert_after(
-            node.loc.expression, ", hash_key: #{suggested_hash_key_name.inspect}"
+            node, ", hash_key: #{suggested_hash_key_name.inspect}"
           )
 
           range = range_with_surrounding_space(
-            range: method_definition.loc.expression, side: :left
+            range: method_definition.source_range, side: :left
           )
 
           corrector.remove(range)

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

@@ -40,6 +40,7 @@ module RuboCop
         PATTERN
 
         MSG = "Use method: :%<method_name>s"
+        RESTRICT_ON_SEND = %i[field].freeze
 
         def on_send(node)
           return unless field_definition?(node)
@@ -51,6 +52,7 @@ module RuboCop
 
           return if suggested_method_name.nil?
           return if RuboCop::GraphQL::Field::CONFLICT_FIELD_NAMES.include?(suggested_method_name)
+          return if method_kwarg_set?(field)
 
           add_offense(node, message: message(suggested_method_name)) do |corrector|
             autocorrect(corrector, node)
@@ -68,10 +70,10 @@ module RuboCop
           method_definition = suggest_method_name_for(field)
           suggested_method_name = method_to_use(method_definition)
 
-          corrector.insert_after(node.loc.expression, ", method: :#{suggested_method_name}")
+          corrector.insert_after(node, ", method: :#{suggested_method_name}")
 
           range = range_with_surrounding_space(
-            range: method_definition.loc.expression, side: :left
+            range: method_definition.source_range, side: :left
           )
           corrector.remove(range)
         end
@@ -80,6 +82,10 @@ module RuboCop
           method_name = field.resolver_method_name
           field.schema_member.find_method_definition(method_name)
         end
+
+        def method_kwarg_set?(field)
+          field.kwargs.method != nil
+        end
       end
     end
   end

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

@@ -29,6 +29,7 @@ module RuboCop
         using RuboCop::GraphQL::Ext::SnakeCase
 
         MSG = "Use snake_case for field names"
+        RESTRICT_ON_SEND = %i[field].freeze
 
         def on_send(node)
           return unless field_definition?(node)

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

@@ -63,9 +63,16 @@ module RuboCop
         end
 
         def field_name(node)
-          node.first_argument.value.to_s
+          field = RuboCop::GraphQL::Field.new(node)
+
+          "#{field.name}#{':non-camelized' if false_value?(field.kwargs.camelize)}"
         end
 
+        # @!method false_value?(node)
+        def_node_matcher :false_value?, <<~PATTERN
+          (pair ... false)
+        PATTERN
+
         # @!method field_declarations(node)
         def_node_search :field_declarations, <<~PATTERN
           {

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # Checks consistency of graphql_name usage
+      #
+      # EnforcedStyle supports two modes:
+      #
+      # `only_override` : types and mutations should have graphql_name configured only if it's
+      #  different from the default name
+      #
+      # `required` : all types and mutations should have graphql_name configured
+      #
+      # @example EnforcedStyle: only_override (default)
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     graphql_name 'Viewer'
+      #   end
+      #
+      #   # bad
+      #
+      #   class UserType < BaseType
+      #     graphql_name 'User'
+      #   end
+      #
+      # @example EnforcedStyle: required
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     graphql_name 'User'
+      #   end
+      #
+      #   # bad
+      #
+      #   class UserType < BaseType
+      #   end
+      #
+      class GraphqlName < Base
+        include ConfigurableEnforcedStyle
+
+        # @!method graphql_name(node)
+        def_node_matcher :graphql_name, <<~PATTERN
+          `(send nil? :graphql_name (str $_))
+        PATTERN
+
+        # @!method class_name(node)
+        def_node_matcher :class_name, <<~PATTERN
+          (class (const _ $_) ...)
+        PATTERN
+
+        MISSING_NAME = "graphql_name should be configured."
+        UNNEEDED_OVERRIDE = "graphql_name should be specified only for overrides."
+
+        def on_class(node)
+          specified_name = graphql_name(node)
+
+          case style
+          when :required
+            add_offense(node, message: MISSING_NAME) if specified_name.nil?
+          when :only_override
+            default_graphql_name = class_name(node).to_s.sub(/Type\Z/, "")
+            add_offense(node, message: UNNEEDED_OVERRIDE) if specified_name == default_graphql_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -32,6 +32,7 @@ module RuboCop
 
         MSG = "Avoid using legacy based type-based definitions. " \
               "Use class-based definitions instead."
+        RESTRICT_ON_SEND = %i[define].freeze
 
         def on_send(node)
           return unless node.parent.block_type?

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # Detects missing max_complexity configuration in schema files
+      #
+      # @example
+      #   # good
+      #
+      #   class AppSchema < BaseSchema
+      #     max_complexity 42
+      #   end
+      #
+      class MaxComplexitySchema < Base
+        # @!method max_complexity(node)
+        def_node_matcher :max_complexity, <<~PATTERN
+          `(send nil? :max_complexity ...)
+        PATTERN
+
+        MSG = "max_complexity should be configured for schema."
+
+        def on_class(node)
+          return if ::RuboCop::GraphQL::Class.new(node).nested? || max_complexity(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # Detects missing max_depth configuration in schema files
+      #
+      # @example
+      #   # good
+      #
+      #   class AppSchema < BaseSchema
+      #     max_depth 42
+      #   end
+      #
+      class MaxDepthSchema < Base
+        # @!method max_depth(node)
+        def_node_matcher :max_depth, <<~PATTERN
+          `(send nil? :max_depth ...)
+        PATTERN
+
+        MSG = "max_depth should be configured for schema."
+
+        def on_class(node)
+          return if ::RuboCop::GraphQL::Class.new(node).nested? || max_depth(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -32,6 +32,8 @@ module RuboCop
         include RuboCop::Cop::RangeHelp
         include RuboCop::GraphQL::Heredoc
 
+        RESTRICT_ON_SEND = %i[field].freeze
+
         def on_send(node)
           return unless field?(node)
 

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # Detects types that implement Node interface and not have `.authorized?` check.
+      # Such types can be fetched by ID and therefore should have type level check to
+      # avoid accidental information exposure.
+      #
+      # If `.authorized?` is defined in a parent class, you can add parent to the "SafeBaseClasses"
+      # to avoid offenses in children.
+      #
+      # This cop also checks the `can_can_action` or `pundit_role` methods that
+      # can be used as part of the Ruby GraphQL Pro.
+      #
+      # @example
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     implements GraphQL::Types::Relay::Node
+      #
+      #     field :uuid, ID, null: false
+      #
+      #     def self.authorized?(object, context)
+      #       super && object.owner == context[:viewer]
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     implements GraphQL::Types::Relay::Node
+      #
+      #     field :uuid, ID, null: false
+      #
+      #     class << self
+      #       def authorized?(object, context)
+      #         super && object.owner == context[:viewer]
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     implements GraphQL::Types::Relay::Node
+      #
+      #     pundit_role :staff
+      #
+      #     field :uuid, ID, null: false
+      #   end
+      #
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     implements GraphQL::Types::Relay::Node
+      #
+      #     can_can_action :staff
+      #
+      #     field :uuid, ID, null: false
+      #   end
+      #
+      #   # bad
+      #
+      #   class UserType < BaseType
+      #     implements GraphQL::Types::Relay::Node
+      #
+      #     field :uuid, ID, null: false
+      #   end
+      #
+      class NotAuthorizedNodeType < Base
+        MSG = ".authorized? should be defined for types implementing Node interface."
+
+        # @!method implements_node_type?(node)
+        def_node_matcher :implements_node_type?, <<~PATTERN
+          `(send nil? :implements
+            (const
+              (const
+                (const
+                  (const nil? :GraphQL) :Types) :Relay) :Node))
+        PATTERN
+
+        # @!method has_can_can_action?(node)
+        def_node_matcher :has_can_can_action?, <<~PATTERN
+          `(send nil? :can_can_action {nil_type? sym_type?})
+        PATTERN
+
+        # @!method has_pundit_role?(node)
+        def_node_matcher :has_pundit_role?, <<~PATTERN
+          `(send nil? :pundit_role {nil_type? sym_type?})
+        PATTERN
+
+        # @!method has_authorized_method?(node)
+        def_node_matcher :has_authorized_method?, <<~PATTERN
+          {`(:defs (:self) :authorized? ...) | `(:sclass (:self) `(:def :authorized? ...))}
+        PATTERN
+
+        def on_module(node)
+          @parent_modules ||= []
+          @parent_modules << node.child_nodes[0].const_name
+        end
+
+        def on_class(node)
+          @parent_modules ||= []
+          return if possible_parent_classes(node).any? { |klass| ignored_class?(klass) }
+
+          @parent_modules << node.child_nodes[0].const_name
+
+          add_offense(node) if implements_node_type?(node) && !implements_authorization?(node)
+        end
+
+        private
+
+        def implements_authorization?(node)
+          has_authorized_method?(node) || has_can_can_action?(node) || has_pundit_role?(node)
+        end
+
+        def possible_parent_classes(node)
+          klass = node.child_nodes[1].const_name
+
+          return [] if klass.nil?
+          return [klass] if node.child_nodes[1].absolute?
+
+          parent_module = "#{@parent_modules.join('::')}::"
+          [klass, parent_module + klass]
+        end
+
+        def ignored_class?(klass)
+          cop_config["SafeBaseClasses"].include?(klass)
+        end
+      end
+    end
+  end
+end

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

@@ -52,6 +52,7 @@ module RuboCop
         extend AutoCorrector
 
         include RuboCop::GraphQL::SwapRange
+        include RuboCop::GraphQL::CompareOrder
 
         MSG = "Arguments should be sorted in an alphabetical order within their section. " \
               "Field `%<current>s` should appear before `%<previous>s`."
@@ -71,7 +72,7 @@ module RuboCop
 
           argument_declarations.each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
-            next if argument_name(current) >= argument_name(previous)
+            next if correct_order?(argument_name(previous), argument_name(current))
 
             register_offense(previous, current)
           end

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

@@ -34,15 +34,25 @@ module RuboCop
         extend AutoCorrector
 
         include RuboCop::GraphQL::SwapRange
+        include RuboCop::GraphQL::CompareOrder
 
         MSG = "Fields should be sorted in an alphabetical order within their "\
               "section. "\
               "Field `%<current>s` should appear before `%<previous>s`."
 
+        # @!method field_declarations(node)
+        def_node_search :field_declarations, <<~PATTERN
+          {
+            (send nil? :field (:sym _) ...)
+            (block
+              (send nil? :field (:sym _) ...) ...)
+          }
+        PATTERN
+
         def on_class(node)
           field_declarations(node).each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
-            next if field_name(current) >= field_name(previous)
+            next unless consecutive_fields(previous, current)
+            next if correct_order?(field_name(previous), field_name(current))
 
             register_offense(previous, current)
           end
@@ -50,6 +60,14 @@ module RuboCop
 
         private
 
+        def consecutive_fields(previous, current)
+          return true if cop_config["Groups"] == false
+
+          (previous.source_range.last_line == current.source_range.first_line - 1) ||
+            (previous.parent.block_type? &&
+               previous.parent.last_line == current.source_range.first_line - 1)
+        end
+
         def register_offense(previous, current)
           message = format(
             self.class::MSG,
@@ -69,19 +87,6 @@ module RuboCop
             node.first_argument.value.to_s
           end
         end
-
-        def consecutive_lines(previous, current)
-          previous.source_range.last_line == current.source_range.first_line - 1
-        end
-
-        # @!method field_declarations(node)
-        def_node_search :field_declarations, <<~PATTERN
-          {
-            (send nil? :field (:sym _) ...)
-            (block
-              (send nil? :field (:sym _) ...) ...)
-          }
-        PATTERN
       end
     end
   end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # Checks that GraphQL Argument definitions prepare arguments use String or constants
+      # instead of `prepare: CONST_REF`
+      # This allows better Sorbet typing.
+      #
+      # Preference is given to an input object declaring a `def prepare(...); end` method
+      #
+      # @example
+      #   # bad
+      #   PREPARE = ->(input, context) { ... }
+      #
+      #   argument :input, prepare: PREPARE
+      #
+      #   # good
+      #   def input_prepare(input); ...; end
+      #
+      #   argument :input, prepare: :input_prepare
+      #
+      class PrepareMethod < RuboCop::Cop::Base
+        extend AutoCorrector
+        GENERAL_MSG = "Avoid using prepare lambdas, use prepare: :method_name or "\
+          "prepare: \"method_name\" instead."
+        STRING_MSG = "Avoid using prepare lambdas, use prepare: \"method_name\" instead."
+        PREFER_STRING_MSG = "Avoid using prepare symbols, use prepare: \"%s\" instead."
+        SYMBOL_MSG = "Avoid using prepare lambdas, use prepare: :method_name instead."
+        PREFER_SYMBOL_MSG = "Avoid using prepare string, use prepare: :%s instead."
+
+        ARGUMENT_METHODS = Set[:argument, :public_argument].freeze
+
+        # @!method graphql_argument_with_prepare_block?(node)
+        def_node_matcher :graphql_argument_with_prepare_block?, <<~PATTERN
+          (send nil? ARGUMENT_METHODS ... (hash ... (pair (sym :prepare) $({ const | block } ...) )))
+        PATTERN
+
+        # @!method prepare_method_string_name?(node)
+        def_node_matcher :prepare_method_string_name?, <<~PATTERN
+          (send nil? ARGUMENT_METHODS ... (hash ... (pair (sym :prepare) $(str ...) )))
+        PATTERN
+
+        # @!method prepare_method_symbol_name?(node)
+        def_node_matcher :prepare_method_symbol_name?, <<~PATTERN
+          (send nil? ARGUMENT_METHODS ... (hash ... (pair (sym :prepare) $(sym ...) )))
+        PATTERN
+
+        def on_send(node)
+          type = cop_config["EnforcedStyle"]
+
+          message = case type
+                    when "symbol"
+                      SYMBOL_MSG
+                    when "string"
+                      STRING_MSG
+                    else
+                      GENERAL_MSG
+                    end
+          graphql_argument_with_prepare_block?(node) do |prepare_definition|
+            add_offense(prepare_definition, message: message)
+          end
+
+          if type == "symbol"
+            prepare_method_string_name?(node) do |prepare_definition|
+              method_name = prepare_definition.value
+              add_offense(prepare_definition,
+                          message: format(PREFER_SYMBOL_MSG, method_name)) do |corrector|
+                autocorrect(corrector, node, "\"#{method_name}\"", ":#{method_name}")
+              end
+            end
+          elsif type == "string"
+            prepare_method_symbol_name?(node) do |prepare_definition|
+              method_name = prepare_definition.value
+              add_offense(prepare_definition,
+                          message: format(PREFER_STRING_MSG, method_name)) do |corrector|
+                autocorrect(corrector, node, ":#{method_name}", "\"#{method_name}\"")
+              end
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node, original_method_name, new_method_name)
+          new_source = node.source.sub("prepare: #{original_method_name}",
+                                       "prepare: #{new_method_name}")
+          corrector.replace(node, new_source)
+        end
+      end
+    end
+  end
+end

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

@@ -23,9 +23,11 @@ module RuboCop
           return if excluded_methods.include?(String(node.method_name))
 
           if field_is_defined?(node)
-            length = code_length(node)
+            return if node.line_count <= max_length
 
-            return unless length > max_length
+            calculator = build_code_length_calculator(node)
+            length = calculator.calculate
+            return if length <= max_length
 
             add_offense(node, message: message(length))
           end
@@ -34,10 +36,6 @@ module RuboCop
 
         private
 
-        def code_length(node)
-          node.source.lines[1..-2].count { |line| !irrelevant_line(line) }
-        end
-
         def field_is_defined?(node)
           node.parent
               .children

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

@@ -10,27 +10,33 @@ module RuboCop
       #
       #   class UserType < BaseType
       #     field :name, String, "Name of the user", null: true do
-      #       argument :filter, String, required: false, camelize: false
+      #       argument :filter, String, required: false
       #     end
       #   end
       #
       #   # good
       #
       #   class UserType < BaseType
-      #     argument :filter, String, required: false, camelize: false
+      #     argument :filter, String, required: false
+      #   end
+      #
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     argument :email_filter, String, required: false, camelize: true
       #   end
       #
       #  # bad
       #
       #   class UserType < BaseType
-      #     argument :filter, String, required: false
+      #     argument :filter, String, required: false, camelize: false
       #   end
       #
       #  # bad
       #
       #   class UserType < BaseType
       #     field :name, String, "Name of the user", null: true do
-      #       argument :filter, String, required: false
+      #       argument :filter, String, required: false, camelize: false
       #     end
       #   end
       #
@@ -38,6 +44,7 @@ module RuboCop
         include RuboCop::GraphQL::NodePattern
 
         MSG = "Unnecessary argument camelize"
+        RESTRICT_ON_SEND = %i[argument].freeze
 
         def on_send(node)
           return unless argument?(node)

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

@@ -3,32 +3,56 @@
 module RuboCop
   module Cop
     module GraphQL
-      #  This cop checks if a field has an unnecessary alias.
+      #  This cop prevents defining an unnecessary alias, method, or resolver_method.
       #
       # @example
       #   # good
       #
-      #   class UserType < BaseType
-      #     field :name, String, "Name of the user", null: true, alias: :real_name
-      #   end
+      #   field :name, String, "Name of the user", null: true, alias: :real_name
+      #   field :name, String, "Name of the user", null: true, method: :real_name
+      #   field :name, String, "Name of the user", null: true, resolver_method: :real_name
+      #   field :name, String, "Name of the user", null: true, hash_key: :real_name
       #
       #   # bad
       #
-      #   class UserType < BaseType
-      #     field :name, "Name of the user" String, null: true, alias: :name
-      #   end
+      #   field :name, "Name of the user" String, null: true, alias: :name
+      #   field :name, String, "Name of the user", null: true, method: :name
+      #   field :name, String, "Name of the user", null: true, resolver_method: :name
+      #   field :name, String, "Name of the user", null: true, hash_key: :name
       #
       class UnnecessaryFieldAlias < Base
+        extend AutoCorrector
         include RuboCop::GraphQL::NodePattern
 
-        MSG = "Unnecessary field alias"
+        MSG = "Unnecessary :%<kwarg>s configured"
+        RESTRICT_ON_SEND = %i[field].freeze
 
         def on_send(node)
           return unless field_definition?(node)
 
           field = RuboCop::GraphQL::Field.new(node)
 
-          add_offense(node) if field.name == field.kwargs.alias
+          if (unnecessary_kwarg = validate_kwargs(field))
+            message = format(self.class::MSG, kwarg: unnecessary_kwarg)
+            add_offense(node, message: message) do |corrector|
+              kwarg_node = node.last_argument.pairs.find do |pair|
+                pair.key.value == unnecessary_kwarg.to_sym
+              end
+              corrector.remove_preceding(kwarg_node, 2)
+              corrector.remove(kwarg_node)
+            end
+          end
+        end
+
+        private
+
+        def validate_kwargs(field) # rubocop:disable Metrics/CyclomaticComplexity
+          case field.name
+          when field.kwargs.alias then "alias"
+          when field.kwargs.method&.value&.value then "method"
+          when field.kwargs.resolver_method_name then "resolver_method"
+          when field.kwargs.hash_key&.value&.value then "hash_key"
+          end
         end
       end
     end

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

@@ -22,6 +22,7 @@ module RuboCop
         include RuboCop::GraphQL::NodePattern
 
         MSG = "Unnecessary field camelize"
+        RESTRICT_ON_SEND = %i[field].freeze
 
         def on_send(node)
           return unless field_definition?(node)

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

@@ -132,7 +132,7 @@ module RuboCop
 
           add_offense(node, message: message) do |corrector|
             if node.arguments?
-              corrector.insert_after(arg_end(node.arguments.last), ", #{unresolved_args_source}")
+              corrector.insert_after(arg_end(node.last_argument), ", #{unresolved_args_source}")
             else
               corrector.insert_after(method_name(node), "(#{unresolved_args_source})")
             end
@@ -144,7 +144,7 @@ module RuboCop
         end
 
         def arg_end(node)
-          node.loc.expression.end
+          node.source_range.end
         end
 
         def inferred_arg_name(name_as_string)

data/lib/rubocop/cop/graphql_cops.rb

@@ -11,12 +11,17 @@ require_relative "graphql/field_hash_key"
 require_relative "graphql/field_method"
 require_relative "graphql/field_name"
 require_relative "graphql/field_uniqueness"
+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/multiple_field_definitions"
+require_relative "graphql/not_authorized_node_type"
 require_relative "graphql/resolver_method_length"
 require_relative "graphql/object_description"
 require_relative "graphql/ordered_arguments"
 require_relative "graphql/ordered_fields"
+require_relative "graphql/prepare_method"
 require_relative "graphql/unused_argument"
 require_relative "graphql/unnecessary_argument_camelize"
 require_relative "graphql/unnecessary_field_alias"

data/lib/rubocop/graphql/argument/block.rb

@@ -12,7 +12,7 @@ module RuboCop
           (block
             (send nil? :argument ...)
             (args ...)
-            $...
+            {(begin $...)|$...}
           )
         PATTERN
 

data/lib/rubocop/graphql/compare_order.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    module CompareOrder
+      def correct_order?(previous, current)
+        # If Order config is provided, we should use it to determine the order
+        # Else, we should use alphabetical order
+        # e.g. "Order" => [
+        #   "id",
+        #   "/^id_.*$/",
+        #   "/^.*_id$/",
+        #   "everything-else",
+        #   "/^(created|updated)_at$/"
+        # ]
+        if (order = cop_config["Order"])
+          # For each of previous and current, we should find the first matching order,
+          # checking 'everything-else' last
+          # If the order is the same, we should use alphabetical order
+          # If the order is different, we should use the order
+          previous_order = order_index(previous, order)
+          current_order = order_index(current, order)
+
+          if previous_order == current_order
+            previous <= current
+          else
+            previous_order < current_order
+          end
+        else
+          previous <= current
+        end
+      end
+
+      def order_index(field, order)
+        everything_else_index = order.length
+
+        order.each_with_index do |order_item, index|
+          if order_item == "everything-else"
+            everything_else_index = index
+          elsif order_item.start_with?("/") && order_item.end_with?("/") # is regex-like?
+            return index if field.match?(order_item[1..-2])
+          elsif field == order_item
+            return index
+          end
+        end
+
+        everything_else_index
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/ext/snake_case.rb

@@ -4,7 +4,7 @@ module RuboCop
   module GraphQL
     module Ext
       module SnakeCase
-        SNAKE_CASE = /^[\da-z_]+[!?=]?$/.freeze
+        SNAKE_CASE = /^[\da-z_]+[!?=]?$/
 
         refine Symbol do
           def snake_case?

data/lib/rubocop/graphql/field.rb

@@ -33,7 +33,7 @@ module RuboCop
 
       # @!method field_description(node)
       def_node_matcher :field_description, <<~PATTERN
-        (send nil? :field _ _ (:str $_) ...)
+        (send nil? :field _ _ {(:str $_)|(:dstr $...)} ...)
       PATTERN
 
       attr_reader :node
@@ -84,7 +84,10 @@ module RuboCop
       end
 
       def root_node?(node)
-        node.parent.nil? || node.parent.module_type? || root_with_siblings?(node.parent)
+        node.parent.nil? ||
+          node.module_type? && node.children.none?(&:module_type?) ||
+          node.class_type? ||
+          root_with_siblings?(node.parent)
       end
 
       def root_with_siblings?(node)

data/lib/rubocop/graphql/heredoc.rb

@@ -13,7 +13,7 @@ module RuboCop
                          heredoc?(kwarg.value)
                        end&.value
 
-        range = node.loc.expression
+        range = node.source_range
         range = range.join(last_heredoc.loc.heredoc_end) if last_heredoc
 
         range_by_whole_lines(range)

data/lib/rubocop/graphql/schema_member.rb

@@ -7,7 +7,7 @@ module RuboCop
 
       # @!method class_contents(node)
       def_node_matcher :class_contents, <<~PATTERN
-        (class _ _ $_)
+        {(class _ _ $_) | (module _ $_)}
       PATTERN
 
       attr_reader :node

data/lib/rubocop/graphql/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module GraphQL
-    VERSION = "0.19.0".freeze
+    VERSION = "1.5.1".freeze
   end
 end

data/lib/rubocop-graphql.rb

@@ -7,6 +7,7 @@ require_relative "rubocop/graphql/ext/snake_case"
 require_relative "rubocop/graphql"
 require_relative "rubocop/graphql/version"
 require_relative "rubocop/graphql/inject"
+require_relative "rubocop/graphql/compare_order"
 require_relative "rubocop/graphql/description_method"
 require_relative "rubocop/graphql/heredoc"
 require_relative "rubocop/graphql/node_pattern"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-graphql
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Dmitry Tsepelev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-15 00:00:00.000000000 Z
+date: 2024-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.87'
+        version: '0.90'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -68,7 +68,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.87'
+        version: '0.90'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -95,11 +95,16 @@ files:
 - lib/rubocop/cop/graphql/field_method.rb
 - lib/rubocop/cop/graphql/field_name.rb
 - lib/rubocop/cop/graphql/field_uniqueness.rb
+- lib/rubocop/cop/graphql/graphql_name.rb
 - 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/multiple_field_definitions.rb
+- lib/rubocop/cop/graphql/not_authorized_node_type.rb
 - lib/rubocop/cop/graphql/object_description.rb
 - lib/rubocop/cop/graphql/ordered_arguments.rb
 - lib/rubocop/cop/graphql/ordered_fields.rb
+- lib/rubocop/cop/graphql/prepare_method.rb
 - lib/rubocop/cop/graphql/resolver_method_length.rb
 - lib/rubocop/cop/graphql/unnecessary_argument_camelize.rb
 - lib/rubocop/cop/graphql/unnecessary_field_alias.rb
@@ -111,6 +116,7 @@ files:
 - lib/rubocop/graphql/argument/block.rb
 - lib/rubocop/graphql/argument/kwargs.rb
 - lib/rubocop/graphql/class.rb
+- lib/rubocop/graphql/compare_order.rb
 - lib/rubocop/graphql/description_method.rb
 - lib/rubocop/graphql/ext/snake_case.rb
 - lib/rubocop/graphql/field.rb
@@ -139,7 +145,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="