gitlab-triage 1.13.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68fbfe16d2db2547d8b262ff52cb7065860d13822a92b38d6d505234aafa0855
-  data.tar.gz: 99dc42b1125665a331b8dd6afe576e1c0b8b0abbd0cf8239d5be44184e900c52
+  metadata.gz: a2927188b4b24b36453f4bac48a82b9af7d2ddc33bb7b5219f533282da9e8370
+  data.tar.gz: 8d35707ba7d219950ab3ba8dda852e89687f16b360cf1f368ae02038ff3ff7cb
 SHA512:
-  metadata.gz: 37e60f6230d1467d18246aa4dc52f439c08939f5a7e2278ed543090c08d5c08b39bffc2840543cbd0a702480d8fbeeb65dc7932fe90a98c2d26a88c8b19f3805
-  data.tar.gz: 8f82804d8431b08791f3e37974a0cc47aacec887af2969f3e612cba8ac8212e0ac6a25f4235424801b01f6eb0d5bc6db72535d0fed1f962658270164613034cd
+  metadata.gz: 12def4c673ceb025d1a286c9c10a53c410d037364865482b85500bff9215d6490e6d0fcc2737f859a8bbeeba5a302c5e2ff6cbddfc7bab1599e909c243240d67
+  data.tar.gz: b98bbed0aabc5cf72595f5dbb3b60ce8d5bb25ad4af19aff1de46c34642ac15c7dc367db39ad1092833a97a923ac73957768bf14b5ed06ccb8bfd518e5fdbdc2

data/.gitlab/CODEOWNERS

@@ -1,2 +1,2 @@
 # The official maintainers
-* @rymai @godfat @markglenfletcher
+* @rymai @godfat-gitlab @markglenfletcher

data/.gitlab/merge_request_templates/Release.md

@@ -32,4 +32,4 @@ with the latest commit from https://gitlab.com/gitlab-org/gitlab-triage/commits/
 - Checklist after merging:
   - [ ] [Update the release notes for the newly created tag](docs/release_process.md#how-to).
 
-/label ~"Engineering Productivity" ~"ep::triage" ~"tooling::workflow"
+/label ~"Engineering Productivity" ~"ep::triage" ~tooling ~"tooling::workflow"

data/README.md

@@ -142,6 +142,7 @@ Available condition types:
 - [`source_branch` condition](#source-branch-condition)
 - [`target_branch` condition](#target-branch-condition)
 - [`weight` condition](#weight-condition)
+- [`discussions` condition](#discussions-condition)
 - [`ruby` condition](#ruby-condition)
 
 ##### Date condition
@@ -486,6 +487,26 @@ conditions:
   weight: Any
 ```
 
+##### Discussions condition
+
+Accepts a hash of fields.
+
+| Field           | Type    | Values                              | Required  |
+| ---------       | ----    | ----                                | --------  |
+| `attribute`     | string  | `threads`, `notes`                  | yes       |
+| `condition`     | string  | `less_than`, `greater_than`         | yes       |
+| `threshold`     | integer | integer                             | yes       |
+
+Example:
+
+```yml
+conditions:
+  discussions:
+    attribute: threads
+    condition: greater_than
+    threshold: 15
+```
+
 ##### Ruby condition
 
 This condition allows users to write a Ruby expression to be evaluated for
@@ -564,6 +585,7 @@ Available action types:
 - [`comment` action](#comment-action)
 - [`comment_type` action option](#comment-type-action-option)
 - [`summarize` action](#summarize-action)
+- [`comment_on_summary` action](#comment-on-summary-action)
 
 ##### Labels action
 
@@ -846,6 +868,56 @@ Which could generate an issue like:
   /label ~"needs attention"
   ```
 
+##### Comment on summary action
+
+Generates one comment for each resource, attaching these comments to the summary
+created by the [`summarize` action](#summarize-action).
+
+The use case for this is wanting to create a summary with an overview, and then
+a threaded discussion for each resource, with a header comment starting each
+discussion.
+
+Accepts a single string value: the template used to generate the comments. For
+details of the syntax of this template, see the [comment action](#comment-action).
+
+Since this action depends on the summary, it is invalid to supply a
+`comment_on_summary` action without an accompanying `summarize` sibling action.
+The `summarize` action will always be completed first.
+
+Just like for [comment action](#comment-action), setting `comment_type` in the
+`actions` set controls whether the comment must be resolved for merge requests.
+See: [`comment_type` action option](#comment-type-action-option).
+
+Example:
+
+```yml
+resource_rules:
+  issues:
+    rules:
+      - name: List of issues to discuss
+        limits:
+          most_recent: 15
+        actions:
+          comment_type: thread
+          comment_on_summary: |
+            # {{title}}
+            
+            author: {{author}}
+          summarize:
+            title: |
+              #{resource[:type].capitalize} require labels
+            item: |
+              - [ ] [{{title}}]({{web_url}}) {{labels}}
+            summary: |
+              The following {{type}} require labels:
+
+              {{items}}
+
+              Please take care of them before the end of #{7.days.from_now.strftime('%Y-%m-%d')}
+
+              /label ~"needs attention"
+```
+
 ### Summary policies
 
 Summary policies are special policies that join multiple rule policies together

data/gitlab-triage.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'activesupport', '~> 5.1'
+  spec.add_dependency 'globalid', '~> 0.4'
+  spec.add_dependency 'graphql-client', '~> 0.16'
   spec.add_dependency 'httparty', '~> 0.17'
 
   spec.add_development_dependency 'bundler'

data/lib/gitlab/triage/action.rb

@@ -1,14 +1,18 @@
 require_relative 'action/summarize'
 require_relative 'action/comment'
+require_relative 'action/comment_on_summary'
 
 module Gitlab
   module Triage
     module Action
       def self.process(policy:, **args)
-        {
-          Summarize => policy.summarize?,
-          Comment => policy.comment?
-        }.compact.each do |action, active|
+        policy.validate!
+
+        [
+          [Summarize, policy.summarize?],
+          [Comment, policy.comment?],
+          [CommentOnSummary, policy.comment_on_summary?]
+        ].each do |action, active|
           act(action: action, policy: policy, **args) if active
         end
       end

data/lib/gitlab/triage/action/comment_on_summary.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../command_builders/text_content_builder'
+require_relative '../command_builders/comment_command_builder'
+require_relative '../command_builders/label_command_builder'
+require_relative '../command_builders/remove_label_command_builder'
+require_relative '../command_builders/cc_command_builder'
+require_relative '../command_builders/status_command_builder'
+require_relative '../command_builders/move_command_builder'
+
+module Gitlab
+  module Triage
+    module Action
+      class CommentOnSummary < Base
+        class Dry < CommentOnSummary
+          def act
+            puts "The following comments would be posted for the rule **#{policy.name}**:\n\n"
+
+            super
+          end
+
+          private
+
+          def perform(comment)
+            puts "# #{summary[:web_url]}\n```\n#{comment}\n```\n"
+          end
+        end
+
+        attr_reader :summary
+
+        def initialize(policy:, network:)
+          super(policy: policy, network: network)
+          @summary = policy.summary
+        end
+
+        def act
+          policy.resources.each do |resource|
+            comment = build_comment(resource).strip
+
+            perform(comment) unless comment.empty?
+          end
+        end
+
+        private
+
+        def build_comment(resource)
+          CommandBuilders::TextContentBuilder.new(policy.actions[:comment_on_summary], resource: resource, network: network).build_command
+        end
+
+        def perform(comment)
+          network.post_api(build_post_url, body: comment)
+        end
+
+        def build_post_url
+          # POST /projects/:id/issues/:issue_iid/notes
+          post_url = UrlBuilders::UrlBuilder.new(
+            network_options: network.options,
+            source_id: summary['project_id'],
+            resource_type: policy.type,
+            resource_id: summary['iid'],
+            sub_resource_type: sub_resource_type
+          ).build
+
+          puts Gitlab::Triage::UI.debug "post_url: #{post_url}" if network.options.debug
+
+          post_url
+        end
+
+        def sub_resource_type
+          case type = policy.actions[:comment_type]
+          when 'comment', nil # nil is default
+            'notes'
+          when 'thread'
+            'discussions'
+          else
+            raise ArgumentError, "Unknown comment type: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/action/summarize.rb

@@ -10,6 +10,12 @@ module Gitlab
           private
 
           def perform
+            policy.summary = {
+              web_url: '[the-created-issue-url]',
+              project_id: 'some-id',
+              iid: 'some-iid'
+            }.with_indifferent_access
+
             if group_summary_without_destination?
               puts Gitlab::Triage::UI.warn("No issue will be created: No summary destination specified when source is 'groups'.")
               return
@@ -35,7 +41,7 @@ module Gitlab
             return
           end
 
-          network.post_api(post_issue_url, post_issue_body)
+          policy.summary = network.post_api(post_issue_url, post_issue_body)
         end
 
         def issue

data/lib/gitlab/triage/api_query_builders/base_query_param_builder.rb

@@ -2,16 +2,25 @@ module Gitlab
   module Triage
     module APIQueryBuilders
       class BaseQueryParamBuilder
-        attr_reader :param_name, :param_contents
+        attr_reader :param_name, :param_contents, :allowed_values
 
-        def initialize(param_name, param_contents)
+        def initialize(param_name, param_contents, allowed_values: nil)
           @param_name = param_name
           @param_contents = param_contents
+          @allowed_values = allowed_values
+
+          validate_allowed_values! if allowed_values
         end
 
         def build_param
           "&#{param_name}=#{param_content.strip}"
         end
+
+        private
+
+        def validate_allowed_values!
+          ParamsValidator.new([{ name: param_name, type: String, values: allowed_values }], { param_name => param_contents }).validate!
+        end
       end
     end
   end

data/lib/gitlab/triage/api_query_builders/multi_query_param_builder.rb

@@ -6,14 +6,22 @@ module Gitlab
       class MultiQueryParamBuilder < BaseQueryParamBuilder
         attr_reader :separator
 
-        def initialize(param_name, param_contents, separator)
+        def initialize(param_name, param_contents, separator, allowed_values: nil)
           @separator = separator
-          super(param_name, param_contents)
+          super(param_name, Array(param_contents), allowed_values: allowed_values)
         end
 
         def param_content
           param_contents.map(&:strip).join(separator)
         end
+
+        private
+
+        def validate_allowed_values!
+          param_contents.each do |param|
+            ParamsValidator.new([{ name: param_name, type: String, values: allowed_values }], { param_name => param }).validate!
+          end
+        end
       end
     end
   end

data/lib/gitlab/triage/engine.rb

@@ -7,6 +7,7 @@ require_relative 'filters/votes_conditions_filter'
 require_relative 'filters/no_additional_labels_conditions_filter'
 require_relative 'filters/author_member_conditions_filter'
 require_relative 'filters/assignee_member_conditions_filter'
+require_relative 'filters/discussions_conditions_filter'
 require_relative 'filters/ruby_conditions_filter'
 require_relative 'limiters/date_field_limiter'
 require_relative 'action'
@@ -19,7 +20,10 @@ require_relative 'api_query_builders/single_query_param_builder'
 require_relative 'api_query_builders/multi_query_param_builder'
 require_relative 'url_builders/url_builder'
 require_relative 'network'
+require_relative 'graphql_network'
 require_relative 'network_adapters/httparty_adapter'
+require_relative 'network_adapters/graphql_adapter'
+require_relative 'graphql_queries/query_builder'
 require_relative 'ui'
 
 module Gitlab
@@ -27,7 +31,14 @@ module Gitlab
     class Engine
       attr_reader :per_page, :policies, :options
 
-      def initialize(policies:, options:, network_adapter_class: Gitlab::Triage::NetworkAdapters::HttpartyAdapter)
+      DEFAULT_NETWORK_ADAPTER = Gitlab::Triage::NetworkAdapters::HttpartyAdapter
+      DEFAULT_GRAPHQL_ADAPTER = Gitlab::Triage::NetworkAdapters::GraphqlAdapter
+      ALLOWED_STATE_VALUES = {
+        issues: %w[opened closed],
+        merge_requests: %w[opened closed merged]
+      }.with_indifferent_access.freeze
+
+      def initialize(policies:, options:, network_adapter_class: DEFAULT_NETWORK_ADAPTER, graphql_network_adapter_class: DEFAULT_GRAPHQL_ADAPTER)
         options.host_url = policies.delete(:host_url) { options.host_url }
         options.api_version = policies.delete(:api_version) { 'v4' }
         options.dry_run = ENV['TEST'] == 'true' if options.dry_run.nil?
@@ -36,6 +47,7 @@ module Gitlab
         @policies = policies
         @options = options
         @network_adapter_class = network_adapter_class
+        @graphql_network_adapter_class = graphql_network_adapter_class
 
         assert_all!
         assert_project_id!
@@ -62,6 +74,10 @@ module Gitlab
         @network ||= Network.new(network_adapter)
       end
 
+      def graphql_network
+        @graphql_network ||= GraphqlNetwork.new(graphql_network_adapter)
+      end
+
       private
 
       def assert_project_id!
@@ -94,6 +110,10 @@ module Gitlab
         @network_adapter ||= @network_adapter_class.new(options)
       end
 
+      def graphql_network_adapter
+        @graphql_network_adapter ||= @graphql_network_adapter_class.new(options)
+      end
+
       def rule_conditions(rule)
         rule.fetch(:conditions) { {} }
       end
@@ -158,8 +178,13 @@ module Gitlab
           # retrieving the resources for every rule is inefficient
           # however, previous rules may affect those upcoming
           resources = network.query_api(build_get_url(resource_type, conditions))
+          iids = resources.pluck('iid').map(&:to_s)
+
+          graphql_query = build_graphql_query(resource_type, conditions)
+          graphql_resources = graphql_network.query(graphql_query, source: source_full_path, iids: iids) if graphql_query.present?
           # In some filters/actions we want to know which resource type it is
           attach_resource_type(resources, resource_type)
+          decorate_resources_with_graphql_data(resources, graphql_resources)
 
           puts "\n\n* Found #{resources.count} resources..."
           print "* Filtering resources..."
@@ -180,6 +205,13 @@ module Gitlab
         resources.each { |resource| resource[:type] ||= resource_type }
       end
 
+      def decorate_resources_with_graphql_data(resources, graphql_resources)
+        return if graphql_resources.nil?
+
+        graphql_resources_by_id = graphql_resources.to_h { |resource| [resource[:id], resource] }
+        resources.each { |resource| resource.merge!(graphql_resources_by_id[resource[:id]].to_h) }
+      end
+
       def process_action(policy)
         Action.process(
           policy: policy,
@@ -213,6 +245,10 @@ module Gitlab
             results << Filters::AssigneeMemberConditionsFilter.new(resource, conditions[:assignee_member], network).calculate
           end
 
+          if conditions[:discussions]
+            results << Filters::DiscussionsConditionsFilter.new(resource, conditions[:discussions]).calculate
+          end
+
           if conditions[:ruby]
             results << Filters::RubyConditionsFilter.new(resource, conditions, network).calculate
           end
@@ -244,7 +280,13 @@ module Gitlab
           condition_builders << APIQueryBuilders::MultiQueryParamBuilder.new('not[labels]', conditions[:forbidden_labels], ',')
         end
 
-        condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('state', conditions[:state]) if conditions[:state]
+        if conditions[:state]
+          condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new(
+            'state',
+            conditions[:state],
+            allowed_values: ALLOWED_STATE_VALUES[resource_type])
+        end
+
         condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('milestone', Array(conditions[:milestone])[0]) if conditions[:milestone]
         condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('source_branch', conditions[:source_branch]) if conditions[:source_branch]
         condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('target_branch', conditions[:target_branch]) if conditions[:target_branch]
@@ -270,6 +312,26 @@ module Gitlab
           params: params
         ).build
       end
+
+      def build_graphql_query(resource_type, conditions)
+        Gitlab::Triage::GraphqlQueries::QueryBuilder
+          .new(options.source, resource_type, conditions)
+      end
+
+      def source_full_path
+        @source_full_path ||= fetch_source_full_path
+      end
+
+      def fetch_source_full_path
+        return options.source_id unless /\A\d+\z/.match?(options.source_id)
+
+        source_details = network.query_api(build_get_url(nil, {})).first
+        full_path = source_details['full_path'] || source_details['path_with_namespace']
+
+        raise ArgumentError, 'A source with given source_id was not found!' if full_path.blank?
+
+        full_path
+      end
     end
   end
 end

data/lib/gitlab/triage/errors/network.rb

@@ -3,6 +3,7 @@ module Gitlab
     module Errors
       module Network
         InternalServerError = Class.new(StandardError)
+        UnexpectedResponse = Class.new(StandardError)
       end
     end
   end

data/lib/gitlab/triage/filters/discussions_conditions_filter.rb

@@ -0,0 +1,58 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class DiscussionsConditionsFilter < BaseConditionsFilter
+        ATTRIBUTES = %w[notes threads].freeze
+        CONDITIONS = %w[greater_than less_than].freeze
+
+        def self.filter_parameters
+          [
+            {
+              name: :attribute,
+              type: String,
+              values: ATTRIBUTES
+            },
+            {
+              name: :condition,
+              type: String,
+              values: CONDITIONS
+            },
+            {
+              name: :threshold,
+              type: Numeric
+            }
+          ]
+        end
+
+        def initialize_variables(condition)
+          @attribute = condition[:attribute].to_sym
+          @condition = condition[:condition].to_sym
+          @threshold = condition[:threshold]
+        end
+
+        def resource_value
+          if @attribute == :notes
+            @resource[:user_notes_count]
+          else
+            @resource[:user_discussions_count]
+          end
+        end
+
+        def condition_value
+          @threshold
+        end
+
+        def calculate
+          case @condition
+          when :greater_than
+            resource_value.to_i > condition_value
+          when :less_than
+            resource_value.to_i < condition_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_network.rb

@@ -0,0 +1,71 @@
+require 'active_support/all'
+require 'net/protocol'
+require 'globalid'
+
+require_relative 'retryable'
+require_relative 'ui'
+require_relative 'errors'
+
+module Gitlab
+  module Triage
+    class GraphqlNetwork
+      attr_reader :options, :adapter
+
+      MINIMUM_RATE_LIMIT = 25
+
+      def initialize(adapter)
+        @adapter = adapter
+        @options = adapter.options
+      end
+
+      def query(graphql_query, variables = {})
+        return if graphql_query.blank?
+
+        response = {}
+        resources = []
+
+        parsed_graphql_query = adapter.parse(graphql_query.query)
+
+        begin
+          print '.'
+
+          response = adapter.query(
+            parsed_graphql_query,
+            resource_path: graphql_query.resource_path,
+            variables: variables.merge(after: response.delete(:end_cursor))
+          )
+
+          rate_limit_debug(response) if options.debug
+          rate_limit_wait(response)
+
+          resources.concat(Array.wrap(response.delete(:results)))
+        end while response.delete(:more_pages)
+
+        resources
+          .map { |resource| resource.deep_transform_keys(&:underscore) }
+          .map(&:with_indifferent_access)
+          .map { |resource| resource.merge(id: extract_id_from_global_id(resource[:id])) }
+      end
+
+      private
+
+      def extract_id_from_global_id(global_id)
+        return if global_id.blank?
+
+        GlobalID.parse(global_id).model_id.to_i
+      end
+
+      def rate_limit_debug(response)
+        rate_limit_infos = "Rate limit remaining: #{response[:ratelimit_remaining]} (reset at #{response[:ratelimit_reset_at]})"
+        puts Gitlab::Triage::UI.debug "rate_limit_infos: #{rate_limit_infos}"
+      end
+
+      def rate_limit_wait(response)
+        return unless response.delete(:ratelimit_remaining) < MINIMUM_RATE_LIMIT
+
+        puts Gitlab::Triage::UI.debug "Rate limit almost exceeded, sleeping for #{response[:ratelimit_reset_at] - Time.now} seconds" if options.debug
+        sleep(1) until Time.now >= response[:ratelimit_reset_at]
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/query_builder.rb

@@ -0,0 +1,47 @@
+require_relative 'user_notes_query'
+require_relative 'threads_query'
+
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      class QueryBuilder
+        def initialize(source_type, resource_type, conditions)
+          @source_type = source_type.to_s.singularize
+          @resource_type = resource_type
+          @conditions = conditions
+        end
+
+        def resource_path
+          [source_type, resource_type]
+        end
+
+        def query
+          return if query_template.nil?
+
+          format(query_template, source_type: source_type, resource_type: resource_type.to_s.camelize(:lower), group_query: group_query)
+        end
+
+        delegate :present?, to: :query_template
+
+        private
+
+        attr_reader :source_type, :resource_type, :conditions
+
+        def query_template
+          case conditions.dig(:discussions, :attribute).to_s
+          when 'notes'
+            UserNotesQuery
+          when 'threads'
+            ThreadsQuery
+          end
+        end
+
+        def group_query
+          return if source_type != 'group'
+
+          ', includeSubgroups: true'
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/threads_query.rb

@@ -0,0 +1,23 @@
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      ThreadsQuery = <<-GRAPHQL.freeze # rubocop:disable Naming/ConstantName
+        query($source: ID!, $after: String, $iids: [String!]) {
+          %{source_type}(fullPath: $source) {
+            id
+            %{resource_type}(after: $after, iids: $iids%{group_query}) {
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                id
+                userDiscussionsCount
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/user_notes_query.rb

@@ -0,0 +1,23 @@
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      UserNotesQuery = <<-GRAPHQL.freeze # rubocop:disable Naming/ConstantName
+        query($source: ID!, $after: String, $iids: [String!]) {
+          %{source_type}(fullPath: $source) {
+            id
+            %{resource_type}(after: $after, iids: $iids%{group_query}) {
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                id
+                userNotesCount
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
+  end
+end

data/lib/gitlab/triage/network.rb

@@ -44,8 +44,10 @@ module Gitlab
           case results
           when Array
             resources.concat(results)
-          else
+          when Hash
             resources << results
+          else
+            raise Errors::Network::UnexpectedResponse, "Unexpected response: #{results.inspect}"
           end
 
           rate_limit_debug(response) if options.debug

data/lib/gitlab/triage/network_adapters/graphql_adapter.rb

@@ -0,0 +1,92 @@
+require 'httparty'
+require 'graphql/client'
+require 'graphql/client/http'
+
+require_relative 'base_adapter'
+require_relative '../ui'
+require_relative '../errors'
+
+module Gitlab
+  module Triage
+    module NetworkAdapters
+      class GraphqlAdapter < BaseAdapter
+        Client = GraphQL::Client
+
+        def query(graphql_query, resource_path: [], variables: {})
+          response = client.query(graphql_query, variables: variables, context: { token: options.token })
+
+          raise_on_error!(response)
+
+          parsed_response = parse_response(response, resource_path)
+          headers = response.extensions.fetch('headers', {})
+
+          graphql_response = {
+            ratelimit_remaining: headers['ratelimit-remaining'].to_i,
+            ratelimit_reset_at: Time.at(headers['ratelimit-reset'].to_i)
+          }
+
+          return graphql_response.merge(results: {}) if parsed_response.nil?
+          return graphql_response.merge(results: parsed_response.map(&:to_h)) if parsed_response.is_a?(Client::List)
+          return graphql_response.merge(results: parsed_response.to_h) unless parsed_response.nodes?
+
+          graphql_response.merge(
+            more_pages: parsed_response.page_info.has_next_page,
+            end_cursor: parsed_response.page_info.end_cursor,
+            results: parsed_response.nodes.map(&:to_h)
+          )
+        end
+
+        delegate :parse, to: :client
+
+        private
+
+        def parse_response(response, resource_path)
+          resource_path.reduce(response.data) { |data, resource| data&.send(resource) }
+        end
+
+        def raise_on_error!(response)
+          return if response.errors.blank?
+
+          puts Gitlab::Triage::UI.debug response.inspect if options.debug
+
+          raise "There was an error: #{response.errors.messages.to_json}"
+        end
+
+        def http_client
+          Client::HTTP.new("#{options.host_url}/api/graphql") do
+            def execute(document:, operation_name: nil, variables: {}, context: {}) # rubocop:disable Lint/NestedMethodDefinition
+              body = {}
+              body['query'] = document.to_query_string
+              body['variables'] = variables if variables.any?
+              body['operationName'] = operation_name if operation_name
+
+              response = HTTParty.post(
+                uri,
+                body: body.to_json,
+                headers: {
+                  'Content-type' => 'application/json',
+                  'PRIVATE-TOKEN' => context[:token]
+                }
+              )
+
+              case response.code
+              when 200, 400
+                JSON.parse(response.body).merge('extensions' => { 'headers' => response.headers })
+              else
+                { 'errors' => [{ 'message' => "#{response.code} #{response.message}" }] }
+              end
+            end
+          end
+        end
+
+        def schema
+          @schema ||= Client.load_schema(http_client)
+        end
+
+        def client
+          @client ||= Client.new(schema: schema, execute: http_client).tap { |client| client.allow_dynamic_queries = true }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/policies/base_policy.rb

@@ -4,7 +4,10 @@ module Gitlab
   module Triage
     module Policies
       class BasePolicy
+        InvalidPolicyError = Class.new(StandardError)
+
         attr_reader :type, :policy_spec, :resources, :network
+        attr_accessor :summary
 
         def initialize(type, policy_spec, resources, network)
           @type = type
@@ -13,6 +16,10 @@ module Gitlab
           @network = network
         end
 
+        def validate!
+          raise InvalidPolicyError, 'Policies that comment_on_summary must include summarize action' if comment_on_summary? && !summarize?
+        end
+
         def name
           @name ||= (policy_spec[:name] || "#{type}-#{object_id}")
         end
@@ -25,9 +32,13 @@ module Gitlab
           actions.key?(:summarize)
         end
 
+        def comment_on_summary?
+          actions.key?(:comment_on_summary)
+        end
+
         def comment?
           # The actual keys are strings
-          (actions.keys.map(&:to_sym) - [:summarize]).any?
+          (actions.keys.map(&:to_sym) - [:summarize, :comment_on_summary]).any?
         end
 
         def build_issue

data/lib/gitlab/triage/validators/params_validator.rb

@@ -34,7 +34,7 @@ module Gitlab
       def validate_parameter_content(value)
         @parameter_definitions.each do |param|
           if param[:values]
-            raise InvalidParameter, "#{param[:name]} must be of one of #{param[:values].join(',')}" unless param[:values].include?(value[param[:name]])
+            raise InvalidParameter, "#{param[:name]} must be one of #{param[:values].join(',')}" unless param[:values].include?(value[param[:name]])
           end
         end
       end

data/lib/gitlab/triage/version.rb

@@ -2,6 +2,6 @@
 
 module Gitlab
   module Triage
-    VERSION = '1.13.0'
+    VERSION = '1.15.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-triage
 version: !ruby/object:Gem::Version
-  version: 1.13.0
+  version: 1.15.0
 platform: ruby
 authors:
 - GitLab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-26 00:00:00.000000000 Z
+date: 2021-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: globalid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: graphql-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +162,7 @@ files:
 - lib/gitlab/triage/action.rb
 - lib/gitlab/triage/action/base.rb
 - lib/gitlab/triage/action/comment.rb
+- lib/gitlab/triage/action/comment_on_summary.rb
 - lib/gitlab/triage/action/summarize.rb
 - lib/gitlab/triage/api_query_builders/base_query_param_builder.rb
 - lib/gitlab/triage/api_query_builders/date_query_param_builder.rb
@@ -158,16 +187,22 @@ files:
 - lib/gitlab/triage/filters/assignee_member_conditions_filter.rb
 - lib/gitlab/triage/filters/author_member_conditions_filter.rb
 - lib/gitlab/triage/filters/base_conditions_filter.rb
+- lib/gitlab/triage/filters/discussions_conditions_filter.rb
 - lib/gitlab/triage/filters/member_conditions_filter.rb
 - lib/gitlab/triage/filters/merge_request_date_conditions_filter.rb
 - lib/gitlab/triage/filters/name_conditions_filter.rb
 - lib/gitlab/triage/filters/no_additional_labels_conditions_filter.rb
 - lib/gitlab/triage/filters/ruby_conditions_filter.rb
 - lib/gitlab/triage/filters/votes_conditions_filter.rb
+- lib/gitlab/triage/graphql_network.rb
+- lib/gitlab/triage/graphql_queries/query_builder.rb
+- lib/gitlab/triage/graphql_queries/threads_query.rb
+- lib/gitlab/triage/graphql_queries/user_notes_query.rb
 - lib/gitlab/triage/limiters/base_limiter.rb
 - lib/gitlab/triage/limiters/date_field_limiter.rb
 - lib/gitlab/triage/network.rb
 - lib/gitlab/triage/network_adapters/base_adapter.rb
+- lib/gitlab/triage/network_adapters/graphql_adapter.rb
 - lib/gitlab/triage/network_adapters/httparty_adapter.rb
 - lib/gitlab/triage/network_adapters/test_adapter.rb
 - lib/gitlab/triage/option_parser.rb
@@ -213,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: GitLab triage automation project.