graphql-modernize 0.1.0

data/lib/graphql/modernize/rules/deprecation.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    module Rules
+      module DeprecatedPluginRule
+        private
+
+        def remove_plugin(node, constant)
+          return unless inside?(node, :schema)
+
+          arguments = node.arguments&.arguments
+          first_argument = arguments&.first
+          return unless constant_source(first_argument) == constant
+
+          if !arguments.one? || node.block || !standalone_line?(node)
+            return add_offense(node.location, safety: :manual,
+                                              message: "Remove `use #{constant}` manually and preserve side effects")
+          end
+
+          add_offense(node.location, message: "Remove `use #{constant}` because it is now the default") do |rw|
+            rw.remove_line(node)
+          end
+        end
+      end
+
+      class InterpreterPlugin < Base
+        include DeprecatedPluginRule
+
+        rule id: "GQLM301", safety: :safe, summary: "Remove the now-default Interpreter plugin",
+             since: "1.12.0", docs: "docs/rules/GQLM301.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :use)"
+
+        def on_match(node, _captures)
+          remove_plugin(node, "GraphQL::Execution::Interpreter")
+        end
+      end
+
+      class AnalysisAstPlugin < Base
+        include DeprecatedPluginRule
+
+        rule id: "GQLM302", safety: :safe, summary: "Remove the now-default Analysis::AST plugin",
+             since: "1.12.0", docs: "docs/rules/GQLM302.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :use)"
+
+        def on_match(node, _captures)
+          remove_plugin(node, "GraphQL::Analysis::AST")
+        end
+      end
+
+      class ConnectionsPlugin < Base
+        include DeprecatedPluginRule
+
+        rule id: "GQLM303", safety: :safe, summary: "Remove the now-default Connections plugin",
+             since: "1.12.0", docs: "docs/rules/GQLM303.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :use)"
+
+        def on_match(node, _captures)
+          remove_plugin(node, "GraphQL::Pagination::Connections")
+        end
+      end
+
+      class ErrorBubbling < Base
+        rule id: "GQLM304", safety: :manual, summary: "Review error_bubbling(true)",
+             since: "2.2.7", docs: "docs/rules/GQLM304.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :error_bubbling)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :schema)
+          return unless node.arguments&.arguments&.first.is_a?(Prism::TrueNode)
+
+          add_offense(node.location, message: "`error_bubbling(true)` is deprecated without a replacement")
+        end
+      end
+
+      module RemovedPaginationSetting
+        private
+
+        def remove_setting(node, name)
+          return unless node.name == name
+
+          receiver = constant_source(node.receiver)
+          return unless receiver == "GraphQL::Relay::ConnectionType"
+
+          label = node.name.to_s.delete_suffix("=")
+          value = node.arguments&.arguments&.first
+          unless @context.top_level_statement?(node) && standalone_line?(node) && value && safe_to_discard?(value)
+            return add_offense(node.location, safety: :manual,
+                                              message: "Remove `#{label}` manually without discarding side effects")
+          end
+
+          add_offense(node.location, message: "Remove the obsolete `#{label}` setting") { |rw| rw.remove_line(node) }
+        end
+      end
+
+      class BidirectionalPagination < Base
+        include RemovedPaginationSetting
+
+        rule id: "GQLM305", safety: :safe, summary: "Remove the legacy pagination setting",
+             since: "1.13.10", docs: "docs/rules/GQLM305.md"
+        node_pattern :call_node, "(call_node)"
+
+        def on_match(node, _captures)
+          remove_setting(node, :bidirectional_pagination=)
+        end
+      end
+
+      class DefaultNodesField < Base
+        include RemovedPaginationSetting
+
+        rule id: "GQLM306", safety: :safe, summary: "Remove the legacy default_nodes_field setting",
+             since: "1.13.10", docs: "docs/rules/GQLM306.md"
+        node_pattern :call_node, "(call_node)"
+
+        def on_match(node, _captures)
+          remove_setting(node, :default_nodes_field=)
+        end
+      end
+
+      class VisibilityPlugin < Base
+        rule id: "GQLM307", safety: :unsafe, summary: "Add the Visibility plugin required by visible?",
+             since: "2.4.0", docs: "docs/rules/GQLM307.md"
+        node_pattern :class_node, "(class_node)"
+        node_pattern :call_node, "(call_node receiver: nil name: :use)", handler: :on_visibility_call
+
+        def on_match(node, _captures)
+          context = context_for(node)
+          return unless inside?(node, :schema)
+          return if hierarchy.visible_definitions.empty? || !hierarchy.visibility_plugin_target?(context.class_name)
+
+          return if hierarchy.visibility_plugin_ambiguous?(context.class_name)
+
+          definition = hierarchy.visible_definitions.first
+          message = "visible? (#{definition.path}:#{definition.line}) requires a Visibility plugin"
+          migration_errors = config.rule_options(self.class.metadata.id).fetch("migration_errors", true)
+          plugin = "use GraphQL::Schema::Visibility, migration_errors: #{migration_errors}"
+          add_offense(node.location, message: message) { |rw| rw.insert_into_body(node, plugin, position: :end) }
+        end
+
+        def on_visibility_call(node, _captures)
+          context = context_for(node)
+          return unless inside?(node, :schema)
+
+          plugin = constant_source(node.arguments&.arguments&.first)
+          return unless %w[GraphQL::Schema::Visibility GraphQL::Schema::Warden].include?(plugin)
+          if hierarchy.visibility_plugin_ambiguous?(context.class_name)
+            return add_offense(node.location, safety: :manual,
+                                              message: "Resolve conditional Visibility plugin configuration manually")
+          end
+          return unless plugin == "GraphQL::Schema::Visibility"
+          return unless hierarchy.visibility_plugin_misplaced?(context.class_name, rewriter.source_file.path,
+                                                               node.location.start_offset)
+
+          message = "Move `use GraphQL::Schema::Visibility` after root type configuration"
+          line_end = rewriter.source_file.line_end(node.location.end_offset - 1)
+          trailing = rewriter.source_file.source.byteslice(node.location.end_offset,
+                                                           line_end - node.location.end_offset).strip
+          if node.block || !standalone_line?(node) || !trailing.empty?
+            return add_offense(node.location, safety: :manual, message: message)
+          end
+
+          source = rewriter.dedent(node.location.slice)
+          add_offense(node.location, message: message) do |rw|
+            rw.remove_line(node)
+            rw.insert_into_body(context.class_node, source, position: :end)
+          end
+        end
+      end
+
+      class TypeIndexKeys < Base
+        rule id: "GQLM308", safety: :manual, summary: "Update for possible_types and references_to key changes",
+             since: "2.3.5", docs: "docs/rules/GQLM308.md"
+        node_pattern :call_node, "(call_node)"
+
+        def on_match(node, _captures)
+          receiver = node.receiver&.location&.slice
+          return unless %i[possible_types references_to].include?(node.name)
+          return unless (receiver == "self" && inside?(node, :schema)) || hierarchy.resolve_kind(receiver) == :schema
+
+          add_offense(node.location, message: "Return keys changed from type-name strings to type classes")
+        end
+      end
+
+      class RescueFrom < Base
+        rule id: "GQLM309", safety: :manual, summary: "Review rescue_from placement and handler signatures",
+             docs: "docs/rules/GQLM309.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :rescue_from)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :schema)
+
+          add_offense(node.location, message: "Review `rescue_from` placement and its handler signature")
+        end
+      end
+
+      class EmptyUnionSelections < Base
+        rule id: "GQLM310", safety: :manual, summary: "Choose a migration policy for empty Union selections",
+             since: "2.5.3", docs: "docs/rules/GQLM310.md"
+        node_pattern :class_node, "(class_node)"
+
+        def on_match(node, _captures)
+          context = context_for(node)
+          return unless inside?(node, :schema)
+
+          configured = hierarchy.calls_for(context.class_name).any? do |call|
+            call.direct && call.name == :allow_legacy_invalid_empty_selections_on_union
+          end
+          configured ||= %i[legacy_invalid_empty_selections_on_union
+                            legacy_invalid_empty_selections_on_union_with_type].any? do |name|
+            hierarchy.class_method_defined?(context.class_name, name)
+          end
+          return if configured
+
+          add_offense(node.location, message: "Choose a policy for `allow_legacy_invalid_empty_selections_on_union`")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/modernize/rules/legacy.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    module Rules
+      class DefineDsl < Base
+        rule id: "GQLM101", safety: :manual, summary: "Migrate the `.define` DSL to the class-based API",
+             since: "1.10.0", removed_in: "2.0.0", docs: "docs/rules/GQLM101.md"
+        node_pattern :call_node, "(call_node name: :define)"
+
+        def on_match(node, _captures)
+          receiver = constant_source(node.receiver)
+          return unless receiver&.match?(/\AGraphQL::(?:Object|InputObject|Interface|Enum|Scalar|Union)Type\z/) ||
+                        receiver == "GraphQL::Relay::Mutation"
+
+          add_offense(node.message_loc, message: "Migrate the `.define` DSL to the class-based API manually")
+        end
+      end
+
+      class ResolveFieldOption < Base
+        RESERVED_METHOD_NAMES = %i[context initialize object].freeze
+        UNSUPPORTED_NODES = [
+          Prism::BlockNode, Prism::LambdaNode, Prism::DefNode, Prism::ClassNode, Prism::ModuleNode,
+          Prism::SelfNode, Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode,
+          Prism::ClassVariableReadNode, Prism::ClassVariableWriteNode,
+          Prism::GlobalVariableReadNode, Prism::GlobalVariableWriteNode,
+          Prism::SuperNode, Prism::ForwardingSuperNode, Prism::YieldNode,
+          Prism::NextNode, Prism::BreakNode, Prism::RedoNode, Prism::RetryNode
+        ].freeze
+
+        rule id: "GQLM102", safety: :unsafe, summary: "Move `resolve:` field options to resolver methods",
+             removed_in: "2.0.1", docs: "docs/rules/GQLM102.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :field)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :object, :interface)
+
+          arguments = keyword_arguments(node, :resolve)
+          return if arguments.empty?
+
+          argument = arguments.first
+          if arguments.length > 1
+            return add_offense(argument.location, safety: :manual,
+                                                  message: "Resolve duplicate `resolve:` options manually")
+          end
+
+          method_name = field_method_name(node)
+          lambda_node = argument.value
+          unless convertible?(node, lambda_node, method_name)
+            return add_offense(argument.location, safety: :manual,
+                                                  message: "Move `resolve:` logic to a resolver method manually")
+          end
+
+          @generated_method_names ||= {}
+          if @generated_method_names[method_name] || hierarchy.method_defined?(context_for(node).class_name,
+                                                                               method_name)
+            return add_offense(argument.location, safety: :manual,
+                                                  message: "`#{method_name}` already exists; migrate manually")
+          end
+          @generated_method_names[method_name] = true
+
+          body = resolver_body(lambda_node)
+          method_source = "def #{method_name}(**)\n#{indent_body(body)}\nend"
+          add_offense(argument.location, message: "Move `resolve:` to the `#{method_name}` method") do |rw|
+            rw.remove_keyword_argument(node, :resolve)
+            rw.insert_into_body(context_for(node).class_node, method_source, position: :before_private)
+          end
+        end
+
+        private
+
+        def field_method_name(node)
+          field_name = node.arguments&.arguments&.first
+          name = case field_name
+                 when Prism::SymbolNode, Prism::StringNode then field_name.unescaped
+                 end
+          name if name&.match?(/\A[a-z_]\w*[!?]?\z/) && !RESERVED_METHOD_NAMES.include?(name.to_sym)
+        end
+
+        def convertible?(field, lambda_node, method_name)
+          return false unless method_name && lambda_node.is_a?(Prism::LambdaNode) && lambda_node.body
+          return false unless body_boundaries_are_whitespace?(lambda_node)
+          return false if dynamic_keyword_arguments?(field)
+          return false if %i[method resolver_method hash_key].any? do |name|
+            rewriter.find_keyword_argument(field, name)
+          end
+
+          parameters = lambda_node.parameters&.parameters
+          return false unless simple_parameters?(parameters)
+
+          names = parameters.requireds.map(&:name)
+          safe_body?(lambda_node.body, names)
+        end
+
+        def simple_parameters?(parameters)
+          parameters && parameters.requireds.length == 3 && parameters.optionals.empty? && !parameters.rest &&
+            parameters.posts.empty? && parameters.keywords.empty? && !parameters.keyword_rest && !parameters.block
+        end
+
+        def safe_body?(body, names)
+          nodes = descendants(body)
+          return false if nodes.any? { |child| UNSUPPORTED_NODES.any? { |type| child.is_a?(type) } }
+
+          assignment_names = names.values_at(0, 2) + %i[object context]
+          return false if nodes.any? do |child|
+            child.respond_to?(:name) && assignment_names.include?(child.name) &&
+            (child.is_a?(Prism::LocalVariableTargetNode) || child.class.name.end_with?("WriteNode"))
+          end
+          return false if nodes.grep(Prism::LocalVariableReadNode).any? { |read| read.depth.positive? }
+          return false if nodes.grep(Prism::LocalVariableReadNode).any? { |read| read.name == names[1] }
+          return false if nodes.grep(Prism::CallNode).any? { |call| call.receiver.nil? }
+
+          true
+        end
+
+        def body_boundaries_are_whitespace?(lambda_node)
+          source = rewriter.source_file.source
+          prefix = source.byteslice(lambda_node.opening_loc.end_offset,
+                                    lambda_node.body.location.start_offset - lambda_node.opening_loc.end_offset)
+          suffix = source.byteslice(lambda_node.body.location.end_offset,
+                                    lambda_node.closing_loc.start_offset - lambda_node.body.location.end_offset)
+          prefix.strip.empty? && suffix.strip.empty?
+        end
+
+        def resolver_body(lambda_node)
+          body = lambda_node.body.location.slice.dup
+          parameters = lambda_node.parameters.parameters.requireds.map(&:name)
+          replacements = descendants(lambda_node.body).grep(Prism::LocalVariableReadNode).filter_map do |read|
+            replacement = "object" if read.name == parameters[0]
+            replacement ||= "context" if read.name == parameters[2]
+            next unless replacement
+
+            [read.location.start_offset - lambda_node.body.location.start_offset,
+             read.location.end_offset - lambda_node.body.location.start_offset, replacement]
+          end
+          replacements.sort_by(&:first).reverse_each { |from, to, replacement| body.bytesplice(from...to, replacement) }
+          rewriter.dedent(body)
+        end
+
+        def indent_body(body)
+          rewriter.indent(body).delete_suffix(rewriter.source_file.newline)
+        end
+
+        def descendants(node)
+          node.compact_child_nodes.flat_map { |child| [child, *descendants(child)] }
+        end
+      end
+
+      class FunctionSuperclass < Base
+        rule id: "GQLM103", safety: :unsafe, summary: "Migrate GraphQL::Function to Resolver",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM103.md"
+        node_pattern :class_node, "(class_node)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node.superclass) == "GraphQL::Function"
+
+          add_offense(node.superclass.location, message: "Migrate `GraphQL::Function` to Resolver") do |rw|
+            replace_constant(rw, node.superclass, "GraphQL::Schema::Resolver")
+          end
+        end
+      end
+
+      class DeprecatedDefinitionCall < Base
+        rule id: "GQLM104", safety: :manual, summary: "Remove legacy definition conversion calls",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM104.md"
+        node_pattern :call_node, "(call_node)"
+
+        def on_match(node, _captures)
+          return unless %i[to_graphql graphql_definition].include?(node.name)
+
+          context = context_for(node)
+          return if context && ClassHierarchy::DIRECT_KINDS.key?(context.class_name)
+
+          add_offense(node.message_loc, message: "`#{node.name}` was removed; review this call manually")
+        end
+      end
+
+      class QueryArgumentsConstant < Base
+        rule id: "GQLM108", safety: :manual, summary: "Migrate GraphQL::Query::Arguments references",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM108.md"
+        node_pattern :constant_path_node, "(constant_path_node name: :Arguments)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node) == "GraphQL::Query::Arguments"
+
+          add_offense(node.location, message: "Migrate this use of `GraphQL::Query::Arguments` manually")
+        end
+      end
+
+      class TypesShortcut < Base
+        TYPE_DSL_CALLS = %i[argument field input_field type].freeze
+        REPLACEMENTS = {
+          "Boolean" => "GraphQL::Types::Boolean",
+          "Float" => "Float",
+          "ID" => "GraphQL::Types::ID",
+          "Int" => "Integer",
+          "String" => "String"
+        }.freeze
+
+        rule id: "GQLM105", safety: :safe, summary: "Replace `types.X` with class references",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM105.md"
+        node_pattern :call_node, "(call_node receiver: (call_node receiver: nil name: :types))"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :object, :input_object, :interface, :resolver, :mutation, :subscription)
+          return if node.block || node.arguments&.arguments&.any?
+
+          name = node.message_loc.slice
+          replacement = REPLACEMENTS[name]
+          return unless replacement
+
+          if @context.call_receiver?(node)
+            return add_offense(node.location, safety: :manual,
+                                              message: "Migrate chained `types.#{name}` to the class API manually")
+          end
+          unless type_dsl_argument?(node)
+            return add_offense(node.location, safety: :manual,
+                                              message: "Review `types.#{name}` outside the type DSL manually")
+          end
+
+          add_offense(node.location, message: "Replace `types.#{name}` with `#{replacement}`") do |rw|
+            rw.replace(node.location, replacement)
+          end
+        end
+
+        private
+
+        def type_dsl_argument?(node)
+          call = @context.argument_call(node)
+          return false unless call
+          return true if call.receiver.nil? && TYPE_DSL_CALLS.include?(call.name)
+
+          call.name == :[] && call.receiver.is_a?(Prism::CallNode) && call.receiver.receiver.nil? &&
+            call.receiver.name == :types
+        end
+      end
+
+      class PropertyOption < Base
+        rule id: "GQLM106", safety: :safe, summary: "Replace `property:` with `method:`",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM106.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :field)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :object, :interface)
+
+          arguments = keyword_arguments(node, :property)
+          return if arguments.empty?
+
+          argument = arguments.first
+
+          if arguments.length > 1 || keyword_arguments(node, :method).any? || dynamic_keyword_arguments?(node)
+            return add_offense(argument.location, safety: :manual,
+                                                  message: "Resolve duplicate `property:` and `method:` manually")
+          end
+
+          add_offense(argument.key.location, message: "Replace `property:` with `method:`") do |rw|
+            rw.replace_keyword_key(argument, :method)
+          end
+        end
+      end
+
+      class RemovedFieldOptions < Base
+        TARGETS = %i[field function].freeze
+
+        rule id: "GQLM107", safety: :safe, summary: "Remove deleted field options",
+             removed_in: "2.0.1", docs: "docs/rules/GQLM107.md"
+        node_pattern :call_node, "(call_node receiver: nil name: :field)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :object, :interface)
+
+          keyword_hash = node.arguments&.arguments&.find { |argument| argument.is_a?(Prism::KeywordHashNode) }
+          return unless keyword_hash
+
+          arguments = keyword_hash.elements.select do |argument|
+            argument.is_a?(Prism::AssocNode) && argument.key.is_a?(Prism::SymbolNode) &&
+              TARGETS.include?(argument.key.unescaped.to_sym)
+          end
+          return if arguments.empty?
+
+          unless arguments.all? { |argument| safe_to_discard?(argument.value) } && !dynamic_keyword_arguments?(node)
+            message = "Remove `field:` and `function:` manually; preserve side effects"
+            return add_offense(arguments.first.location, safety: :manual, message: message)
+          end
+
+          add_offense(arguments.first.location, message: "Remove the deleted `field:` and `function:` options") do |rw|
+            if arguments.length == keyword_hash.elements.length
+              if node.arguments.arguments.one? && !node.opening_loc
+                rw.remove(node.message_loc.end_offset...keyword_hash.location.end_offset)
+              else
+                rw.remove_list_element(node.arguments, keyword_hash)
+              end
+            else
+              rw.remove_list_elements(keyword_hash, arguments)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/modernize/rules/modernize.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    module Rules
+      class RedundantRequiredTrue < Base
+        rule id: "GQLM401", safety: :safe, summary: "Remove the default `required: true` option",
+             since: "1.13.0", docs: "docs/rules/GQLM401.md", default_enabled: false
+        node_pattern :call_node, "(call_node receiver: nil name: :argument)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :object, :input_object, :interface, :resolver, :mutation, :subscription)
+
+          arguments = keyword_arguments(node, :required)
+          return if arguments.empty?
+
+          if arguments.length > 1
+            return unless arguments.any? { |argument| argument.value.is_a?(Prism::TrueNode) }
+
+            return add_offense(arguments.first.location, safety: :manual,
+                                                         message: "Resolve duplicate `required:` options manually")
+          end
+          return unless arguments.first.value.is_a?(Prism::TrueNode)
+
+          argument = arguments.first
+          if dynamic_keyword_arguments?(node)
+            return add_offense(argument.location, safety: :manual,
+                                                  message: "Review `**` before removing `required: true` manually")
+          end
+
+          add_offense(argument.location, message: "Remove the default `required: true` option") do |rw|
+            rw.remove_keyword_argument(node, :required)
+          end
+        end
+      end
+
+      class RedundantNullTrue < Base
+        rule id: "GQLM402", safety: :safe, summary: "Remove the default `null: true` option",
+             since: "1.13.0", docs: "docs/rules/GQLM402.md", default_enabled: false
+        node_pattern :call_node, "(call_node receiver: nil name: :field)"
+
+        def on_match(node, _captures)
+          return unless inside?(node, :object, :interface)
+
+          arguments = keyword_arguments(node, :null)
+          return if arguments.empty?
+
+          if arguments.length > 1
+            return unless arguments.any? { |argument| argument.value.is_a?(Prism::TrueNode) }
+
+            return add_offense(arguments.first.location, safety: :manual,
+                                                         message: "Resolve duplicate `null:` options manually")
+          end
+          return unless arguments.first.value.is_a?(Prism::TrueNode)
+
+          argument = arguments.first
+          if dynamic_keyword_arguments?(node)
+            return add_offense(argument.location, safety: :manual,
+                                                  message: "Review `**` expansion and resolve `null: true` manually")
+          end
+
+          add_offense(argument.location, message: "Remove the default `null: true` option") do |rw|
+            rw.remove_keyword_argument(node, :null)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/modernize/rules/relay.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    module Rules
+      class RelayMutationSuperclass < Base
+        rule id: "GQLM201", safety: :unsafe, summary: "Migrate Relay::Mutation to RelayClassicMutation",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM201.md"
+        node_pattern :class_node, "(class_node)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node.superclass) == "GraphQL::Relay::Mutation"
+
+          add_offense(node.superclass.location, message: "Migrate to RelayClassicMutation") do |rw|
+            replace_constant(rw, node.superclass, "GraphQL::Schema::RelayClassicMutation")
+          end
+        end
+      end
+
+      class RelayConnectionType < Base
+        rule id: "GQLM202", safety: :manual, summary: "Migrate ConnectionType.create_type to connection_type",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM202.md"
+        node_pattern :call_node, "(call_node name: :create_type)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node.receiver) == "GraphQL::Relay::ConnectionType"
+
+          add_offense(node.location, message: "Migrate to the generated type's `connection_type` manually")
+        end
+      end
+
+      class RelayNodeField < Base
+        rule id: "GQLM203", safety: :unsafe, summary: "Migrate Relay::Node.field to the Relay node interface",
+             removed_in: "2.0.0", docs: "docs/rules/GQLM203.md"
+        node_pattern :call_node, "(call_node name: :field)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node.receiver) == "GraphQL::Relay::Node"
+
+          add_offense(node.location, message: "Migrate to `implements GraphQL::Types::Relay::Node`")
+        end
+      end
+
+      class DirectBaseConnection < Base
+        rule id: "GQLM204", safety: :unsafe, summary: "Inherit from the generated BaseConnection",
+             docs: "docs/rules/GQLM204.md"
+        node_pattern :class_node, "(class_node)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node.superclass) == "GraphQL::Types::Relay::BaseConnection"
+
+          add_offense(node.superclass.location, message: "Inherit from the application's `Types::BaseConnection`")
+        end
+      end
+
+      class LoadApplicationObjectFailedError < Base
+        OLD_NAME = "GraphQL::Schema::Resolver::LoadApplicationObjectFailedError"
+        NEW_NAME = "GraphQL::LoadApplicationObjectFailedError"
+
+        rule id: "GQLM205", safety: :safe, summary: "Update the LoadApplicationObjectFailedError constant path",
+             since: "1.9.4", docs: "docs/rules/GQLM205.md"
+        node_pattern :constant_path_node, "(constant_path_node name: :LoadApplicationObjectFailedError)"
+
+        def on_match(node, _captures)
+          return unless constant_source(node) == OLD_NAME
+
+          add_offense(node.location, message: "Replace `#{OLD_NAME}` with `#{NEW_NAME}`") do |rw|
+            replace_constant(rw, node, NEW_NAME)
+          end
+        end
+      end
+    end
+  end
+end