app/models/onboarding_progress.rb

-# frozen_string_literal: true
-
-class OnboardingProgress < ApplicationRecord
-  belongs_to :namespace, optional: false
-
-  validate :namespace_is_root_namespace
-
-  ACTIONS = [
-    :git_pull,
-    :git_write,
-    :merge_request_created,
-    :pipeline_created,
-    :user_added,
-    :trial_started,
-    :subscription_created,
-    :required_mr_approvals_enabled,
-    :code_owners_enabled,
-    :scoped_label_created,
-    :security_scan_enabled,
-    :issue_created,
-    :issue_auto_closed,
-    :repository_imported,
-    :repository_mirrored,
-    :secure_dependency_scanning_run,
-    :secure_container_scanning_run,
-    :secure_dast_run,
-    :secure_secret_detection_run,
-    :secure_coverage_fuzzing_run,
-    :secure_api_fuzzing_run,
-    :secure_cluster_image_scanning_run,
-    :license_scanning_run
-  ].freeze
-
-  scope :incomplete_actions, -> (actions) do
-    Array.wrap(actions).inject(self) { |scope, action| scope.where(column_name(action) => nil) }
-  end
-
-  scope :completed_actions, -> (actions) do
-    Array.wrap(actions).inject(self) { |scope, action| scope.where.not(column_name(action) => nil) }
-  end
-
-  scope :completed_actions_with_latest_in_range, -> (actions, range) do
-    actions = Array(actions)
-    if actions.size == 1
-      where(column_name(actions[0]) => range)
-    else
-      action_columns = actions.map { |action| arel_table[column_name(action)] }
-      completed_actions(actions).where(Arel::Nodes::NamedFunction.new('GREATEST', action_columns).between(range))
-    end
-  end
-
-  class << self
-    def onboard(namespace)
-      return unless root_namespace?(namespace)
-
-      create(namespace: namespace)
-    end
-
-    def onboarding?(namespace)
-      where(namespace: namespace).any?
-    end
-
-    def register(namespace, actions)
-      actions = Array(actions)
-      return unless root_namespace?(namespace) && actions.difference(ACTIONS).empty?
-
-      onboarding_progress = find_by(namespace: namespace)
-      return unless onboarding_progress
-
-      now = Time.current
-      nil_actions = actions.select { |action| onboarding_progress[column_name(action)].nil? }
-      return if nil_actions.empty?
-
-      updates = nil_actions.inject({}) { |sum, action| sum.merge!({ column_name(action) => now }) }
-      onboarding_progress.update!(updates)
-    end
-
-    def completed?(namespace, action)
-      return unless root_namespace?(namespace) && ACTIONS.include?(action)
-
-      action_column = column_name(action)
-      where(namespace: namespace).where.not(action_column => nil).exists?
-    end
-
-    def not_completed?(namespace_id, action)
-      return unless ACTIONS.include?(action)
-
-      action_column = column_name(action)
-      where(namespace_id: namespace_id).where(action_column => nil).exists?
-    end
-
-    def column_name(action)
-      :"#{action}_at"
-    end
-
-    private
-
-    def root_namespace?(namespace)
-      namespace && namespace.root?
-    end
-  end
-
-  def number_of_completed_actions
-    attributes.extract!(*ACTIONS.map { |action| self.class.column_name(action).to_s }).compact!.size
-  end
-
-  private
-
-  def namespace_is_root_namespace
-    return unless namespace
-
-    errors.add(:namespace, _('must be a root namespace')) if namespace.has_parent?
-  end
-end

app/models/packages/package.rb

@@ -242,22 +242,23 @@ def self.keyset_pagination_order(join_class:, column_name:, direction: :asc)
     reverse_order_direction = direction == :asc ? desc_order_expression : asc_order_expression
     arel_order_classes = ::Gitlab::Pagination::Keyset::ColumnOrderDefinition::AREL_ORDER_CLASSES.invert
 
-    ::Gitlab::Pagination::Keyset::Order.build([
-      ::Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-        attribute_name: "#{join_table}_#{column_name}",
-        column_expression: join_class.arel_table[column_name],
-        order_expression: order_direction,
-        reversed_order_expression: reverse_order_direction,
-        order_direction: direction,
-        distinct: false,
-        add_to_projections: true
-      ),
-      ::Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-        attribute_name: 'id',
-        order_expression: arel_order_classes[direction].new(Packages::Package.arel_table[:id]),
-        add_to_projections: true
-      )
-    ])
+    ::Gitlab::Pagination::Keyset::Order.build(
+      [
+        ::Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+          attribute_name: "#{join_table}_#{column_name}",
+          column_expression: join_class.arel_table[column_name],
+          order_expression: order_direction,
+          reversed_order_expression: reverse_order_direction,
+          order_direction: direction,
+          distinct: false,
+          add_to_projections: true
+        ),
+        ::Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+          attribute_name: 'id',
+          order_expression: arel_order_classes[direction].new(Packages::Package.arel_table[:id]),
+          add_to_projections: true
+        )
+      ])
   end
 
   def versions

app/models/project.rb

@@ -569,26 +569,29 @@ def self.integration_association_name(name)
   scope :projects_order_id_desc, -> { reorder(self.arel_table['id'].desc) }
 
   scope :sorted_by_similarity_desc, -> (search, include_in_select: false) do
-    order_expression = Gitlab::Database::SimilarityScore.build_expression(search: search, rules: [
-      { column: arel_table["path"], multiplier: 1 },
-      { column: arel_table["name"], multiplier: 0.7 },
-      { column: arel_table["description"], multiplier: 0.2 }
-    ])
-
-    order = Gitlab::Pagination::Keyset::Order.build([
-      Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-        attribute_name: 'similarity',
-        column_expression: order_expression,
-        order_expression: order_expression.desc,
-        order_direction: :desc,
-        distinct: false,
-        add_to_projections: true
-      ),
-      Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-        attribute_name: 'id',
-        order_expression: Project.arel_table[:id].desc
-      )
-    ])
+    order_expression = Gitlab::Database::SimilarityScore.build_expression(
+      search: search,
+      rules: [
+        { column: arel_table["path"], multiplier: 1 },
+        { column: arel_table["name"], multiplier: 0.7 },
+        { column: arel_table["description"], multiplier: 0.2 }
+      ])
+
+    order = Gitlab::Pagination::Keyset::Order.build(
+      [
+        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+          attribute_name: 'similarity',
+          column_expression: order_expression,
+          order_expression: order_expression.desc,
+          order_direction: :desc,
+          distinct: false,
+          add_to_projections: true
+        ),
+        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+          attribute_name: 'id',
+          order_expression: Project.arel_table[:id].desc
+        )
+      ])
 
     order.apply_cursor_conditions(reorder(order))
   end
@@ -1167,7 +1170,7 @@ def latest_successful_build_for_ref(job_name, ref = default_branch)
     latest_pipeline = ci_pipelines.latest_successful_for_ref(ref)
     return unless latest_pipeline
 
-    latest_pipeline.build_with_artifacts_in_self_and_descendants(job_name)
+    latest_pipeline.build_with_artifacts_in_self_and_project_descendants(job_name)
   end
 
   def latest_successful_build_for_sha(job_name, sha)
@@ -1176,7 +1179,7 @@ def latest_successful_build_for_sha(job_name, sha)
     latest_pipeline = ci_pipelines.latest_successful_for_sha(sha)
     return unless latest_pipeline
 
-    latest_pipeline.build_with_artifacts_in_self_and_descendants(job_name)
+    latest_pipeline.build_with_artifacts_in_self_and_project_descendants(job_name)
   end
 
   def latest_successful_build_for_ref!(job_name, ref = default_branch)
@@ -2562,10 +2565,7 @@ def storage_version=(value)
   def badges
     return project_badges unless group
 
-    Badge.from_union([
-      project_badges,
-      GroupBadge.where(group: group.self_and_ancestors)
-    ])
+    Badge.from_union([project_badges, GroupBadge.where(group: group.self_and_ancestors)])
   end
 
   def merge_requests_allowing_push_to_user(user)

app/models/projects/topic.rb

@@ -18,9 +18,11 @@ class Topic < ApplicationRecord
     scope :without_assigned_projects, -> { where(total_projects_count: 0) }
     scope :order_by_non_private_projects_count, -> { order(non_private_projects_count: :desc).order(id: :asc) }
     scope :reorder_by_similarity, -> (search) do
-      order_expression = Gitlab::Database::SimilarityScore.build_expression(search: search, rules: [
-        { column: arel_table['name'] }
-      ])
+      order_expression = Gitlab::Database::SimilarityScore.build_expression(
+        search: search,
+        rules: [
+          { column: arel_table['name'] }
+        ])
       reorder(order_expression.desc, arel_table['non_private_projects_count'].desc, arel_table['id'])
     end
 

app/models/todo.rb

@@ -96,10 +96,11 @@ class << self
     def for_group_ids_and_descendants(group_ids)
       groups = Group.groups_including_descendants_by(group_ids)
 
-      from_union([
-        for_project(Project.for_group(groups)),
-        for_group(groups)
-      ])
+      from_union(
+        [
+          for_project(Project.for_group(groups)),
+          for_group(groups)
+        ])
     end
 
     # Returns `true` if the current user has any todos for the given target with the optional given state.

app/models/user.rb

@@ -696,28 +696,29 @@ def search(query, **options)
       scope = options[:with_private_emails] ? with_primary_or_secondary_email(query) : with_public_email(query)
       scope = scope.or(search_by_name_or_username(query, use_minimum_char_limit: options[:use_minimum_char_limit]))
 
-      order = Gitlab::Pagination::Keyset::Order.build([
-        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-          attribute_name: 'users_match_priority',
-          order_expression: sanitized_order_sql.asc,
-          add_to_projections: true,
-          distinct: false
-        ),
-        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-          attribute_name: 'users_name',
-          order_expression: arel_table[:name].asc,
-          add_to_projections: true,
-          nullable: :not_nullable,
-          distinct: false
-        ),
-        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
-          attribute_name: 'users_id',
-          order_expression: arel_table[:id].asc,
-          add_to_projections: true,
-          nullable: :not_nullable,
-          distinct: true
-        )
-      ])
+      order = Gitlab::Pagination::Keyset::Order.build(
+        [
+          Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+            attribute_name: 'users_match_priority',
+            order_expression: sanitized_order_sql.asc,
+            add_to_projections: true,
+            distinct: false
+          ),
+          Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+            attribute_name: 'users_name',
+            order_expression: arel_table[:name].asc,
+            add_to_projections: true,
+            nullable: :not_nullable,
+            distinct: false
+          ),
+          Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
+            attribute_name: 'users_id',
+            order_expression: arel_table[:id].asc,
+            add_to_projections: true,
+            nullable: :not_nullable,
+            distinct: true
+          )
+        ])
       scope.reorder(order)
     end
 
@@ -1357,10 +1358,11 @@ def credit_card_validated_at
   end
 
   def accessible_deploy_keys
-    DeployKey.from_union([
-      DeployKey.where(id: project_deploy_keys.select(:deploy_key_id)),
-      DeployKey.are_public
-    ])
+    DeployKey.from_union(
+      [
+        DeployKey.where(id: project_deploy_keys.select(:deploy_key_id)),
+        DeployKey.are_public
+      ])
   end
 
   def created_by
@@ -1661,10 +1663,11 @@ def forkable_namespaces
     strong_memoize(:forkable_namespaces) do
       personal_namespace = Namespace.where(id: namespace_id)
 
-      Namespace.from_union([
-        manageable_groups(include_groups_with_developer_maintainer_access: true),
-        personal_namespace
-      ])
+      Namespace.from_union(
+        [
+          manageable_groups(include_groups_with_developer_maintainer_access: true),
+          personal_namespace
+        ])
     end
   end
 
@@ -2243,10 +2246,11 @@ def namespace_callouts_by_feature_name
   end
 
   def authorized_groups_without_shared_membership
-    Group.from_union([
-      groups.select(*Namespace.cached_column_list),
-      authorized_projects.joins(:namespace).select(*Namespace.cached_column_list)
-    ])
+    Group.from_union(
+      [
+        groups.select(*Namespace.cached_column_list),
+        authorized_projects.joins(:namespace).select(*Namespace.cached_column_list)
+      ])
   end
 
   def authorized_groups_with_shared_membership
@@ -2256,10 +2260,10 @@ def authorized_groups_with_shared_membership
     Group
       .with(cte.to_arel)
       .from_union([
-        Group.from(cte_alias),
-        Group.joins(:shared_with_group_links)
-             .where(group_group_links: { shared_with_group_id: Group.from(cte_alias) })
-    ])
+                    Group.from(cte_alias),
+                    Group.joins(:shared_with_group_links)
+                         .where(group_group_links: { shared_with_group_id: Group.from(cte_alias) })
+                  ])
   end
 
   def default_private_profile_to_false

app/models/users/credit_card_validation.rb

@@ -23,7 +23,9 @@ def similar_records
     end
 
     def similar_holder_names_count
-      self.class.where('lower(holder_name) = :value', value: holder_name.downcase).count
+      return 0 unless holder_name
+
+      self.class.where('lower(holder_name) = lower(:value)', value: holder_name).count
     end
   end
 end

app/models/wiki.rb

@@ -103,6 +103,17 @@ def for_container(container, user = nil)
     def find_by_id(container_id)
       container_class.find_by_id(container_id)&.wiki
     end
+
+    def sluggified_full_path(title, extension)
+      sluggified_title(title) + '.' + extension
+    end
+
+    def sluggified_title(title)
+      title = Gitlab::EncodingHelper.encode_utf8_no_detect(title)
+      title = File.expand_path(title, '/')
+      title = Pathname.new(title).relative_path_from('/').to_s
+      title.tr(' ', '-')
+    end
   end
 
   def initialize(container, user = nil)
@@ -206,10 +217,11 @@ def sidebar_entries(limit: Gitlab::WikiPages::MAX_SIDEBAR_PAGES, **options)
   #
   # Returns an initialized WikiPage instance or nil
   def find_page(title, version = nil, load_content: true)
-    page_title, page_dir = page_title_and_dir(title)
-
-    if page = wiki.page(title: page_title, version: version, dir: page_dir, load_content: load_content)
-      WikiPage.new(self, page)
+    if find_page_with_repository_rpcs?
+      create_wiki_repository unless repository_exists?
+      find_page_with_repository_rpcs(title, version, load_content: load_content)
+    else
+      find_page_with_legacy_wiki_service(title, version, load_content: load_content)
     end
   end
 
@@ -419,19 +431,83 @@ def raise_duplicate_page_error!
   end
 
   def sluggified_full_path(title, extension)
-    sluggified_title(title) + '.' + extension
+    self.class.sluggified_full_path(title, extension)
   end
 
   def sluggified_title(title)
-    utf8_encoded_title = Gitlab::EncodingHelper.encode_utf8_no_detect(title)
+    self.class.sluggified_title(title)
+  end
 
-    sanitized_title(utf8_encoded_title).tr(' ', '-')
+  def canonicalize_filename(filename)
+    Gitlab::Git::Wiki::GollumSlug.canonicalize_filename(filename)
   end
 
-  def sanitized_title(title)
-    clean_absolute_path = File.expand_path(title, '/')
+  def find_page_with_legacy_wiki_service(title, version, load_content: false)
+    page_title, page_dir = page_title_and_dir(title)
+
+    if page = wiki.page(title: page_title, version: version, dir: page_dir, load_content: load_content)
+      WikiPage.new(self, page)
+    end
+  end
+
+  def find_matched_file(title, version)
+    escaped_path = RE2::Regexp.escape(sluggified_title(title))
+    # We could not use ALLOWED_EXTENSIONS_REGEX constant or similar regexp with
+    # Regexp.union. The result combination complicated modifiers:
+    # /(?i-mx:md|mkdn?|mdown|markdown)|(?i-mx:rdoc).../
+    # Regexp used by Gitaly is Go's Regexp package. It does not support those
+    # features. So, we have to compose another more-friendly regexp to pass to
+    # Gitaly side.
+    extension_regexp = Wiki::MARKUPS.map { |_, format| format[:extension_regex].source }.join("|")
+    path_regexp = Gitlab::EncodingHelper.encode_utf8_no_detect("(?i)^#{escaped_path}\\.(#{extension_regexp})$")
+
+    matched_files = repository.search_files_by_regexp(path_regexp, version)
+    return if matched_files.blank?
+
+    Gitlab::EncodingHelper.encode_utf8_no_detect(matched_files.first)
+  end
+
+  def find_page_format(path)
+    ext = File.extname(path).downcase[1..]
+    MARKUPS.find { |_, markup| markup[:extension_regex].match?(ext) }&.first
+  end
+
+  def check_page_historical(path, commit)
+    repository.last_commit_for_path('HEAD', path).id != commit.id
+  end
+
+  def find_page_with_repository_rpcs(title, version, load_content: true)
+    version = version.presence || 'HEAD'
+    path = find_matched_file(title, version)
+    return if path.blank?
+
+    blob_options = load_content ? {} : { limit: 0 }
+    blob = repository.blob_at(version, path, **blob_options)
+    commit = repository.commit(blob.commit_id)
+    format = find_page_format(path)
+
+    page = Gitlab::Git::WikiPage.new(
+      url_path: sluggified_title(path.sub(/\.[^.]+\z/, "")),
+      title: canonicalize_filename(path),
+      format: format,
+      path: sluggified_title(path),
+      raw_data: blob.data,
+      name: canonicalize_filename(path),
+      historical: version == 'HEAD' ? false : check_page_historical(path, commit),
+      version: Gitlab::Git::WikiPageVersion.new(commit, format)
+    )
+    WikiPage.new(self, page)
+  end
+
+  def find_page_with_repository_rpcs?
+    group =
+      if container.is_a?(::Group)
+        container
+      else
+        container.group
+      end
 
-    Pathname.new(clean_absolute_path).relative_path_from('/').to_s
+    Feature.enabled?(:wiki_find_page_with_normal_repository_rpcs, group, type: :development)
   end
 end
 

app/presenters/ci/pipeline_presenter.rb

@@ -49,7 +49,7 @@ def localized_names
       {
         merge_train: s_('Pipeline|Merge train pipeline'),
         merged_result: s_('Pipeline|Merged result pipeline'),
-        detached: s_('Pipeline|Detached merge request pipeline')
+        detached: s_('Pipeline|Merge request pipeline')
       }.freeze
     end
 

app/services/ci/create_downstream_pipeline_service.rb

@@ -137,7 +137,7 @@ def has_max_nested_children?
       return false unless @bridge.triggers_child_pipeline?
 
       # only applies to parent-child pipelines not multi-project
-      ancestors_of_new_child = @bridge.pipeline.self_and_ancestors
+      ancestors_of_new_child = @bridge.pipeline.self_and_project_ancestors
       ancestors_of_new_child.count > MAX_NESTED_CHILDREN
     end
 

app/services/ci/delete_objects_service.rb

@@ -27,9 +27,7 @@ def load_next_batch
       # `find_by_sql` performs a write in this case and we need to wrap it in
       # a transaction to stick to the primary database.
       Ci::DeletedObject.transaction do
-        Ci::DeletedObject.find_by_sql([
-          next_batch_sql, new_pick_up_at: RETRY_IN.from_now
-        ])
+        Ci::DeletedObject.find_by_sql([next_batch_sql, new_pick_up_at: RETRY_IN.from_now])
       end
     end
     # rubocop: enable CodeReuse/ActiveRecord

app/services/ci/expire_pipeline_cache_service.rb

@@ -86,7 +86,7 @@ def update_etag_cache(pipeline, store)
         etag_paths << path
       end
 
-      pipeline.all_pipelines_in_hierarchy.includes(project: [:route, { namespace: :route }]).each do |relative_pipeline| # rubocop: disable CodeReuse/ActiveRecord
+      pipeline.upstream_and_all_downstreams.includes(project: [:route, { namespace: :route }]).each do |relative_pipeline| # rubocop: disable CodeReuse/ActiveRecord
         etag_paths << project_pipeline_path(relative_pipeline.project, relative_pipeline)
         etag_paths << graphql_pipeline_path(relative_pipeline)
         etag_paths << graphql_pipeline_sha_path(relative_pipeline.sha)

app/services/ci/generate_coverage_reports_service.rb

@@ -43,7 +43,7 @@ def key(base_pipeline, head_pipeline)
     end
 
     def last_update_timestamp(pipeline_hierarchy)
-      pipeline_hierarchy&.self_and_descendants&.maximum(:updated_at)
+      pipeline_hierarchy&.self_and_project_descendants&.maximum(:updated_at)
     end
   end
 end

app/services/concerns/ci/downstream_pipeline_helpers.rb

@@ -5,7 +5,7 @@ module DownstreamPipelineHelpers
     def log_downstream_pipeline_creation(downstream_pipeline)
       return unless downstream_pipeline&.persisted?
 
-      hierarchy_size = downstream_pipeline.all_pipelines_in_hierarchy.count
+      hierarchy_size = downstream_pipeline.upstream_and_all_downstreams.count
       root_pipeline = downstream_pipeline.upstream_root
 
       ::Gitlab::AppLogger.info(

app/services/groups/create_service.rb

@@ -39,7 +39,7 @@ def execute
         if @group.save
           @group.add_owner(current_user)
           Integration.create_from_active_default_integrations(@group, :group_id)
-          OnboardingProgress.onboard(@group)
+          Onboarding::Progress.onboard(@group)
         end
       end
 

app/services/labels/transfer_service.rb

@@ -40,9 +40,9 @@ def execute
     def labels_to_transfer
       Label
         .from_union([
-          group_labels_applied_to_issues,
-          group_labels_applied_to_merge_requests
-        ])
+                      group_labels_applied_to_issues,
+                      group_labels_applied_to_merge_requests
+                    ])
         .reorder(nil)
         .distinct
     end

app/services/merge_requests/merge_service.rb

@@ -92,15 +92,16 @@ def commit
         raise_error(GENERIC_ERROR_MESSAGE)
       end
 
-      merge_request.update!(merge_commit_sha: commit_id)
+      data_to_update = { merge_commit_sha: commit_id }
+      data_to_update[:squash_commit_sha] = source if merge_request.squash_on_merge?
+
+      merge_request.update!(**data_to_update)
     ensure
       merge_request.update_and_mark_in_progress_merge_commit_sha(nil)
     end
 
     def try_merge
-      repository.merge(current_user, source, merge_request, commit_message).tap do
-        merge_request.update_column(:squash_commit_sha, source) if merge_request.squash_on_merge?
-      end
+      repository.merge(current_user, source, merge_request, commit_message)
     rescue Gitlab::Git::PreReceiveError => e
       raise MergeError,
             "Something went wrong during merge pre-receive hook. #{e.message}".strip

app/services/milestones/transfer_service.rb

@@ -35,10 +35,7 @@ def execute
 
     # rubocop: disable CodeReuse/ActiveRecord
     def milestones_to_transfer
-      Milestone.from_union([
-          group_milestones_applied_to_issues,
-          group_milestones_applied_to_merge_requests
-        ])
+      Milestone.from_union([group_milestones_applied_to_issues, group_milestones_applied_to_merge_requests])
         .reorder(nil)
         .distinct
     end

app/services/namespaces/in_product_marketing_emails_service.rb

@@ -89,7 +89,7 @@ def send_email_for_group(group)
     end
 
     def groups_for_track
-      onboarding_progress_scope = OnboardingProgress
+      onboarding_progress_scope = Onboarding::Progress
         .completed_actions_with_latest_in_range(completed_actions, range)
         .incomplete_actions(incomplete_actions)
 

app/services/onboarding_progress_service.rb

@@ -9,7 +9,7 @@ def initialize(namespace_id)
     end
 
     def execute(action:)
-      return unless OnboardingProgress.not_completed?(namespace_id, action)
+      return unless Onboarding::Progress.not_completed?(namespace_id, action)
 
       Namespaces::OnboardingProgressWorker.perform_async(namespace_id, action)
     end
@@ -26,6 +26,6 @@ def initialize(namespace)
   def execute(action:)
     return unless @namespace
 
-    OnboardingProgress.register(@namespace, action)
+    Onboarding::Progress.register(@namespace, action)
   end
 end