Create GraphQL mutations for group and project transfers with async support. GitLab doesn't currently have GraphQL transfer mutations. **Implementation Details:** **Create `app/graphql/mutations/groups/transfer.rb`:** ```ruby # frozen_string_literal: true module Mutations module Groups class Transfer < BaseMutation graphql_name 'GroupTransfer' authorize :admin_group argument :id, ::Types::GlobalIDType[::Group], required: true, description: 'Global ID of the group to transfer.' argument :target_id, ::Types::GlobalIDType[::Group], required: false, description: 'Global ID of the target parent group. Omit to make group top-level.' field :group, Types::GroupType, null: true, description: 'Group after mutation.' field :async, GraphQL::Types::Boolean, null: false, description: 'Whether transfer was queued asynchronously.' def resolve(id:, target_id: nil) group = authorized_find!(id) target_group = target_id ? find_object(target_id) : nil if Feature.enabled?(:groups_and_projects_async_transfer, group) # Async transfer group.transfer_target_parent_id = target_group&.id group.save! if group.start_transfer Groups::TransferWorker.perform_async( group.id, target_group&.id, current_user.id ) { group: group, async: true, errors: [] } else { group: nil, async: false, errors: group.errors.full_messages } end else # Sync transfer service = ::Groups::TransferService.new(group, current_user) if service.execute(target_group) { group: group, async: false, errors: [] } else { group: nil, async: false, errors: [service.error] } end end end private def find_object(id) GitlabSchema.find_by_gid(id) end end end end ``` **Create `app/graphql/mutations/projects/transfer.rb`:** ```ruby # frozen_string_literal: true module Mutations module Projects class Transfer < BaseMutation graphql_name 'ProjectTransfer' authorize :change_namespace argument :id, ::Types::GlobalIDType[::Project], required: true, description: 'Global ID of the project to transfer.' argument :namespace_id, ::Types::GlobalIDType[::Namespace], required: true, description: 'Global ID of the target namespace.' field :project, Types::ProjectType, null: true, description: 'Project after mutation.' field :async, GraphQL::Types::Boolean, null: false, description: 'Whether transfer was queued asynchronously.' def resolve(id:, namespace_id:) project = authorized_find!(id) namespace = find_object(namespace_id) unless namespace.is_a?(Namespace) return { project: nil, async: false, errors: ['Invalid namespace'] } end if Feature.enabled?(:groups_and_projects_async_transfer, project) # Async transfer project.project_namespace.transfer_target_parent_id = namespace.id project.project_namespace.save! if project.project_namespace.start_transfer Projects::TransferWorker.perform_async( project.id, namespace.id, current_user.id ) { project: project, async: true, errors: [] } else { project: nil, async: false, errors: project.project_namespace.errors.full_messages } end else # Sync transfer service = ::Projects::TransferService.new(project, current_user) if service.execute(namespace) { project: project, async: false, errors: [] } else { project: nil, async: false, errors: project.errors[:new_namespace] || ['Transfer failed'] } end end end private def find_object(id) GitlabSchema.find_by_gid(id) end end end end ``` **Register mutations in `app/graphql/types/mutation_type.rb`:** ```ruby mount_mutation Mutations::Groups::Transfer mount_mutation Mutations::Projects::Transfer ``` **Add transfer status fields to types:** **Update `app/graphql/types/group_type.rb`:** ```ruby field :transfer_in_progress, GraphQL::Types::Boolean, null: false, description: 'Whether the group is currently being transferred.', method: :transfer_in_progress? ``` **Update `app/graphql/types/project_type.rb`:** ```ruby field :transfer_in_progress, GraphQL::Types::Boolean, null: false, description: 'Whether the project is currently being transferred.', resolver_method: :project_transfer_in_progress? def project_transfer_in_progress? object.project_namespace&.transfer_in_progress? end ```