Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

36.3 KB
Raw Blame
import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { beforeUnload } from 'kea-router'

import { lemonToast } from '@posthog/lemon-ui'

import api from 'lib/api'
import { ApiError, isApprovalRequiredError } from 'lib/api-error'
import { PromiseTimeoutError, withTimeout } from 'lib/utils/async'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
import { pluralize } from 'lib/utils/strings'
import { dispatchChangeRequestCreated } from 'scenes/approvals/utils'
import { organizationLogic } from 'scenes/organizationLogic'
import { projectLogic } from 'scenes/projectLogic'

import { RESTORE_UNAVAILABLE_DISABLED_REASON } from 'products/feature_flags/frontend/featureFlagConfigFormat'
import { featureFlagsPartialUpdate } from 'products/feature_flags/frontend/generated/api'
import type { CopyFlagsResponseApi } from 'products/feature_flags/frontend/generated/api.schemas'

import type { OrganizationType, TeamBasicType } from '../../types'
import { featureFlagsLogic } from './featureFlagsLogic'

export type FlagRolloutState = 'fully_rolled_out' | 'not_rolled_out' | 'partial'

export interface DeletedFlagInfo {
    id: number
    key: string
    rollout_state: FlagRolloutState
    active_variant: string | null
}

export interface BulkDeleteResult {
    deleted: DeletedFlagInfo[]
    errors: Array<{ id: number; key?: string; reason: string }>
}

export interface BulkArchiveFailure {
    id: number
    errorMessage: string
    /** The flag wasn't archived because the change needs approval — a change request was created. */
    approvalPending: boolean
}

export interface BulkArchiveResult {
    archivedIds: number[]
    failed: BulkArchiveFailure[]
}

export interface BulkRestoreFailure {
    id: number
    key: string
    errorMessage: string
    /** False when the API won't restore this flag at all, so trying again fails the same way. */
    retryable: boolean
}

/**
 * Bulk archive issues one request per flag, so it's capped the same way bulk copy is rather than
 * letting a "select all matching" run fan out to thousands of sequential requests.
 */
export const BULK_ARCHIVE_MAX_FLAGS = 100

export const BULK_COPY_MAX_FLAGS = 100
// Mirrors MAX_COPY_FLAGS_TARGET_PROJECTS in
// products/feature_flags/backend/api/organization_feature_flag.py, which rejects more. Keep in sync.
export const BULK_COPY_MAX_TARGET_PROJECTS = 50

/**
 * Bulk restore waits for each request before it sends the next, and the dialog stays locked until the
 * last one returns. A request that stalls would keep it locked for good, so each one is cancelled after
 * this long and counts as a failure the person can retry.
 */
export const BULK_RESTORE_REQUEST_TIMEOUT_MS = 30_000

export interface BulkCopyParams {
    /** Project the flags are copied from. */
    sourceProjectId: number
    /** Selected flag IDs (overview tab) — resolved to keys via bulk_keys at submit time. */
    flagIds?: number[]
    /** Selected flag keys (projects grid) — used as-is. */
    flagKeys?: string[]
    /** Whether the modal lets the user change the source project (projects grid rows are org-level). */
    sourceSelectable?: boolean
}

export interface BulkCopyFailure {
    key: string
    projectId: number | null
    errorMessage: string
    /** The copy wasn't applied because the target project requires approval — a change request was created. */
    approvalPending?: boolean
}

export interface BulkCopyResult {
    copied: Array<{
        key: string
        projectIds: number[]
        /** Subset of projectIds where a flag with this key already existed and was overwritten. */
        updatedProjectIds: number[]
    }>
    failed: BulkCopyFailure[]
    warnings: string[]
    /** Selected flags that no longer resolved to a key (e.g. deleted between selection and submit). */
    skippedFlagCount: number
}

function summarizeBulkCopy(
    copied: BulkCopyResult['copied'],
    failed: BulkCopyFailure[],
    targetCount: number
): { level: 'success' | 'warning' | 'error'; message: string } {
    const pendingApprovalCount = failed.filter((failure) => failure.approvalPending).length
    const hardFailureCount = failed.length - pendingApprovalCount
    const updatedPairCount = copied.reduce((count, entry) => count + entry.updatedProjectIds.length, 0)
    // Omit the "Copied N flags" clause entirely when nothing copied, rather than showing a
    // contradictory "Copied 0 flags ... pending approval" message.
    const summary =
        copied.length > 0
            ? `Copied ${pluralize(copied.length, 'flag')} to ${pluralize(targetCount, 'project')}` +
              (updatedPairCount > 0 ? ` (${pluralize(updatedPairCount, 'existing flag')} overwritten)` : '')
            : null
    if (failed.length === 0 && copied.length > 0) {
        return { level: 'success', message: summary as string }
    }
    if (copied.length > 0 || pendingApprovalCount > 0) {
        const parts = [
            summary,
            pendingApprovalCount > 0 ? `${pluralize(pendingApprovalCount, 'copy', 'copies')} pending approval` : null,
            hardFailureCount > 0 ? `${pluralize(hardFailureCount, 'copy', 'copies')} failed` : null,
        ].filter((part): part is string => part !== null)
        return {
            level: 'warning',
            message: parts.join(', '),
        }
    }
    return { level: 'error', message: 'No flags were copied' }
}

function summarizeBulkArchive(
    archivedCount: number,
    failed: BulkArchiveFailure[]
): { level: 'success' | 'warning' | 'error'; message: string } {
    const pendingApprovalCount = failed.filter((failure) => failure.approvalPending).length
    const hardFailureCount = failed.length - pendingApprovalCount
    if (failed.length === 0) {
        return { level: 'success', message: `Archived ${pluralize(archivedCount, 'flag')}` }
    }
    if (archivedCount > 0 || pendingApprovalCount > 0) {
        const parts = [
            archivedCount > 0 ? `Archived ${pluralize(archivedCount, 'flag')}` : null,
            pendingApprovalCount > 0 ? `${pluralize(pendingApprovalCount, 'flag')} pending approval` : null,
            hardFailureCount > 0 ? `${pluralize(hardFailureCount, 'flag')} failed` : null,
        ].filter((part): part is string => part !== null)
        return { level: 'warning', message: parts.join(', ') }
    }
    return { level: 'error', message: 'No flags were archived' }
}

function summarizeBulkRestore(
    restoredCount: number,
    failedCount: number
): { level: 'success' | 'warning' | 'error'; message: string } {
    if (failedCount === 0) {
        return { level: 'success', message: `Restored ${pluralize(restoredCount, 'flag')}` }
    }
    if (restoredCount > 0) {
        return {
            level: 'warning',
            message: `Restored ${pluralize(restoredCount, 'flag')}, ${pluralize(failedCount, 'flag')} failed`,
        }
    }
    return { level: 'error', message: 'No flags were restored' }
}

// The API refuses to restore a flag on config version 2.
function isUnsupportedConfigVersion(error: unknown): boolean {
    return error instanceof ApiError && error.code === 'unsupported_config_version'
}

function restoreErrorMessage(error: unknown): string {
    if (error instanceof PromiseTimeoutError) {
        return 'The request timed out. Try again.'
    }
    // Say why a version 2 flag can't be restored in the words the flag page uses.
    return isUnsupportedConfigVersion(error) ? RESTORE_UNAVAILABLE_DISABLED_REASON : errorMessageFrom(error)
}

export function errorMessageFrom(error: unknown): string {
    if (typeof error === 'string') {
        return error
    }
    if (error instanceof ApiError) {
        return error.detail ?? error.message
    }
    return 'Request failed'
}

/** Turns one key's copy response into the copied/failed/warning entries the bulk-copy listener accumulates. */
export function aggregateCopyResponse(
    key: string,
    targetProjectIds: number[],
    response: CopyFlagsResponseApi
): { copied: BulkCopyResult['copied'][number] | null; failed: BulkCopyFailure[]; warnings: string[] } {
    // Copied targets are inferred as requested-minus-failed (robust to success items
    // missing team_id during deploy skew); overwrites come from the per-item flag.
    const failedProjectIds = new Set(
        response.failed.map((entry) => entry.project_id).filter((id): id is number => id != null)
    )
    const copiedProjectIds = targetProjectIds.filter((id) => !failedProjectIds.has(id))
    const updatedProjectIds = response.success
        .filter((item) => item.updated_existing && item.team_id != null)
        .map((item) => item.team_id)
    const failed: BulkCopyFailure[] = response.failed.map((entry) => ({
        key,
        projectId: entry.project_id ?? null,
        errorMessage: errorMessageFrom(entry.error_message || 'Copy failed'),
        approvalPending: entry.approval_pending,
    }))
    const warnings: string[] = []
    for (const successItem of response.success) {
        for (const warning of successItem.flag_dependency_warnings ?? []) {
            warnings.push(`${key}: ${warning}`)
        }
        if (successItem.schedule_copy_warning) {
            warnings.push(`${key}: ${successItem.schedule_copy_warning}`)
        }
    }
    return {
        copied: copiedProjectIds.length > 0 ? { key, projectIds: copiedProjectIds, updatedProjectIds } : null,
        failed,
        warnings,
    }
}

/** Splits each copied entry's projectIds into freshly created flags vs. overwrites of flags that already existed in the target. */
export function splitCopiedByOverwrite(copied: BulkCopyResult['copied']): {
    newCopies: Array<{ key: string; projectIds: number[] }>
    overwrites: Array<{ key: string; projectIds: number[] }>
} {
    const newCopies = copied
        .map((entry) => ({
            key: entry.key,
            projectIds: entry.projectIds.filter((id) => !entry.updatedProjectIds.includes(id)),
        }))
        .filter((entry) => entry.projectIds.length > 0)
    const overwrites = copied
        .map((entry) => ({ key: entry.key, projectIds: entry.updatedProjectIds }))
        .filter((entry) => entry.projectIds.length > 0)
    return { newCopies, overwrites }
}

export interface ProjectSelectOption {
    key: string
    label: string
    value: number
}

/** Copy-destination options for a project picker: the org's teams minus one excluded project, sorted by name. */
export function projectSelectOptions(
    teams: TeamBasicType[] | null | undefined,
    excludeProjectId: number | null
): ProjectSelectOption[] {
    return (teams ?? [])
        .filter((team) => team.id !== excludeProjectId)
        .map((team) => ({ key: String(team.id), label: team.name, value: team.id }))
        .sort((a, b) => a.label.localeCompare(b.label))
}

export function getBulkCopyDisabledReason(selectedCount: number, extraReason?: string | null): string | undefined {
    if (extraReason) {
        return extraReason
    }
    if (selectedCount > BULK_COPY_MAX_FLAGS) {
        return `Bulk copy supports up to ${BULK_COPY_MAX_FLAGS} flags at once`
    }
    return undefined
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagSelectionLogicValues {
    paramsFromFilters: {
        active?: string | undefined
        archived?: string | undefined
        created_by_id?: number[] | undefined
        deleted?: string | undefined
        evaluation_runtime?: string | undefined
        excluded_tags?: string[] | undefined
        limit: number
        offset: number
        order?: string | undefined
        page?: number | undefined
        search?: string | undefined
        tags?: string[] | undefined
        type?: string | undefined
    } // featureFlagsLogic
    currentOrganization: OrganizationType | null // organizationLogic
    currentProjectId: number | null // projectLogic
    bulkArchiveProgress: {
        done: number
        total: number
    } | null
    bulkArchiveResult: BulkArchiveResult | null
    bulkArchiveRunning: boolean
    bulkCopyDisableCopiedFlag: boolean
    bulkCopyFlagCount: number
    bulkCopyHardFailures: BulkCopyFailure[]
    bulkCopyModalVisible: boolean
    bulkCopyParams: BulkCopyParams | null
    bulkCopyPendingApproval: BulkCopyFailure[]
    bulkCopyProgress: {
        done: number
        total: number
    } | null
    bulkCopyResult: BulkCopyResult | null
    bulkCopyRunning: boolean
    bulkCopySchedule: boolean
    bulkCopySourceProjectId: number | null
    bulkCopySplitCopied: {
        newCopies: {
            key: string
            projectIds: number[]
        }[]
        overwrites: {
            key: string
            projectIds: number[]
        }[]
    }
    bulkCopySubmitDisabledReason: string | undefined
    bulkCopyTargetProjectIds: number[]
    bulkDeleteResponse: BulkDeleteResult | null
    bulkDeleteResponseLoading: boolean
    bulkDeleteResult: BulkDeleteResult | null
    bulkRestoreFailures: BulkRestoreFailure[]
    bulkRestoreProgress: {
        done: number
        total: number
    } | null
    bulkRestoreRunning: boolean
    bulkRestoredIds: number[]
    restorableFlags: DeletedFlagInfo[]
    resultsModalVisible: boolean
    stillDeletedFlags: DeletedFlagInfo[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagSelectionLogicActions {
    reportFeatureFlagBulkCopy: (
        flagCount: number,
        projectCount: number,
        failedCount: number
    ) => {
        failedCount: number
        flagCount: number
        projectCount: number
    } // eventUsageLogic
    reportFeatureFlagsBulkArchived: (
        archivedCount: number,
        pendingApprovalCount: number,
        failedCount: number
    ) => {
        archivedCount: number
        failedCount: number
        pendingApprovalCount: number
    } // eventUsageLogic
    reportFeatureFlagsBulkRestored: (
        restoredCount: number,
        failedCount: number
    ) => {
        failedCount: number
        restoredCount: number
    } // eventUsageLogic
    loadFeatureFlags: (_?: void | undefined) => void // featureFlagsLogic
    bulkArchiveFlags: (ids: number[]) => {
        ids: number[]
    }
    bulkArchiveFlagsFinished: (result: BulkArchiveResult | null) => {
        result: BulkArchiveResult | null
    }
    bulkCopyFlags: () => {
        value: true
    }
    bulkCopyFlagsFinished: (result: BulkCopyResult | null) => {
        result: BulkCopyResult | null
    }
    bulkDeleteFlags: ({ ids, allMatching }: { allMatching: boolean; ids: number[] }) => {
        ids: number[]
        allMatching: boolean
    }
    bulkDeleteFlagsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    bulkDeleteFlagsSuccess: (
        bulkDeleteResponse: BulkDeleteResult,
        payload?: {
            ids: number[]
            allMatching: boolean
        }
    ) => {
        bulkDeleteResponse: BulkDeleteResult
        payload?: {
            ids: number[]
            allMatching: boolean
        }
    }
    bulkRestoreFlagSucceeded: (id: number) => {
        id: number
    }
    bulkRestoreFlags: (flags: DeletedFlagInfo[]) => {
        flags: DeletedFlagInfo[]
    }
    bulkRestoreFlagsFinished: (failed: BulkRestoreFailure[]) => {
        failed: BulkRestoreFailure[]
    }
    closeBulkCopyModal: () => {
        value: true
    }
    hideResultsModal: () => {
        value: true
    }
    openBulkCopyModal: (params: BulkCopyParams) => {
        params: BulkCopyParams
    }
    setBulkArchiveProgress: (
        done: number,
        total: number
    ) => {
        done: number
        total: number
    }
    setBulkCopyDisableCopiedFlag: (disableCopiedFlag: boolean) => {
        disableCopiedFlag: boolean
    }
    setBulkCopyProgress: (
        done: number,
        total: number
    ) => {
        done: number
        total: number
    }
    setBulkCopySchedule: (copySchedule: boolean) => {
        copySchedule: boolean
    }
    setBulkCopySourceProjectId: (projectId: number) => {
        projectId: number
    }
    setBulkCopyTargetProjectIds: (projectIds: number[]) => {
        projectIds: number[]
    }
    setBulkRestoreProgress: (
        done: number,
        total: number
    ) => {
        done: number
        total: number
    }
    showResultsModal: (result: BulkDeleteResult) => {
        result: BulkDeleteResult
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagSelectionLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        resultsModalVisible: (bulkDeleteResult: BulkDeleteResult | null) => boolean
        bulkCopyModalVisible: (bulkCopyParams: BulkCopyParams | null) => boolean
        bulkCopyFlagCount: (bulkCopyParams: BulkCopyParams | null) => number
        bulkCopySplitCopied: (bulkCopyResult: BulkCopyResult | null) => {
            newCopies: {
                key: string
                projectIds: number[]
            }[]
            overwrites: {
                key: string
                projectIds: number[]
            }[]
        }
        bulkCopyPendingApproval: (bulkCopyResult: BulkCopyResult | null) => BulkCopyFailure[]
        bulkCopyHardFailures: (bulkCopyResult: BulkCopyResult | null) => BulkCopyFailure[]
        bulkCopySubmitDisabledReason: (bulkCopyTargetProjectIds: number[]) => string | undefined
        stillDeletedFlags: (bulkDeleteResult: BulkDeleteResult | null, bulkRestoredIds: number[]) => DeletedFlagInfo[]
        restorableFlags: (
            stillDeletedFlags: DeletedFlagInfo[],
            bulkRestoreFailures: BulkRestoreFailure[]
        ) => DeletedFlagInfo[]
    }
}

export type flagSelectionLogicType = MakeLogicType<
    flagSelectionLogicValues,
    flagSelectionLogicActions,
    Record<string, any>,
    flagSelectionLogicMeta
>

export const flagSelectionLogic = kea<flagSelectionLogicType>([
    path(['scenes', 'feature-flags', 'flagSelectionLogic']),

    connect(() => ({
        values: [
            projectLogic,
            ['currentProjectId'],
            featureFlagsLogic({}),
            ['paramsFromFilters'],
            organizationLogic,
            ['currentOrganization'],
        ],
        actions: [
            featureFlagsLogic({}),
            ['loadFeatureFlags'],
            eventUsageLogic,
            ['reportFeatureFlagBulkCopy', 'reportFeatureFlagsBulkArchived', 'reportFeatureFlagsBulkRestored'],
        ],
    })),

    actions({
        showResultsModal: (result: BulkDeleteResult) => ({ result }),
        hideResultsModal: true,
        openBulkCopyModal: (params: BulkCopyParams) => ({ params }),
        closeBulkCopyModal: true,
        setBulkCopySourceProjectId: (projectId: number) => ({ projectId }),
        setBulkCopyTargetProjectIds: (projectIds: number[]) => ({ projectIds }),
        setBulkCopySchedule: (copySchedule: boolean) => ({ copySchedule }),
        setBulkCopyDisableCopiedFlag: (disableCopiedFlag: boolean) => ({ disableCopiedFlag }),
        setBulkCopyProgress: (done: number, total: number) => ({ done, total }),
        bulkCopyFlags: true,
        bulkCopyFlagsFinished: (result: BulkCopyResult | null) => ({ result }),
        setBulkArchiveProgress: (done: number, total: number) => ({ done, total }),
        bulkArchiveFlags: (ids: number[]) => ({ ids }),
        bulkArchiveFlagsFinished: (result: BulkArchiveResult | null) => ({ result }),
        setBulkRestoreProgress: (done: number, total: number) => ({ done, total }),
        bulkRestoreFlags: (flags: DeletedFlagInfo[]) => ({ flags }),
        bulkRestoreFlagSucceeded: (id: number) => ({ id }),
        bulkRestoreFlagsFinished: (failed: BulkRestoreFailure[]) => ({ failed }),
    }),

    reducers({
        bulkDeleteResult: [
            null as BulkDeleteResult | null,
            {
                showResultsModal: (_, { result }) => result,
                hideResultsModal: () => null,
            },
        ],
        bulkCopyParams: [
            null as BulkCopyParams | null,
            {
                openBulkCopyModal: (_, { params }) => params,
                closeBulkCopyModal: () => null,
            },
        ],
        bulkCopySourceProjectId: [
            null as number | null,
            {
                openBulkCopyModal: (_, { params }) => params.sourceProjectId,
                setBulkCopySourceProjectId: (_, { projectId }) => projectId,
            },
        ],
        bulkCopyTargetProjectIds: [
            [] as number[],
            {
                openBulkCopyModal: () => [],
                setBulkCopyTargetProjectIds: (_, { projectIds }) => projectIds,
                // A project can't be both source and destination of the same copy
                setBulkCopySourceProjectId: (state, { projectId }) => state.filter((id) => id !== projectId),
            },
        ],
        bulkCopySchedule: [
            false,
            {
                openBulkCopyModal: () => false,
                setBulkCopySchedule: (_, { copySchedule }) => copySchedule,
            },
        ],
        bulkCopyDisableCopiedFlag: [
            false,
            {
                openBulkCopyModal: () => false,
                setBulkCopyDisableCopiedFlag: (_, { disableCopiedFlag }) => disableCopiedFlag,
            },
        ],
        bulkCopyRunning: [
            false,
            {
                bulkCopyFlags: () => true,
                bulkCopyFlagsFinished: () => false,
            },
        ],
        bulkCopyProgress: [
            null as { done: number; total: number } | null,
            {
                openBulkCopyModal: () => null,
                setBulkCopyProgress: (_, { done, total }) => ({ done, total }),
            },
        ],
        bulkCopyResult: [
            null as BulkCopyResult | null,
            {
                openBulkCopyModal: () => null,
                bulkCopyFlagsFinished: (_, { result }) => result,
            },
        ],
        bulkArchiveRunning: [
            false,
            {
                bulkArchiveFlags: () => true,
                bulkArchiveFlagsFinished: () => false,
            },
        ],
        bulkArchiveProgress: [
            null as { done: number; total: number } | null,
            {
                bulkArchiveFlags: () => null,
                setBulkArchiveProgress: (_, { done, total }) => ({ done, total }),
            },
        ],
        bulkArchiveResult: [
            null as BulkArchiveResult | null,
            {
                bulkArchiveFlags: () => null,
                bulkArchiveFlagsFinished: (_, { result }) => result,
            },
        ],
        bulkRestoreRunning: [
            false,
            {
                bulkRestoreFlags: () => true,
                bulkRestoreFlagsFinished: () => false,
            },
        ],
        bulkRestoreProgress: [
            null as { done: number; total: number } | null,
            {
                bulkRestoreFlags: () => null,
                setBulkRestoreProgress: (_, { done, total }) => ({ done, total }),
            },
        ],
        bulkRestoreFailures: [
            [] as BulkRestoreFailure[],
            {
                showResultsModal: () => [],
                // A retry clears the failures of the flags it tries again. The flags it leaves out keep their
                // reason on show.
                bulkRestoreFlags: (state, { flags }) => {
                    const retriedIds = new Set(flags.map((flag) => flag.id))
                    return state.filter((failure) => !retriedIds.has(failure.id))
                },
                bulkRestoreFlagsFinished: (state, { failed }) => [...state, ...failed],
            },
        ],
        // Filled as each restore lands, not when the batch ends, because a restored flag is live again
        // and the cleanup prompt must stop asking to remove its code straight away.
        bulkRestoredIds: [
            [] as number[],
            {
                showResultsModal: () => [],
                bulkRestoreFlagSucceeded: (state, { id }) => [...state, id],
            },
        ],
    }),

    loaders(({ values }) => ({
        bulkDeleteResponse: [
            null as BulkDeleteResult | null,
            {
                bulkDeleteFlags: async ({ ids, allMatching }: { ids: number[]; allMatching: boolean }) => {
                    if (allMatching) {
                        const { limit, offset, ...filters } = values.paramsFromFilters
                        // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use featureFlagsBulkDeleteCreate() from 'products/feature_flags/frontend/generated/api' instead.
                        const response = await api.create(
                            `api/projects/${values.currentProjectId}/feature_flags/bulk_delete/`,
                            { filters }
                        )
                        return response as BulkDeleteResult
                    }
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use featureFlagsBulkDeleteCreate() from 'products/feature_flags/frontend/generated/api' instead.
                    const response = await api.create(
                        `api/projects/${values.currentProjectId}/feature_flags/bulk_delete/`,
                        { ids }
                    )
                    return response as BulkDeleteResult
                },
            },
        ],
    })),

    selectors({
        resultsModalVisible: [(s) => [s.bulkDeleteResult], (result: BulkDeleteResult | null) => result !== null],
        bulkCopyModalVisible: [(s) => [s.bulkCopyParams], (params: BulkCopyParams | null) => params !== null],
        bulkCopyFlagCount: [
            (s) => [s.bulkCopyParams],
            (params: BulkCopyParams | null): number => params?.flagKeys?.length ?? params?.flagIds?.length ?? 0,
        ],
        bulkCopySplitCopied: [
            (s) => [s.bulkCopyResult],
            (result: BulkCopyResult | null) => splitCopiedByOverwrite(result?.copied ?? []),
        ],
        bulkCopyPendingApproval: [
            (s) => [s.bulkCopyResult],
            (result: BulkCopyResult | null): BulkCopyFailure[] =>
                result?.failed.filter((failure) => failure.approvalPending) ?? [],
        ],
        bulkCopyHardFailures: [
            (s) => [s.bulkCopyResult],
            (result: BulkCopyResult | null): BulkCopyFailure[] =>
                result?.failed.filter((failure) => !failure.approvalPending) ?? [],
        ],
        bulkCopySubmitDisabledReason: [
            (s) => [s.bulkCopyTargetProjectIds],
            (targetProjectIds: number[]): string | undefined =>
                targetProjectIds.length === 0
                    ? 'Select at least one destination project'
                    : targetProjectIds.length > BULK_COPY_MAX_TARGET_PROJECTS
                      ? `Bulk copy supports up to ${BULK_COPY_MAX_TARGET_PROJECTS} destination projects at once`
                      : undefined,
        ],
        stillDeletedFlags: [
            (s) => [s.bulkDeleteResult, s.bulkRestoredIds],
            (bulkDeleteResult: BulkDeleteResult | null, bulkRestoredIds: number[]): DeletedFlagInfo[] => {
                const restoredIds = new Set(bulkRestoredIds)
                return bulkDeleteResult?.deleted.filter((flag) => !restoredIds.has(flag.id)) ?? []
            },
        ],
        // What the restore button offers: the flags still deleted, minus those the API already refused.
        restorableFlags: [
            (s) => [s.stillDeletedFlags, s.bulkRestoreFailures],
            (stillDeletedFlags: DeletedFlagInfo[], bulkRestoreFailures: BulkRestoreFailure[]): DeletedFlagInfo[] => {
                const refusedIds = new Set(
                    bulkRestoreFailures.filter((failure) => !failure.retryable).map((failure) => failure.id)
                )
                return stillDeletedFlags.filter((flag) => !refusedIds.has(flag.id))
            },
        ],
    }),

    listeners(({ actions, values }) => ({
        bulkDeleteFlagsSuccess: ({ bulkDeleteResponse }) => {
            if (bulkDeleteResponse) {
                actions.showResultsModal(bulkDeleteResponse)
                actions.loadFeatureFlags()
            }
        },
        bulkArchiveFlags: async ({ ids }) => {
            const projectId = values.currentProjectId
            if (!projectId || ids.length === 0) {
                actions.bulkArchiveFlagsFinished(null)
                return
            }
            if (ids.length > BULK_ARCHIVE_MAX_FLAGS) {
                lemonToast.error(`Bulk archive supports up to ${BULK_ARCHIVE_MAX_FLAGS} flags at once.`)
                actions.bulkArchiveFlagsFinished(null)
                return
            }

            const archivedIds: number[] = []
            const failed: BulkArchiveFailure[] = []

            actions.setBulkArchiveProgress(0, ids.length)
            // One request per flag through the regular update endpoint, on purpose: archiving disables
            // the flag, so each one has to pass the approval gate the same way a single archive does.
            // Sequential keeps the write load and the rollback ordering the same as archiving by hand.
            for (const [index, id] of ids.entries()) {
                try {
                    await featureFlagsPartialUpdate(String(projectId), id, { archived: true, active: false })
                    archivedIds.push(id)
                } catch (error: any) {
                    const approvalPending = isApprovalRequiredError(error)
                    if (approvalPending) {
                        dispatchChangeRequestCreated({ resourceType: 'feature_flag', resourceId: id })
                    }
                    failed.push({ id, errorMessage: errorMessageFrom(error), approvalPending })
                }
                actions.setBulkArchiveProgress(index + 1, ids.length)
            }

            actions.bulkArchiveFlagsFinished({ archivedIds, failed })
            actions.loadFeatureFlags()
            const pendingApprovalCount = failed.filter((failure) => failure.approvalPending).length
            actions.reportFeatureFlagsBulkArchived(
                archivedIds.length,
                pendingApprovalCount,
                failed.length - pendingApprovalCount
            )

            const { level, message } = summarizeBulkArchive(archivedIds.length, failed)
            lemonToast[level](message)
        },
        bulkRestoreFlags: async ({ flags }) => {
            const projectId = values.currentProjectId
            if (!projectId || flags.length === 0) {
                actions.bulkRestoreFlagsFinished([])
                return
            }

            let restoredCount = 0
            const failed: BulkRestoreFailure[] = []

            actions.setBulkRestoreProgress(0, flags.length)
            // One request per flag, like the flag page's restore but with no row version. Only a v2 flag sends a
            // row version there, and the API won't restore a v2 flag, so leaving it out here is safe. It undoes
            // a delete the person just made, so it covers every deleted flag rather than stopping at a cap.
            for (const [index, flag] of flags.entries()) {
                const url = `api/projects/${projectId}/feature_flags/${flag.id}`
                try {
                    await withTimeout(
                        // nosemgrep: prefer-codegen-api -- The generated partial update request type has no `deleted` field.
                        (signal) => api.update(url, { deleted: false }, { signal }),
                        BULK_RESTORE_REQUEST_TIMEOUT_MS
                    )
                    restoredCount += 1
                    actions.bulkRestoreFlagSucceeded(flag.id)
                } catch (error) {
                    failed.push({
                        id: flag.id,
                        key: flag.key,
                        errorMessage: restoreErrorMessage(error),
                        retryable: !isUnsupportedConfigVersion(error),
                    })
                }
                actions.setBulkRestoreProgress(index + 1, flags.length)
            }

            actions.bulkRestoreFlagsFinished(failed)
            actions.loadFeatureFlags()
            actions.reportFeatureFlagsBulkRestored(restoredCount, failed.length)
            // Keep the results open while any flag is still deleted, so the person can see which ones. That
            // includes a flag an earlier run found the API won't restore, which this run left out.
            if (values.stillDeletedFlags.length === 0) {
                actions.hideResultsModal()
            }

            const { level, message } = summarizeBulkRestore(restoredCount, failed.length)
            lemonToast[level](message)
        },
        bulkCopyFlags: async () => {
            const params = values.bulkCopyParams
            const sourceProjectId = values.bulkCopySourceProjectId
            const targetProjectIds = values.bulkCopyTargetProjectIds
            if (!params || !sourceProjectId || targetProjectIds.length === 0) {
                actions.bulkCopyFlagsFinished(null)
                return
            }

            let keys: string[] = []
            let skippedFlagCount = 0
            try {
                if (params.flagKeys?.length) {
                    keys = Array.from(new Set(params.flagKeys))
                } else if (params.flagIds?.length) {
                    const response = await api.featureFlags.bulkKeys(params.flagIds)
                    keys = Array.from(new Set(Object.values(response.keys)))
                    skippedFlagCount = params.flagIds.length - Object.keys(response.keys).length
                }
            } catch (error) {
                lemonToast.error(`Failed to resolve selected flags: ${errorMessageFrom(error)}`)
                actions.bulkCopyFlagsFinished(null)
                return
            }
            if (keys.length === 0) {
                lemonToast.error('None of the selected flags could be resolved — they may have been deleted.')
                actions.bulkCopyFlagsFinished(null)
                return
            }
            if (keys.length > BULK_COPY_MAX_FLAGS) {
                lemonToast.error(`Bulk copy supports up to ${BULK_COPY_MAX_FLAGS} flags at once.`)
                actions.bulkCopyFlagsFinished(null)
                return
            }

            const copied: BulkCopyResult['copied'] = []
            const failed: BulkCopyFailure[] = []
            const warnings = new Set<string>()

            actions.setBulkCopyProgress(0, keys.length)
            // Sequential on purpose: each call already fans out to every target project server-side
            // (and may create cohorts there), so parallel calls would multiply write load and risk
            // rate limiting without improving perceived progress.
            for (const [index, key] of keys.entries()) {
                try {
                    const response = await api.organizationFeatureFlags.copy(values.currentOrganization?.id, {
                        feature_flag_key: key,
                        from_project: sourceProjectId,
                        target_project_ids: targetProjectIds,
                        copy_schedule: values.bulkCopySchedule,
                        disable_copied_flag: values.bulkCopyDisableCopiedFlag,
                    })
                    const aggregated = aggregateCopyResponse(key, targetProjectIds, response)
                    if (aggregated.copied) {
                        copied.push(aggregated.copied)
                    }
                    failed.push(...aggregated.failed)
                    aggregated.warnings.forEach((warning) => warnings.add(warning))
                } catch (error) {
                    for (const projectId of targetProjectIds) {
                        failed.push({ key, projectId, errorMessage: errorMessageFrom(error) })
                    }
                }
                actions.setBulkCopyProgress(index + 1, keys.length)
            }

            actions.bulkCopyFlagsFinished({
                copied,
                failed,
                warnings: Array.from(warnings),
                skippedFlagCount,
            })
            actions.reportFeatureFlagBulkCopy(keys.length, targetProjectIds.length, failed.length)

            const { level, message } = summarizeBulkCopy(copied, failed, targetProjectIds.length)
            lemonToast[level](message)
        },
    })),

    beforeUnload(({ values }) => ({
        enabled: () =>
            values.bulkDeleteResponseLoading ||
            values.bulkCopyRunning ||
            values.bulkArchiveRunning ||
            values.bulkRestoreRunning,
        message: 'A bulk flag operation is in progress. Leaving may interrupt it.',
    })),
])