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.

feat(flags): undo a bulk delete from its results (#125724)

ruby childsd0e56bca09c6
diff --git a/frontend/src/lib/utils/eventUsageLogic.ts b/frontend/src/lib/utils/eventUsageLogic.ts
index 4d6363109613..25919d45c841 100644
--- a/frontend/src/lib/utils/eventUsageLogic.ts
+++ b/frontend/src/lib/utils/eventUsageLogic.ts
@@ -1101,6 +1101,13 @@ export interface eventUsageLogicActions {
failedCount: number
pendingApprovalCount: number
}
+ reportFeatureFlagsBulkRestored: (
+ restoredCount: number,
+ failedCount: number
+ ) => {
+ failedCount: number
+ restoredCount: number
+ }
reportFlagsCodeExampleInteraction: (optionType: string) => {
optionType: string
}
@@ -1736,6 +1743,10 @@ export const eventUsageLogic = kea<eventUsageLogicType>([
pendingApprovalCount,
failedCount,
}),
+ reportFeatureFlagsBulkRestored: (restoredCount: number, failedCount: number) => ({
+ restoredCount,
+ failedCount,
+ }),
reportInviteMembersButtonClicked: true,
reportAxisUnitsChanged: (properties: Record<string, any>) => ({ ...properties }),
reportFlagsCodeExampleInteraction: (optionType: string) => ({
@@ -2358,6 +2369,12 @@ export const eventUsageLogic = kea<eventUsageLogicType>([
failed_count: failedCount,
})
},
+ reportFeatureFlagsBulkRestored: ({ restoredCount, failedCount }) => {
+ posthog.capture('feature flags bulk restored', {
+ restored_count: restoredCount,
+ failed_count: failedCount,
+ })
+ },
reportInviteMembersButtonClicked: () => {
posthog.capture('invite members button clicked')
},
diff --git a/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.test.tsx b/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.test.tsx
new file mode 100644
index 000000000000..fb7cdcd2c273
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.test.tsx
@@ -0,0 +1,112 @@
+import '@testing-library/jest-dom'
+
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { Provider } from 'kea'
+import { expectLogic } from 'kea-test-utils'
+
+import { useMocks } from '~/mocks/jest'
+import { getByDataAttr, queryByDataAttr } from '~/test/byDataAttr'
+import { initKeaTests } from '~/test/init'
+
+import { BulkDeleteResultsModal } from './BulkDeleteResultsModal'
+import { DeletedFlagInfo, flagSelectionLogic } from './flagSelectionLogic'
+
+const deletedFlag = (id: number): DeletedFlagInfo => ({
+ id,
+ key: `flag-${id}`,
+ rollout_state: 'partial',
+ active_variant: null,
+})
+
+describe('BulkDeleteResultsModal', () => {
+ let logic: ReturnType<typeof flagSelectionLogic.build>
+
+ beforeEach(() => {
+ initKeaTests()
+ logic = flagSelectionLogic()
+ logic.mount()
+ })
+
+ afterEach(() => {
+ cleanup()
+ logic.unmount()
+ })
+
+ function renderModal(): void {
+ render(
+ <Provider>
+ <BulkDeleteResultsModal />
+ </Provider>
+ )
+ }
+
+ it('offers to restore every deleted flag', () => {
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+ renderModal()
+
+ expect(getByDataAttr(document.body, 'bulk-restore-deleted-flags')).toHaveTextContent('Restore 2 flags')
+ })
+
+ it('lists only the flags still deleted after a restore that partly failed, and offers to retry them', () => {
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+ logic.actions.bulkRestoreFlagSucceeded(1)
+ logic.actions.bulkRestoreFlagsFinished([
+ { id: 2, key: 'flag-2', errorMessage: 'Server error', retryable: true },
+ ])
+ renderModal()
+
+ expect(screen.getByText('Restored 1 flag')).toBeInTheDocument()
+ expect(screen.getByText('Failed to restore 1 flag')).toBeInTheDocument()
+ expect(screen.getByText('Deleted 1 flag')).toBeInTheDocument()
+ expect(screen.queryByText('flag-1')).not.toBeInTheDocument()
+
+ fireEvent.click(screen.getByText('Clean up code references with AI'))
+ const cleanupPrompt = screen.getByText(/Find and remove all references/).textContent
+ expect(cleanupPrompt).toContain('- flag-2')
+ expect(cleanupPrompt).not.toContain('flag-1')
+
+ expect(getByDataAttr(document.body, 'bulk-restore-deleted-flags')).toHaveTextContent('Restore 1 flag')
+ })
+
+ it('hides the restore button when only flags the API refused are left, and keeps their reason', () => {
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+ logic.actions.bulkRestoreFlagSucceeded(1)
+ logic.actions.bulkRestoreFlagsFinished([
+ { id: 2, key: 'flag-2', errorMessage: 'Restoring is not available for this flag yet.', retryable: false },
+ ])
+ renderModal()
+
+ expect(screen.getByText('Failed to restore 1 flag')).toBeInTheDocument()
+ expect(screen.getByText(/Restoring is not available for this flag yet\./)).toBeInTheDocument()
+ expect(screen.getByText('Deleted 1 flag')).toBeInTheDocument()
+ expect(queryByDataAttr(document.body, 'bulk-restore-deleted-flags')).not.toBeInTheDocument()
+ })
+
+ it('stays open until the restore finishes', async () => {
+ useMocks({
+ get: {
+ '/api/projects/:team/feature_flags/': { count: 0, results: [] },
+ },
+ patch: {
+ '/api/projects/:team/feature_flags/:id/': () => [500, { detail: 'Server error' }],
+ },
+ })
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1)], errors: [] })
+ renderModal()
+
+ fireEvent.click(getByDataAttr(document.body, 'bulk-restore-deleted-flags'))
+ expect(screen.queryByLabelText('close')).not.toBeInTheDocument()
+ fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape', code: 'Escape', keyCode: 27 })
+ expect(logic.values.resultsModalVisible).toBe(true)
+ fireEvent.click(screen.getByText('Done'))
+ expect(logic.values.resultsModalVisible).toBe(true)
+
+ // Once the restore fails, the results list it and close again.
+ await act(async () => {
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+ })
+ expect(screen.getByText('Failed to restore 1 flag')).toBeInTheDocument()
+ fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape', code: 'Escape', keyCode: 27 })
+ expect(logic.values.resultsModalVisible).toBe(false)
+ })
+})
diff --git a/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.tsx b/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.tsx
index a08a68f2b199..87e1837c4e03 100644
--- a/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.tsx
+++ b/frontend/src/scenes/feature-flags/BulkDeleteResultsModal.tsx
@@ -2,10 +2,11 @@ import { useActions, useValues } from 'kea'
import { useState } from 'react'
import { TextMorph } from 'torph/react'
-import { IconCheck, IconCopy, IconWarning, IconX } from '@posthog/icons'
+import { IconCheck, IconCopy, IconRewind, IconWarning, IconX } from '@posthog/icons'
import { LemonButton, LemonCollapse, LemonModal } from '@posthog/lemon-ui'
import { copyToClipboard } from 'lib/utils/copyToClipboard'
+import { pluralize } from 'lib/utils/strings'
import { DeletedFlagInfo, FlagRolloutState, flagSelectionLogic } from './flagSelectionLogic'
@@ -113,16 +114,25 @@ If there is an else branch, keep only the else body:
}
export function BulkDeleteResultsModal(): JSX.Element | null {
- const { bulkDeleteResult, resultsModalVisible } = useValues(flagSelectionLogic)
- const { hideResultsModal } = useActions(flagSelectionLogic)
+ const {
+ bulkDeleteResult,
+ resultsModalVisible,
+ stillDeletedFlags,
+ restorableFlags,
+ bulkRestoredIds,
+ bulkRestoreFailures,
+ bulkRestoreRunning,
+ bulkRestoreProgress,
+ } = useValues(flagSelectionLogic)
+ const { hideResultsModal, bulkRestoreFlags } = useActions(flagSelectionLogic)
const [copied, setCopied] = useState(false)
if (!bulkDeleteResult || !resultsModalVisible) {
return null
}
- const { deleted, errors } = bulkDeleteResult
- const cleanupPrompt = generateCleanupPrompt(deleted)
+ const { errors } = bulkDeleteResult
+ const cleanupPrompt = generateCleanupPrompt(stillDeletedFlags)
const handleCopyPrompt = async (): Promise<void> => {
await copyToClipboard(cleanupPrompt, 'cleanup prompt')
@@ -134,24 +144,70 @@ export function BulkDeleteResultsModal(): JSX.Element | null {
<LemonModal
isOpen={resultsModalVisible}
onClose={hideResultsModal}
+ // Closing clears the results, so a restore that then fails would have nowhere to list its flags.
+ closable={!bulkRestoreRunning}
title="Bulk deletion results"
width={600}
footer={
- <LemonButton type="primary" onClick={hideResultsModal}>
- Done
- </LemonButton>
+ <>
+ {restorableFlags.length > 0 && (
+ <LemonButton
+ type="secondary"
+ icon={<IconRewind />}
+ loading={bulkRestoreRunning}
+ onClick={() => bulkRestoreFlags(restorableFlags)}
+ data-attr="bulk-restore-deleted-flags"
+ >
+ {bulkRestoreRunning && bulkRestoreProgress
+ ? `Restoring ${bulkRestoreProgress.done} of ${bulkRestoreProgress.total}…`
+ : `Restore ${pluralize(restorableFlags.length, 'flag')}`}
+ </LemonButton>
+ )}
+ <LemonButton
+ type="primary"
+ onClick={hideResultsModal}
+ disabledReason={bulkRestoreRunning ? 'Wait for the restore to finish' : undefined}
+ >
+ Done
+ </LemonButton>
+ </>
}
>
<div className="space-y-4">
- {deleted.length > 0 && (
+ {(bulkRestoredIds.length > 0 || bulkRestoreFailures.length > 0) && (
+ <div className="space-y-2">
+ {bulkRestoredIds.length > 0 && (
+ <div className="flex items-center gap-2 text-success font-medium">
+ <IconRewind className="text-lg" />
+ <span>Restored {pluralize(bulkRestoredIds.length, 'flag')}</span>
+ </div>
+ )}
+ {bulkRestoreFailures.length > 0 && (
+ <>
+ <div className="flex items-center gap-2 text-danger font-medium">
+ <IconX className="text-lg" />
+ <span>Failed to restore {pluralize(bulkRestoreFailures.length, 'flag')}</span>
+ </div>
+ <ul className="list-none pl-6 space-y-1">
+ {bulkRestoreFailures.map((failure) => (
+ <li key={failure.id} className="text-sm">
+ <span className="text-muted">{failure.key}:</span>
+ <span className="text-muted-alt"> {failure.errorMessage}</span>
+ </li>
+ ))}
+ </ul>
+ </>
+ )}
+ </div>
+ )}
+
+ {stillDeletedFlags.length > 0 && (
<div className="space-y-2">
<div className="flex items-center gap-2 text-success font-medium">
<IconCheck className="text-lg" />
- <span>
- Deleted {deleted.length} flag{deleted.length !== 1 ? 's' : ''}
- </span>
+ <span>Deleted {pluralize(stillDeletedFlags.length, 'flag')}</span>
</div>
- <FlagResultsList flags={deleted} />
+ <FlagResultsList flags={stillDeletedFlags} />
</div>
)}
@@ -174,7 +230,7 @@ export function BulkDeleteResultsModal(): JSX.Element | null {
</div>
)}
- {deleted.length > 0 && (
+ {stillDeletedFlags.length > 0 && (
<LemonCollapse
panels={[
{
diff --git a/frontend/src/scenes/feature-flags/FeatureFlags.tsx b/frontend/src/scenes/feature-flags/FeatureFlags.tsx
index 75955e78755c..b41105e03cdf 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlags.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlags.tsx
@@ -879,7 +879,7 @@ export function OverviewTab({
icon={<IconTrash />}
loading={bulkDeleteResponseLoading}
onClick={() => {
- const description = `Are you sure you want to delete ${ctx.selectedCount} feature flag${ctx.selectedCount !== 1 ? 's' : ''}? This action cannot be undone.`
+ const description = `Are you sure you want to delete ${ctx.selectedCount} feature flag${ctx.selectedCount !== 1 ? 's' : ''}? You can restore most flags from the results that open next. Flags on the newer configuration format can't be restored yet.`
LemonDialog.open({
title: `Delete ${ctx.selectedCount} feature flag${ctx.selectedCount !== 1 ? 's' : ''}?`,
description,
diff --git a/frontend/src/scenes/feature-flags/flagSelectionLogic.bulkRestore.test.ts b/frontend/src/scenes/feature-flags/flagSelectionLogic.bulkRestore.test.ts
new file mode 100644
index 000000000000..960bc62b4300
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/flagSelectionLogic.bulkRestore.test.ts
@@ -0,0 +1,217 @@
+import { expectLogic } from 'kea-test-utils'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import { BULK_RESTORE_REQUEST_TIMEOUT_MS, DeletedFlagInfo, flagSelectionLogic } from './flagSelectionLogic'
+
+const deletedFlag = (id: number): DeletedFlagInfo => ({
+ id,
+ key: `flag-${id}`,
+ rollout_state: 'partial',
+ active_variant: null,
+})
+
+describe('flagSelectionLogic bulk restore', () => {
+ let logic: ReturnType<typeof flagSelectionLogic.build>
+ let restoreRequests: { id: number; body: Record<string, any> }[]
+
+ function useRestoreMocks(
+ restoreHandler: (id: number) => [number, any] | Promise<[number, any]> = () => [200, {}]
+ ): void {
+ restoreRequests = []
+ useMocks({
+ get: {
+ '/api/projects/:team/feature_flags/': { count: 0, results: [] },
+ },
+ patch: {
+ '/api/projects/:team/feature_flags/:id/': async ({ request, params }) => {
+ const id = Number(params.id)
+ restoreRequests.push({ id, body: (await request.json()) as Record<string, any> })
+ return restoreHandler(id)
+ },
+ },
+ })
+ }
+
+ beforeEach(() => {
+ initKeaTests()
+ })
+
+ afterEach(() => logic?.unmount())
+
+ it('restores every flag the bulk delete removed, then reloads the list and closes the results', async () => {
+ useRestoreMocks()
+ logic = flagSelectionLogic()
+ logic.mount()
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+
+ logic.actions.bulkRestoreFlags([deletedFlag(1), deletedFlag(2)])
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished', 'loadFeatureFlags', 'hideResultsModal'])
+
+ expect(restoreRequests).toEqual([
+ { id: 1, body: { deleted: false } },
+ { id: 2, body: { deleted: false } },
+ ])
+ expect(logic.values.bulkRestoredIds).toEqual([1, 2])
+ expect(logic.values.bulkRestoreFailures).toEqual([])
+ expect(logic.values.bulkRestoreProgress).toEqual({ done: 2, total: 2 })
+ expect(logic.values.bulkRestoreRunning).toBe(false)
+ expect(logic.values.resultsModalVisible).toBe(false)
+ })
+
+ it('keeps restoring after a failure and leaves the results open to show it', async () => {
+ useRestoreMocks((id) => {
+ if (id === 2) {
+ return [
+ 400,
+ {
+ type: 'validation_error',
+ code: 'unsupported_config_version',
+ detail: 'These fields cannot be updated on this flag: deleted.',
+ },
+ ]
+ }
+ return id === 4 ? [500, { detail: 'Server error' }] : [200, {}]
+ })
+ logic = flagSelectionLogic()
+ logic.mount()
+ const deleted = [deletedFlag(1), deletedFlag(2), deletedFlag(3), deletedFlag(4)]
+ logic.actions.showResultsModal({ deleted, errors: [] })
+
+ logic.actions.bulkRestoreFlags(deleted)
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished', 'loadFeatureFlags'])
+
+ expect(restoreRequests.map(({ id }) => id)).toEqual([1, 2, 3, 4])
+ // A version 2 flag can't be restored yet. The failure says so in the words the flag page uses.
+ expect(logic.values.bulkRestoredIds).toEqual([1, 3])
+ expect(logic.values.bulkRestoreFailures).toEqual([
+ { id: 2, key: 'flag-2', errorMessage: 'Restoring is not available for this flag yet.', retryable: false },
+ { id: 4, key: 'flag-4', errorMessage: 'Server error', retryable: true },
+ ])
+ expect(logic.values.resultsModalVisible).toBe(true)
+ })
+
+ it('leaves a flag the API refused out of the retry, and keeps its reason on show', async () => {
+ let secondFlagFails = true
+ useRestoreMocks((id) => {
+ if (id === 1) {
+ return [400, { type: 'validation_error', code: 'unsupported_config_version', detail: 'Not supported.' }]
+ }
+ return secondFlagFails ? [500, { detail: 'Server error' }] : [200, {}]
+ })
+ logic = flagSelectionLogic()
+ logic.mount()
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+
+ logic.actions.bulkRestoreFlags(logic.values.restorableFlags)
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+ // Trying flag 1 again would fail the same way, so the retry only offers flag 2.
+ expect(logic.values.restorableFlags).toEqual([deletedFlag(2)])
+
+ secondFlagFails = false
+ logic.actions.bulkRestoreFlags(logic.values.restorableFlags)
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+
+ expect(restoreRequests.map(({ id }) => id)).toEqual([1, 2, 2])
+ expect(logic.values.bulkRestoreFailures).toEqual([
+ { id: 1, key: 'flag-1', errorMessage: 'Restoring is not available for this flag yet.', retryable: false },
+ ])
+ expect(logic.values.stillDeletedFlags).toEqual([deletedFlag(1)])
+ expect(logic.values.restorableFlags).toEqual([])
+ // The retry had no failures of its own, but flag 1 is still deleted, so the results stay open.
+ expect(logic.values.resultsModalVisible).toBe(true)
+ })
+
+ it('drops each flag from the still deleted list as soon as it is restored', async () => {
+ let finishSecondRestore: () => void = () => {}
+ const secondRestore = new Promise<void>((resolve) => {
+ finishSecondRestore = resolve
+ })
+ useRestoreMocks(async (id) => {
+ if (id === 2) {
+ await secondRestore
+ }
+ return [200, {}]
+ })
+ logic = flagSelectionLogic()
+ logic.mount()
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+
+ logic.actions.bulkRestoreFlags([deletedFlag(1), deletedFlag(2)])
+ await expectLogic(logic).toDispatchActions([logic.actionCreators.bulkRestoreFlagSucceeded(1)])
+
+ expect(logic.values.bulkRestoreRunning).toBe(true)
+ expect(logic.values.stillDeletedFlags).toEqual([deletedFlag(2)])
+
+ finishSecondRestore()
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+ expect(logic.values.bulkRestoredIds).toEqual([1, 2])
+ })
+
+ it('retries only the flags a partly failed restore left deleted', async () => {
+ let secondFlagFails = true
+ useRestoreMocks((id) => (id === 2 && secondFlagFails ? [500, { detail: 'Server error' }] : [200, {}]))
+ logic = flagSelectionLogic()
+ logic.mount()
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+
+ logic.actions.bulkRestoreFlags(logic.values.stillDeletedFlags)
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+ expect(logic.values.stillDeletedFlags).toEqual([deletedFlag(2)])
+ expect(logic.values.bulkRestoreFailures).toEqual([
+ { id: 2, key: 'flag-2', errorMessage: 'Server error', retryable: true },
+ ])
+
+ secondFlagFails = false
+ logic.actions.bulkRestoreFlags(logic.values.stillDeletedFlags)
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished', 'hideResultsModal'])
+
+ expect(restoreRequests.map(({ id }) => id)).toEqual([1, 2, 2])
+ // The retry's success clears the first try's failure, and both restores still count.
+ expect(logic.values.bulkRestoredIds).toEqual([1, 2])
+ expect(logic.values.bulkRestoreFailures).toEqual([])
+ })
+
+ it('gives up on a restore that stalls, moves on, and leaves that flag to retry', async () => {
+ // A request that never answers used to hold the loop, so the dialog stayed locked for good.
+ useRestoreMocks((id) => (id === 1 ? new Promise<[number, any]>(() => {}) : [200, {}]))
+ logic = flagSelectionLogic()
+ logic.mount()
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1), deletedFlag(2)], errors: [] })
+
+ jest.useFakeTimers()
+ try {
+ logic.actions.bulkRestoreFlags([deletedFlag(1), deletedFlag(2)])
+ await jest.advanceTimersByTimeAsync(BULK_RESTORE_REQUEST_TIMEOUT_MS - 1)
+ expect(logic.values.bulkRestoreRunning).toBe(true)
+ await jest.advanceTimersByTimeAsync(1)
+ } finally {
+ jest.useRealTimers()
+ }
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+
+ expect(restoreRequests.map(({ id }) => id)).toEqual([1, 2])
+ expect(logic.values.bulkRestoreRunning).toBe(false)
+ expect(logic.values.bulkRestoreFailures).toEqual([
+ { id: 1, key: 'flag-1', errorMessage: 'The request timed out. Try again.', retryable: true },
+ ])
+ expect(logic.values.stillDeletedFlags).toEqual([deletedFlag(1)])
+ expect(logic.values.resultsModalVisible).toBe(true)
+ })
+
+ it('starts each bulk delete result without the last restore', async () => {
+ useRestoreMocks()
+ logic = flagSelectionLogic()
+ logic.mount()
+ logic.actions.showResultsModal({ deleted: [deletedFlag(1)], errors: [] })
+ logic.actions.bulkRestoreFlags([deletedFlag(1)])
+ await expectLogic(logic).toDispatchActions(['bulkRestoreFlagsFinished'])
+
+ logic.actions.showResultsModal({ deleted: [deletedFlag(4)], errors: [] })
+
+ expect(logic.values.bulkRestoreFailures).toEqual([])
+ expect(logic.values.bulkRestoredIds).toEqual([])
+ expect(logic.values.stillDeletedFlags).toEqual([deletedFlag(4)])
+ })
+})
diff --git a/frontend/src/scenes/feature-flags/flagSelectionLogic.ts b/frontend/src/scenes/feature-flags/flagSelectionLogic.ts
index fcacf7317d29..4a86ff5b53a2 100644
--- a/frontend/src/scenes/feature-flags/flagSelectionLogic.ts
+++ b/frontend/src/scenes/feature-flags/flagSelectionLogic.ts
@@ -6,12 +6,14 @@ 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'
@@ -44,6 +46,14 @@ export interface BulkArchiveResult {
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.
@@ -55,6 +65,13 @@ export const BULK_COPY_MAX_FLAGS = 100
// 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
@@ -139,6 +156,35 @@ function summarizeBulkArchive(
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
@@ -284,7 +330,16 @@ export interface flagSelectionLogicValues {
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.
@@ -307,6 +362,13 @@ export interface flagSelectionLogicActions {
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[]
@@ -344,6 +406,15 @@ export interface flagSelectionLogicActions {
allMatching: boolean
}
}
+ bulkRestoreFlagSucceeded: (id: number) => {
+ id: number
+ }
+ bulkRestoreFlags: (flags: DeletedFlagInfo[]) => {
+ flags: DeletedFlagInfo[]
+ }
+ bulkRestoreFlagsFinished: (failed: BulkRestoreFailure[]) => {
+ failed: BulkRestoreFailure[]
+ }
closeBulkCopyModal: () => {
value: true
}
@@ -379,6 +450,13 @@ export interface flagSelectionLogicActions {
setBulkCopyTargetProjectIds: (projectIds: number[]) => {
projectIds: number[]
}
+ setBulkRestoreProgress: (
+ done: number,
+ total: number
+ ) => {
+ done: number
+ total: number
+ }
showResultsModal: (result: BulkDeleteResult) => {
result: BulkDeleteResult
}
@@ -403,6 +481,11 @@ export interface flagSelectionLogicMeta {
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[]
}
}
@@ -429,7 +512,7 @@ export const flagSelectionLogic = kea<flagSelectionLogicType>([
featureFlagsLogic({}),
['loadFeatureFlags'],
eventUsageLogic,
- ['reportFeatureFlagBulkCopy', 'reportFeatureFlagsBulkArchived'],
+ ['reportFeatureFlagBulkCopy', 'reportFeatureFlagsBulkArchived', 'reportFeatureFlagsBulkRestored'],
],
})),
@@ -448,6 +531,10 @@ export const flagSelectionLogic = kea<flagSelectionLogicType>([
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({
@@ -537,6 +624,42 @@ export const flagSelectionLogic = kea<flagSelectionLogicType>([
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 }) => ({
@@ -594,6 +717,23 @@ export const flagSelectionLogic = kea<flagSelectionLogicType>([
? `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 }) => ({
@@ -648,6 +788,53 @@ export const flagSelectionLogic = kea<flagSelectionLogicType>([
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
@@ -728,7 +915,11 @@ export const flagSelectionLogic = kea<flagSelectionLogicType>([
})),
beforeUnload(({ values }) => ({
- enabled: () => values.bulkDeleteResponseLoading || values.bulkCopyRunning || values.bulkArchiveRunning,
+ enabled: () =>
+ values.bulkDeleteResponseLoading ||
+ values.bulkCopyRunning ||
+ values.bulkArchiveRunning ||
+ values.bulkRestoreRunning,
message: 'A bulk flag operation is in progress. Leaving may interrupt it.',
})),
])