Add a rule to enforce resolver type annotations

What does this MR do?

This MR adds a new Rubocop rule: Graphql/ResolverType.

This rule enforces that every resolver declares its type explicitly using a top level DSL method.

The reasons for this are:

• Executable documentation: developers can see what a resolver returns
• SSOT for field metadata. We currently are being wasteful in this regard, since fields that have resolver classes can inherit the resolver's field options. There is never a reason for a field to override the type, so we should encourage fields with resolvers to delegate to the resolver for all metadata. For this to work, the resolvers will need to have this metadata defined in all cases, so this cop is the first step.
• Enable better testing of resolvers. To test resolvers properly we need to generate fields for them. To do this we need a type definition.

Does this MR meet the acceptance criteria?

Conformity

• Changelog entry
• Documentation (if required)
• Code review guidelines
• Merge request performance guidelines
• Style guides
• Database guides
• Separation of EE specific content

Availability and Testing

• Review and add/update tests for this feature/bug. Consider all test levels. See the Test Planning Process.
• Tested in all supported browsers
• Informed Infrastructure department of a default or new setting change, if applicable per definition of done

Security

If this MR contains changes to processing or storing of credentials or tokens, authorization and authentication methods and other items described in the security review guidelines:

• Label as security and @ mention @gitlab-com/gl-security/appsec
• The MR includes necessary changes to maintain consistency between UI, API, email, or other methods
• Security reports checked/validated by a reviewer from the AppSec team

rubocop/cop/graphql/resolver_type.rb

+# frozen_string_literal: true
+
+# This cop checks for missing GraphQL type annotations on resolvers
+#
+# @example
+#
+#   # bad
+#   module Resolvers
+#     class NoType < BaseResolver
+#       field :some_field, GraphQL::STRING_TYPE
+#     end
+#   end
+#
+#   # good
+#   module Resolvers
+#     class WithType < BaseResolver
+#       type MyType, null: true
+#
+#       field :some_field, GraphQL::STRING_TYPE
+#     end
+#   end
+
+module RuboCop
+  module Cop
+    module Graphql
+      class ResolverType < RuboCop::Cop::Cop
+        MSG = 'Missing type annotation: Please add `type` DSL method call. ' \
+          'e.g: type UserType.connection_type, null: true'
+
+        def_node_matcher :type_dsl_call?, <<~PATTERN
+          (send nil? :type ...)
+        PATTERN
+
+        def on_class(node)
+          add_offense(node, location: :expression) if resolver?(node) && !typed?(node)
+        end
+
+        private
+
+        def typed?(class_node)
+          body = class_node.children[2]&.children
+          return false unless body
+
+          body.any? { |declaration| type_dsl_call?(declaration) }
+        end
+
+        def resolver?(node)
+          class_name = class_constant(node)&.short_name&.to_s
+
+          !class_name.nil? && class_name.end_with?('Resolver')
+        end
+
+        def class_constant(node)
+          node.descendants.first
+        end
+      end
+    end
+  end
+end