## Summary First of three backend MRs to bring status to Epics. This one is a **pure refactor with zero behavior change**: extract the duplicated status-lifecycle resolution into a single collaborator, `WorkItems::Statuses::Lifecycles::Provider`, and route all callers through it. Nothing epic-specific ships here; this is the foundation the next two MRs build on. Part of the [Status on epics POC](https://gitlab.com/gitlab-org/gitlab/-/work_items/605494). Related to https://gitlab.com/groups/gitlab-org/-/work_items/17709. ## Background Status resolves through a lifecycle per `(root namespace, work item type)`, either the in-code system-defined lifecycle or a DB-backed custom one. The rule is: use the custom lifecycle attached to this type in this namespace if one exists, otherwise fall back to the system-defined lifecycle. That `custom_lifecycle_for(namespace) || system_defined_lifecycle` fallback is duplicated across several call sites: - `ee/app/models/ee/work_items/types_framework/system_defined/type.rb` (`status_lifecycle_for`, `custom_lifecycle_for`, `system_defined_lifecycle`) - `ee/app/models/work_items/types_framework/custom/type.rb` (`status_lifecycle_for`, `custom_lifecycle_for`, private `find_custom_lifecycle_for`) - `ee/app/models/concerns/work_items/has_status.rb` (`find_lifecycle`, with its own ad-hoc `Gitlab::SafeRequestStore` cache and a dead no-namespace branch) Plus direct `custom_lifecycle_for` readers: `ee/app/finders/work_items/status_filter.rb` and `ee/app/models/work_items/statuses/current_status.rb`. This duplication is the seam every follow-up (the read mask, the feature-flag gate, persist-on-write) would otherwise have to touch in five places. Centralizing it first keeps MR 2 and MR 3 small. ## Scope Introduce `WorkItems::Statuses::Lifecycles::Provider` (new file `ee/app/models/work_items/statuses/lifecycles/provider.rb`), mirroring the existing `WorkItems::TypesFramework::Provider` shape. It: - takes a namespace object, resolves its `root_ancestor` - loads the custom lifecycles for that root namespace **once** and indexes them by `work_item_type_id`, caching the index in the request store keyed by root id - exposes `find_by_type(type)` = `find_custom_by_type(type) || type.system_defined_lifecycle` - exposes `find_custom_by_type(type)` = the indexed custom lifecycle for `type.persistable_id`, or nil Then route the callers through it: - `has_status#find_lifecycle` collapses to a single `Provider.new(namespace).find_by_type(work_item_type)` (delete the ad-hoc cache and the dead no-namespace branch) - the EE system-defined and custom `Type` methods become thin delegators (normalizing the id-or-object argument they receive today) - direct `custom_lifecycle_for` readers keep working via the delegators ## Important details - **Identity difference to preserve:** the system-defined type keys the custom-lifecycle lookup by `id`; the custom type keys it by `converted_from_system_defined_type_identifier || id`. Both are what `persistable_id` returns, so index and look up by `type.persistable_id` to keep converted custom types resolving correctly. - **Argument normalization:** callers pass either a namespace id (integer) or a namespace object. The provider takes an object; the type-method delegators normalize (accept id or object, return object, nil-safe). Do not change the public method signatures. - **Caching key:** `[:status_lifecycle_index, root_ancestor.id]` in `Gitlab::SafeRequestStore`, shared across all types for a namespace within a request. Replaces the per-`(namespace, type)` ad-hoc cache in `find_lifecycle`. - **Nil-namespace contract:** `find_lifecycle` currently returns `work_item_type.system_defined_lifecycle` when there is no root namespace. Preserve this: a nil namespace resolves the system-defined lifecycle and never raises. ## Out of scope (deliberately - later MRs) - Read-time masking / fallback to the Issue lifecycle - Any `type_supports_status?` / widget / feature-flag gate - Persist-on-write (`ensure_connection!`) and cache busting - Any change to `Custom::Lifecycle#work_item_types` - Adding `:epic` to the system-defined lifecycle or a status widget on any type ## Acceptance criteria - [ ] `Lifecycles::Provider` resolves the attached custom lifecycle when a row exists, and falls back to the system-defined lifecycle otherwise, for both system-defined and custom types (including converted custom types via `persistable_id`). - [ ] A nil namespace resolves the system-defined lifecycle without raising. - [ ] The index is built with a single query per namespace per request. - [ ] All existing status specs pass **unchanged** (the proof of zero behavior change). If any needs editing to pass, the refactor leaked behavior; fix the code, not the spec. - [ ] A focused `ee/spec/models/work_items/statuses/lifecycles/provider_spec.rb` covers custom-hit, system-fallback, nil-namespace, and the single-query caching claim, tested through the public interface. ## Verification - New spec: `bundle exec rspec ee/spec/models/work_items/statuses/lifecycles/provider_spec.rb` - Regression fence (expect zero failures): `type_spec.rb` (EE system-defined + custom), `current_status_spec.rb`, `work_item_spec.rb`, `update_service_spec.rb` (widgets/statuses + ee/work_items) - `bundle exec rubocop` on changed files