gitlab-triage 1.56.1 → 1.56.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9420b956227ae89432c05b78279b5c8267bf98e721c4feb2cde5fee21a7d611a
-  data.tar.gz: ffde105e64820dca1e873e4c368bbe65d4039080aba864e114e67e7c6d3efaa3
+  metadata.gz: 51a92e16690b0c2f5453cc6a63f69afc72664c457e66be02a4c0ea976ceedddd
+  data.tar.gz: 36f7c9d84716e73d5f329a98ab06a8e09093b05e77e77dcb9ef8aa0a7cf62a93
 SHA512:
-  metadata.gz: 4475319216eee8897599eef75260c58e3d677043d3a8b86cbe1ef44b6146faafb967786d3004731879b8a9c4996a21620a50956196f978aa94c704f9e2c2ef96
-  data.tar.gz: 42b71bf2233e9daeeec8834b2bb3d651f620f758f83cb3e4e17701208aa40fbf55473532d5eff574dde327afc4c3d97029c370ee5c34198d22bf784a51af932d
+  metadata.gz: e3c94b3fc92a0e66df471d4912f6c97527f1bce6de7b872ee01818fa7eae0bb54defb9ec2c64dcb295997a6d755bd6f9932b4fe2436349c6a6c275ab9e6b9462
+  data.tar.gz: 119e10a479dbfbcd9f0e51ffc17e65582ffa058129c0077175f843a2e450dcfb03e49c8b8a963f15b3e08c3ecfc40fe77c3dc22c23fb5ef540d3c04925610957

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab-triage (1.56.1)
+    gitlab-triage (1.56.2)
       activesupport (>= 5.1)
       globalid (~> 1.0, >= 1.0.1)
       graphql (< 2.1.0)

data/lib/gitlab/triage/engine.rb

@@ -2,6 +2,7 @@
 
 require 'active_support/all'
 require 'active_support/inflector'
+require 'globalid'
 
 require_relative 'expand_condition'
 require_relative 'filters/issue_date_conditions_filter'
@@ -409,14 +410,14 @@ module Gitlab
         end
 
         ExpandCondition.perform(rule_conditions(rule_definition)) do |expanded_conditions|
-          status_pre_filtered = pre_filter_by_work_item_status!(resource_type, expanded_conditions)
+          status_by_id = pre_filter_by_work_item_status!(resource_type, expanded_conditions)
 
           # retrieving the resources for every rule is inefficient
           # however, previous rules may affect those upcoming
           resources = options.resources ||
             fetch_resources(resource_type, expanded_conditions, rule_definition)
 
-          apply_work_item_status!(resource_type, expanded_conditions, rule_definition, resources, status_pre_filtered)
+          apply_work_item_status!(resource_type, expanded_conditions, rule_definition, resources, status_by_id)
 
           # In some filters/actions we want to know which resource type it is
           attach_resource_type(resources, resource_type)
@@ -452,6 +453,7 @@ module Gitlab
 
         if rule_definition[:api] == 'graphql'
           graphql_query_options = { source: source_full_path }
+          pre_filter_status_ids = expanded_conditions.delete(:work_item_status_ids)
 
           if options.resource_reference
             expanded_conditions[:iids] = options.resource_reference[1..]
@@ -463,25 +465,16 @@ module Gitlab
           graphql_query = build_graphql_query(resource_type, expanded_conditions, rule_definition, true)
 
           resources = graphql_network.query(graphql_query, **graphql_query_options)
+          resources = narrow_to_pre_filtered(resources, nil, pre_filter_status_ids)
         else
           # FIXME: Epics listing endpoint doesn't support filtering by `iids`, so instead we
           # get a single epic when `--resource-reference` is given for epics.
           # Because of that, the query could return a single epic, so we make sure we get an array.
           pre_filter_iids = expanded_conditions.delete(:iids)
+          pre_filter_status_ids = expanded_conditions.delete(:work_item_status_ids)
 
           resources = Array(network.query_api(build_get_url(resource_type, expanded_conditions)))
-
-          # Narrow the REST results to the pre-filtered IID set, when a pre-filter
-          # ran. The contract is carried by the value itself: `nil` means no
-          # pre-filter ran (keep all resources), while any array - including `[]` -
-          # means "narrow to exactly these IIDs". An empty array therefore yields
-          # zero resources, which is correct when a pre-filter (e.g. work_item_status)
-          # ran and matched nothing. `present?` cannot express this because it is
-          # false for `[]`.
-          unless pre_filter_iids.nil?
-            filtered_iids = pre_filter_iids.map(&:to_s)
-            resources = resources.select { |r| filtered_iids.include?(r['iid'].to_s) }
-          end
+          resources = narrow_to_pre_filtered(resources, pre_filter_iids, pre_filter_status_ids)
 
           iids = resources.pluck('iid').map(&:to_s)
           expanded_conditions[:iids] = iids
@@ -495,6 +488,29 @@ module Gitlab
         resources
       end
 
+      # Narrow the fetched results to a pre-filtered set, when a pre-filter ran.
+      # The contract is carried by each value: `nil` means that pre-filter did not
+      # run (keep all resources), while any array - including `[]` - means "narrow
+      # to exactly these". An empty array therefore yields zero resources, which is
+      # correct when a pre-filter (e.g. work_item_status) ran and matched nothing;
+      # `present?` cannot express this because it is false for `[]`.
+      #
+      # The work_item_status pre-filter narrows by the globally-unique id, so it
+      # cannot conflate same-iid issues from different projects of a group.
+      def narrow_to_pre_filtered(resources, pre_filter_iids, pre_filter_status_ids)
+        unless pre_filter_status_ids.nil?
+          filtered_ids = pre_filter_status_ids.map(&:to_s)
+          resources = resources.select { |r| filtered_ids.include?(r[:id].to_s) }
+        end
+
+        unless pre_filter_iids.nil?
+          filtered_iids = pre_filter_iids.map(&:to_s)
+          resources = resources.select { |r| filtered_iids.include?(r[:iid].to_s) }
+        end
+
+        resources
+      end
+
       def fetch_work_items(expanded_conditions)
         conditions = expanded_conditions.dup
         conditions[:iids] = options.resource_reference[1..] if options.resource_reference
@@ -729,32 +745,33 @@ module Gitlab
       end
 
       # When filtering by work_item_status, query workItems with server-side
-      # status filtering first to narrow the IID set before the main fetch.
+      # status filtering first to narrow the resource set before the main fetch.
       # This avoids fetching all resources just to discard most of them.
+      #
+      # We narrow by the globally-unique work item id, not the iid: a group
+      # source flattens work items from every descendant project into one list,
+      # and iids are unique only within a project, so two projects can share an
+      # iid. The id side-steps that collision.
       def pre_filter_by_work_item_status!(resource_type, expanded_conditions)
-        return false unless resource_type == 'issues' && expanded_conditions.key?(:work_item_status)
-
-        pre_filter_iids = fetch_work_item_iids_by_status(expanded_conditions[:work_item_status])
+        return unless resource_type == 'issues' && expanded_conditions.key?(:work_item_status)
 
-        expanded_conditions[:iids] =
-          if expanded_conditions[:iids].present?
-            Array(expanded_conditions[:iids]).map(&:to_s) & pre_filter_iids
-          else
-            pre_filter_iids
-          end
+        status_by_id = fetch_work_item_status_by_id(expanded_conditions[:work_item_status])
+        expanded_conditions[:work_item_status_ids] = status_by_id.keys
 
-        true
+        status_by_id
       end
 
-      def apply_work_item_status!(resource_type, expanded_conditions, rule_definition, resources, status_pre_filtered)
+      # The pre-filter (pre_filter_by_work_item_status!) always runs before this
+      # for an issues rule that filters by work_item_status, and returns a map of
+      # id to matched status name. We stamp each resource from that map instead of
+      # a second, iid-keyed status query: the pre-filter already knows the answer,
+      # and keying by the globally-unique id avoids the group iid collision that a
+      # flattened `iids:` query would reintroduce.
+      def apply_work_item_status!(resource_type, expanded_conditions, rule_definition, resources, status_by_id)
         return unless resource_type == 'issues' && needs_work_item_status?(expanded_conditions, rule_definition)
 
-        status_values = Array(expanded_conditions[:work_item_status])
-
-        if status_pre_filtered && status_values.size == 1
-          resources.each { |r| r[:work_item_status] = status_values.first }
-        else
-          decorate_resources_with_work_item_status(resources)
+        resources.each do |resource|
+          resource[:work_item_status] = status_by_id[resource[:id].to_s]
         end
       end
 
@@ -762,24 +779,40 @@ module Gitlab
         conditions.key?(:work_item_status)
       end
 
+      # A group's `workItems` connection returns only the group's own work items
+      # (epics), whose IIDs do not match the project-scoped issue IIDs the issues
+      # fetch returns. `includeDescendants: true` pulls in the descendant project
+      # issues so the status IIDs line up. The argument does not exist on
+      # `project.workItems`, so it is only emitted for a group source.
+      def work_item_descendants_argument
+        options.source == 'groups' ? 'includeDescendants: true, ' : ''
+      end
+
       # Pre-filter: query workItems with server-side status filtering to get only
-      # the IIDs that match, avoiding fetching the full resource set when most
-      # items won't pass the status filter.
-      def fetch_work_item_iids_by_status(status_condition)
+      # the items that match, avoiding fetching the full resource set when most
+      # items won't pass the status filter. Because it queries one status at a
+      # time, it also learns which status each id matched, and returns that as a
+      # map of globally-unique id (from the work item GID) to status name. The id
+      # keys stay correct across a group's descendant projects where iids can
+      # collide, and the map lets the caller stamp statuses without a second
+      # iid-keyed query. When several statuses match the same id, the last one
+      # queried wins; a work item has a single status, so this does not happen in
+      # practice.
+      def fetch_work_item_status_by_id(status_condition)
         status_names = Array(status_condition)
-        all_iids = []
+        status_by_id = {}
 
         status_names.each do |status_name|
           query = <<~GRAPHQL
             query($source: ID!, $after: String, $statusName: String!) {
               #{options.source.singularize}(fullPath: $source) {
-                workItems(status: { name: $statusName }, after: $after, first: 100) {
+                workItems(status: { name: $statusName }, #{work_item_descendants_argument}after: $after, first: 100) {
                   pageInfo {
                     hasNextPage
                     endCursor
                   }
                   nodes {
-                    iid
+                    id
                   }
                 }
               }
@@ -797,8 +830,9 @@ module Gitlab
 
             work_items = Array.wrap(response[:results])
             work_items.each do |wi|
-              iid = wi.is_a?(Hash) ? (wi['iid'] || wi[:iid]) : wi.try(:iid)
-              all_iids << iid.to_s if iid
+              gid = wi.is_a?(Hash) ? (wi['id'] || wi[:id]) : wi.try(:id)
+              id = numeric_id_from_gid(gid)
+              status_by_id[id.to_s] = status_name if id
             end
 
             break unless response[:more_pages]
@@ -807,80 +841,16 @@ module Gitlab
           end
         end
 
-        all_iids.uniq
-      end
-
-      # Status is a work item capability not available on the IssueType GraphQL type
-      # or the REST API. We fetch it via a separate workItems query and merge it back
-      # by IID, similar to how decorate_resources_with_graphql_data works for other fields.
-      # We use widgets (not features) for backward compatibility with GitLab versions
-      # before the features field was introduced in 18.9.
-      def decorate_resources_with_work_item_status(resources)
-        return if resources.empty?
-
-        iids = resources.filter_map { |r| (r['iid'] || r[:iid])&.to_s }
-        return if iids.empty?
-
-        status_by_iid = fetch_work_item_statuses_by_iid(iids)
-
-        resources.each do |resource|
-          iid = (resource['iid'] || resource[:iid]).to_s
-          resource[:work_item_status] = status_by_iid[iid]
-        end
+        status_by_id
       end
 
-      # The workItems connection caps `first` at 100, so we request the status
-      # for the given IIDs in batches and paginate within each batch.
-      def fetch_work_item_statuses_by_iid(iids)
-        query = <<~GRAPHQL
-          query($source: ID!, $iids: [String!], $after: String) {
-            #{options.source.singularize}(fullPath: $source) {
-              workItems(iids: $iids, after: $after, first: 100) {
-                pageInfo {
-                  hasNextPage
-                  endCursor
-                }
-                nodes {
-                  iid
-                  widgets(onlyTypes: [STATUS]) {
-                    ... on WorkItemWidgetStatus {
-                      status {
-                        id
-                        name
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        GRAPHQL
-
-        status_by_iid = {}
-
-        iids.each_slice(100) do |iids_batch|
-          after_cursor = nil
-
-          loop do
-            response = graphql_network.adapter.query_raw(
-              query,
-              resource_path: [options.source.singularize, 'workItems'],
-              variables: { source: source_full_path, iids: iids_batch, after: after_cursor }
-            )
-
-            Array.wrap(response[:results]).each do |wi|
-              wi = wi.deep_transform_keys(&:underscore).with_indifferent_access
-              status_widget = Array.wrap(wi[:widgets]).find { |w| w[:status].present? }
-              status_by_iid[wi[:iid].to_s] = status_widget.dig(:status, :name) if status_widget
-            end
-
-            break unless response[:more_pages]
-
-            after_cursor = response[:end_cursor]
-          end
-        end
+      # A work item GID (`gid://gitlab/WorkItem/1234`) carries the same model id
+      # the REST issues endpoint returns as `id`. Parsed with GlobalID, matching
+      # GraphqlNetwork#extract_id_from_global_id.
+      def numeric_id_from_gid(gid)
+        return if gid.blank?
 
-        status_by_iid
+        GlobalID.parse(gid).model_id
       end
 
       def build_graphql_query(resource_type, conditions, rule_definition, graphql_only = false)

data/lib/gitlab/triage/version.rb

@@ -2,6 +2,6 @@
 
 module Gitlab
   module Triage
-    VERSION = '1.56.1'
+    VERSION = '1.56.2'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-triage
 version: !ruby/object:Gem::Version
-  version: 1.56.1
+  version: 1.56.2
 platform: ruby
 authors:
 - GitLab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport