: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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.tsindex 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: numberpendingApprovalCount: 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.tsxnew file mode 100644index 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.tsxindex 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 {<LemonModalisOpen={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 && (<LemonCollapsepanels={[{diff --git a/frontend/src/scenes/feature-flags/FeatureFlags.tsx b/frontend/src/scenes/feature-flags/FeatureFlags.tsxindex 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.tsnew file mode 100644index 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.tsindex 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 | nullbulkDeleteResponseLoading: booleanbulkDeleteResult: 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: numberpendingApprovalCount: number} // eventUsageLogic+ reportFeatureFlagsBulkRestored: (+ restoredCount: number,+ failedCount: number+ ) => {+ failedCount: number+ restoredCount: number+ } // eventUsageLogicloadFeatureFlags: (_?: void | undefined) => void // featureFlagsLogicbulkArchiveFlags: (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.bulkCopyParamsconst 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.',})),])