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(experiments): restore a draft's deleted flag from the experiment page (#125723)

ruby childsdf7c1480be52
diff --git a/frontend/src/scenes/experiments/ExperimentView/DeletedFlagBanner.test.tsx b/frontend/src/scenes/experiments/ExperimentView/DeletedFlagBanner.test.tsx
new file mode 100644
index 000000000000..2dfc5791798e
--- /dev/null
+++ b/frontend/src/scenes/experiments/ExperimentView/DeletedFlagBanner.test.tsx
@@ -0,0 +1,273 @@
+import '@testing-library/jest-dom'
+
+import { cleanup, render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { BindLogic, Provider } from 'kea'
+import { expectLogic } from 'kea-test-utils'
+
+import { lemonToast } from '@posthog/lemon-ui'
+
+import { dayjs } from 'lib/dayjs'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+import { Experiment, ExperimentStatus } from '~/types'
+
+import { NEW_EXPERIMENT } from 'products/experiments/frontend/constants'
+
+import { experimentLogic } from '../experimentLogic'
+import { DeletedFlagBanner } from './DeletedFlagBanner'
+import { deletedFlagBannerLogic } from './deletedFlagBannerLogic'
+
+const EXPERIMENT_ID = 7
+const FLAG_ID = 11
+
+const deletedFlag = {
+ id: FLAG_ID,
+ team_id: 1,
+ key: `checkout-flag:deleted:${FLAG_ID}`,
+ name: '',
+ filters: { groups: [] },
+ deleted: true,
+ active: true,
+ ensure_experience_continuity: false,
+}
+
+// The flag API's copy of the flag. Unlike the experiment's copy, it says whether the viewer can edit the flag.
+const flagFromFlagApi = { ...deletedFlag, archived: false, can_edit: true }
+
+function draftExperiment(featureFlag: Record<string, unknown> = deletedFlag): Experiment {
+ return {
+ ...NEW_EXPERIMENT,
+ id: EXPERIMENT_ID,
+ feature_flag_key: 'checkout-flag',
+ feature_flag: featureFlag,
+ } as unknown as Experiment
+}
+
+// LemonBanner renders its action twice, once per layout.
+function restoreButtons(): NodeListOf<HTMLButtonElement> {
+ return document.querySelectorAll<HTMLButtonElement>('[data-attr="experiment-restore-deleted-flag"]')
+}
+
+const deletion = {
+ id: '1',
+ activity: 'deleted',
+ scope: 'FeatureFlag',
+ item_id: String(FLAG_ID),
+ user: { first_name: 'Max', last_name: 'Smith', email: '[email protected]' },
+ created_at: dayjs().subtract(3, 'day').toISOString(),
+ is_system: false,
+ was_impersonated: false,
+ client: 'mcp',
+}
+
+describe('DeletedFlagBanner', () => {
+ let logic: ReturnType<typeof experimentLogic.build>
+ let restoreBodies: unknown[]
+
+ function renderBanner(experiment: Experiment): void {
+ logic.actions.setExperiment(experiment)
+ render(
+ <Provider>
+ <BindLogic logic={experimentLogic} props={{ experimentId: EXPERIMENT_ID }}>
+ <DeletedFlagBanner />
+ </BindLogic>
+ </Provider>
+ )
+ }
+
+ beforeEach(() => {
+ restoreBodies = []
+ const emptyList = { count: 0, next: null, previous: null, results: [] }
+ useMocks({
+ get: {
+ '/api/projects/:team/experiments': emptyList,
+ '/api/projects/:team/experiment_holdouts': emptyList,
+ '/api/projects/:team/experiment_saved_metrics': emptyList,
+ '/api/projects/:team/experiments/:id': () => [
+ 200,
+ draftExperiment({ ...deletedFlag, key: 'checkout-flag', deleted: false }),
+ ],
+ '/api/projects/:team/feature_flags/:id': flagFromFlagApi,
+ '/api/projects/:team/feature_flags/:id/activity': {
+ results: [deletion],
+ next: null,
+ previous: null,
+ total_count: 1,
+ },
+ },
+ patch: {
+ '/api/projects/:team/feature_flags/:id': async ({ request, params }) => {
+ restoreBodies.push({ id: params.id, body: await request.json() })
+ return [200, { ...deletedFlag, key: 'checkout-flag', deleted: false }]
+ },
+ },
+ })
+ initKeaTests()
+ logic = experimentLogic({ experimentId: EXPERIMENT_ID })
+ logic.mount()
+ })
+
+ afterEach(() => {
+ cleanup()
+ logic.unmount()
+ })
+
+ it.each([
+ { who: 'a member by full name', entry: {}, name: 'Max Smith' },
+ {
+ who: 'support while impersonating',
+ entry: { was_impersonated: true },
+ name: 'PostHog Support (as Max Smith)',
+ },
+ { who: 'the system', entry: { is_system: true, user: null }, name: 'PostHog' },
+ ])('names $who as the activity log does', async ({ entry, name }) => {
+ useMocks({
+ get: {
+ '/api/projects/:team/feature_flags/:id/activity': {
+ results: [{ ...deletion, ...entry }],
+ next: null,
+ previous: null,
+ total_count: 1,
+ },
+ },
+ })
+ renderBanner(draftExperiment())
+
+ expect(await screen.findByText((text) => text.startsWith(`${name} deleted`))).toBeInTheDocument()
+ })
+
+ it('names whoever deleted the flag most recently', async () => {
+ // A flag can be deleted, restored and deleted again. The activity API lists the newest entry first.
+ const newerDeletion = {
+ ...deletion,
+ id: '3',
+ user: { first_name: 'Alex', last_name: 'Jones', email: '[email protected]' },
+ created_at: dayjs().subtract(1, 'day').toISOString(),
+ }
+ const restore = {
+ ...deletion,
+ id: '2',
+ activity: 'restored',
+ created_at: dayjs().subtract(2, 'day').toISOString(),
+ }
+ useMocks({
+ get: {
+ '/api/projects/:team/feature_flags/:id/activity': {
+ results: [newerDeletion, restore, deletion],
+ next: null,
+ previous: null,
+ total_count: 3,
+ },
+ },
+ })
+ renderBanner(draftExperiment())
+
+ expect(await screen.findByText((text) => text.startsWith('Alex Jones deleted'))).toBeInTheDocument()
+ expect(screen.queryByText((text) => text.startsWith('Max Smith deleted'))).not.toBeInTheDocument()
+ })
+
+ it('links the flag, and names the client that deleted it', async () => {
+ renderBanner(draftExperiment())
+
+ expect(await screen.findByText(/via MCP/)).toBeInTheDocument()
+ expect(screen.getByText('checkout-flag').closest('a')).toHaveAttribute(
+ 'href',
+ expect.stringContaining(`/feature-flags/${FLAG_ID}`)
+ )
+ expect(screen.getByText(/can't launch until the flag is restored/)).toBeInTheDocument()
+ })
+
+ it('restores the flag and reloads the experiment', async () => {
+ renderBanner(draftExperiment())
+
+ await screen.findByText(/feature flag is deleted/)
+ await userEvent.click(restoreButtons()[0])
+
+ await waitFor(() => expect(restoreBodies).toEqual([{ id: String(FLAG_ID), body: { deleted: false } }]))
+ await waitFor(() => expect(screen.queryByText(/feature flag is deleted/)).not.toBeInTheDocument())
+ })
+
+ it('shows why a restore failed and keeps the banner', async () => {
+ const errorToast = jest.spyOn(lemonToast, 'error').mockReturnValue('toast-id')
+ const detail = 'There is already a feature flag with this key.'
+ useMocks({ patch: { '/api/projects/:team/feature_flags/:id': () => [400, { detail }] } })
+ renderBanner(draftExperiment())
+
+ await screen.findByText(/feature flag is deleted/)
+ await userEvent.click(restoreButtons()[0])
+
+ // The experiment only reloads after a restore that worked.
+ await expectLogic(deletedFlagBannerLogic({ experimentId: EXPERIMENT_ID, flagId: FLAG_ID }))
+ .toDispatchActions(['restoreFlagSuccess'])
+ .toNotHaveDispatchedActions(['loadExperiment'])
+ expect(errorToast).toHaveBeenCalledWith(detail)
+ expect(screen.getByText(/feature flag is deleted/)).toBeInTheDocument()
+ expect(restoreButtons().length).toBeGreaterThan(0)
+ errorToast.mockRestore()
+ })
+
+ it('still explains the delete when the activity log cannot be read', async () => {
+ useMocks({ get: { '/api/projects/:team/feature_flags/:id/activity': () => [500, { detail: 'Server error' }] } })
+ renderBanner(draftExperiment())
+
+ expect(await screen.findByText(/can't launch until the flag is restored/)).toBeInTheDocument()
+ expect(screen.queryByText(/deleted it/)).not.toBeInTheDocument()
+ expect(restoreButtons().length).toBeGreaterThan(0)
+ })
+
+ it.each([
+ {
+ state: 'when the viewer cannot edit the flag',
+ response: () => [200, { ...flagFromFlagApi, can_edit: false }],
+ },
+ {
+ state: 'when the flag cannot be read',
+ response: () => [403, { detail: 'You do not have access to this feature flag.' }],
+ },
+ ])('offers no restore $state', async ({ response }) => {
+ useMocks({ get: { '/api/projects/:team/feature_flags/:id': response } })
+ renderBanner(draftExperiment())
+
+ expect(await screen.findByText(/Ask someone with edit access to restore it/)).toBeInTheDocument()
+ expect(restoreButtons()).toHaveLength(0)
+ })
+
+ it('offers no restore for a flag on the new config format', async () => {
+ const v2Flag = { ...deletedFlag, filters: { version: 2, rules: [] } }
+ useMocks({ get: { '/api/projects/:team/feature_flags/:id': { ...flagFromFlagApi, ...v2Flag } } })
+ renderBanner(draftExperiment(v2Flag))
+
+ expect(await screen.findByText(/Restoring is not available for this flag yet/)).toBeInTheDocument()
+ expect(restoreButtons()).toHaveLength(0)
+ })
+
+ it.each([
+ {
+ state: 'a running experiment',
+ experiment: { start_date: dayjs().subtract(3, 'day').toISOString(), status: ExperimentStatus.Running },
+ },
+ {
+ state: 'an ended experiment',
+ experiment: {
+ start_date: dayjs().subtract(10, 'day').toISOString(),
+ end_date: dayjs().subtract(3, 'day').toISOString(),
+ status: ExperimentStatus.Stopped,
+ },
+ },
+ ])('stays hidden for $state', ({ experiment }) => {
+ renderBanner({ ...draftExperiment(), ...experiment } as Experiment)
+
+ // The banner renders nothing while it reads the flag, so its logic shows that it never started.
+ expect(deletedFlagBannerLogic.findMounted({ experimentId: EXPERIMENT_ID, flagId: FLAG_ID })).toBeNull()
+ expect(screen.queryByText(/feature flag is deleted/)).not.toBeInTheDocument()
+ })
+
+ it('stays hidden when the flag is not deleted', () => {
+ renderBanner(draftExperiment({ ...deletedFlag, deleted: false }))
+
+ expect(deletedFlagBannerLogic.findMounted({ experimentId: EXPERIMENT_ID, flagId: FLAG_ID })).toBeNull()
+ expect(screen.queryByText(/feature flag is deleted/)).not.toBeInTheDocument()
+ })
+})
diff --git a/frontend/src/scenes/experiments/ExperimentView/DeletedFlagBanner.tsx b/frontend/src/scenes/experiments/ExperimentView/DeletedFlagBanner.tsx
new file mode 100644
index 000000000000..a6b4ec5ac79a
--- /dev/null
+++ b/frontend/src/scenes/experiments/ExperimentView/DeletedFlagBanner.tsx
@@ -0,0 +1,76 @@
+import { useActions, useValues } from 'kea'
+
+import { Link } from '@posthog/lemon-ui'
+
+import { activityClientLabel } from 'lib/components/ActivityLog/activityClientLabel'
+import { TZLabel } from 'lib/components/TZLabel'
+import { urls } from 'scenes/urls'
+
+import { Experiment, FeatureFlagBasicType } from '~/types'
+
+import { FeatureFlagDeletedBanner } from 'products/feature_flags/frontend/FeatureFlagDeletedBanner'
+
+import { experimentLogic } from '../experimentLogic'
+import { deletedFlagBannerLogic } from './deletedFlagBannerLogic'
+
+function DeletedFlagBannerContent({
+ experimentId,
+ flag,
+ flagKey,
+}: {
+ experimentId: Experiment['id']
+ flag: FeatureFlagBasicType
+ /** The key people know the flag by, from before the delete renamed it. */
+ flagKey: Experiment['feature_flag_key']
+}): JSX.Element | null {
+ const logic = deletedFlagBannerLogic({ experimentId, flagId: flag.id })
+ const { deletedFlag, deletedFlagLoading, flagDeletion, restoredFlagLoading } = useValues(logic)
+ const { restoreFlag } = useActions(logic)
+
+ // Until the flag API answers, nobody knows whether the viewer can restore the flag.
+ if (deletedFlagLoading) {
+ return null
+ }
+
+ return (
+ <FeatureFlagDeletedBanner
+ // When the flag API can't be read, the banner offers no restore.
+ flag={deletedFlag ?? { ...flag, archived: false, can_edit: false }}
+ subject={
+ <>
+ This experiment's feature flag{' '}
+ <Link to={urls.featureFlag(flag.id)} target="_blank">
+ {flagKey}
+ </Link>
+ </>
+ }
+ onRestore={restoreFlag}
+ restoreLoading={restoredFlagLoading}
+ restoreDataAttr="experiment-restore-deleted-flag"
+ className="mb-4"
+ >
+ <div>
+ {flagDeletion && (
+ <>
+ {flagDeletion.actor} deleted it <TZLabel time={flagDeletion.deletedAt} />
+ {flagDeletion.client ? ` via ${activityClientLabel(flagDeletion.client)}` : ''}.{' '}
+ </>
+ )}
+ The experiment can't launch until the flag is restored.
+ </div>
+ </FeatureFlagDeletedBanner>
+ )
+}
+
+/** A draft can't launch on a deleted flag. Once an experiment has run, deleting its flag is the normal cleanup. */
+export function DeletedFlagBanner(): JSX.Element | null {
+ const { experiment, isExperimentDraft } = useValues(experimentLogic)
+ const flag = experiment.feature_flag
+
+ if (!flag?.deleted || !isExperimentDraft) {
+ return null
+ }
+
+ // Deleting a flag adds `:deleted:<id>` to its key. The experiment API strips that suffix from `feature_flag_key`.
+ return <DeletedFlagBannerContent experimentId={experiment.id} flag={flag} flagKey={experiment.feature_flag_key} />
+}
diff --git a/frontend/src/scenes/experiments/ExperimentView/ExperimentView.tsx b/frontend/src/scenes/experiments/ExperimentView/ExperimentView.tsx
index d2370b5636b2..5566a6dbba4c 100644
--- a/frontend/src/scenes/experiments/ExperimentView/ExperimentView.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/ExperimentView.tsx
@@ -29,6 +29,7 @@ import { DEFAULT_EXPERIMENT_TAB, type ExperimentTab, experimentSceneLogic } from
import { Metrics } from '../MetricsView/new/Metrics'
import { RecalculationStatus } from '../MetricsView/shared/RecalculationStatus'
import { isLegacyExperiment } from '../utils'
+import { DeletedFlagBanner } from './DeletedFlagBanner'
import { DistributionModal, DistributionTable } from './DistributionTable'
import { ExperimentDebugPanel } from './ExperimentExecutionPathComparison'
import { ExperimentFeedbackTab } from './ExperimentFeedbackTab'
@@ -205,6 +206,7 @@ export function ExperimentView(): JSX.Element {
<LoadingState />
) : (
<>
+ <DeletedFlagBanner />
{healthFindings === null && <ExperimentWarningBanner />}
{showDebugPanel && (
<div className="mb-4">
diff --git a/frontend/src/scenes/experiments/ExperimentView/deletedFlagBannerLogic.ts b/frontend/src/scenes/experiments/ExperimentView/deletedFlagBannerLogic.ts
new file mode 100644
index 000000000000..c48113eb098b
--- /dev/null
+++ b/frontend/src/scenes/experiments/ExperimentView/deletedFlagBannerLogic.ts
@@ -0,0 +1,207 @@
+import { MakeLogicType, afterMount, connect, kea, key, listeners, path, props } from 'kea'
+import { loaders } from 'kea-loaders'
+
+import { lemonToast } from '@posthog/lemon-ui'
+
+import api from 'lib/api'
+import { ActivityLogItem, userNameForLogItem } from 'lib/components/ActivityLog/humanizeActivity'
+import { teamLogic } from 'scenes/teamLogic'
+
+import { deleteFromTree, refreshTreeItem } from '~/layout/panel-layout/ProjectTree/projectTreeLogic'
+import { Experiment, FeatureFlagBasicType, FeatureFlagType } from '~/types'
+
+import { featureFlagsActivityRetrieve, featureFlagsRetrieve } from 'products/feature_flags/frontend/generated/api'
+
+import { experimentLogic } from '../experimentLogic'
+
+export interface DeletedFlagBannerLogicProps {
+ experimentId: Experiment['id']
+ flagId: FeatureFlagBasicType['id']
+}
+
+export interface FlagDeletion {
+ /** Who deleted the flag, named as the activity log names them. */
+ actor: string
+ deletedAt: string
+ /** The API client that sent the delete, for example `mcp`. */
+ client: string | null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface deletedFlagBannerLogicValues {
+ currentProjectId: number | string // teamLogic
+ deletedFlag: FeatureFlagType | null
+ deletedFlagLoading: boolean
+ flagDeletion: FlagDeletion | null
+ flagDeletionLoading: boolean
+ restoredFlag: FeatureFlagType | null
+ restoredFlagLoading: boolean
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface deletedFlagBannerLogicActions {
+ loadExperiment: (
+ payload?:
+ | {
+ triggeredBy?: import('../experimentLogic').ExperimentTriggeredBy
+ }
+ | undefined
+ ) => {
+ triggeredBy?: import('../experimentLogic').ExperimentTriggeredBy
+ } // experimentLogic
+ loadDeletedFlag: () => any
+ loadDeletedFlagFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadDeletedFlagSuccess: (
+ deletedFlag: FeatureFlagType | null,
+ payload?: any
+ ) => {
+ deletedFlag: FeatureFlagType | null
+ payload?: any
+ }
+ loadFlagDeletion: () => any
+ loadFlagDeletionFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadFlagDeletionSuccess: (
+ flagDeletion: {
+ actor: string
+ client: string | null
+ deletedAt: string
+ } | null,
+ payload?: any
+ ) => {
+ flagDeletion: {
+ actor: string
+ client: string | null
+ deletedAt: string
+ } | null
+ payload?: any
+ }
+ restoreFlag: () => any
+ restoreFlagFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ restoreFlagSuccess: (
+ restoredFlag: FeatureFlagType | null,
+ payload?: any
+ ) => {
+ restoredFlag: FeatureFlagType | null
+ payload?: any
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface deletedFlagBannerLogicMeta {
+ key: number
+}
+
+export type deletedFlagBannerLogicType = MakeLogicType<
+ deletedFlagBannerLogicValues,
+ deletedFlagBannerLogicActions,
+ DeletedFlagBannerLogicProps,
+ deletedFlagBannerLogicMeta
+>
+
+export const deletedFlagBannerLogic = kea<deletedFlagBannerLogicType>([
+ props({} as DeletedFlagBannerLogicProps),
+ key((props) => props.flagId),
+ path((key) => ['scenes', 'experiments', 'ExperimentView', 'deletedFlagBannerLogic', key]),
+ connect((props: DeletedFlagBannerLogicProps) => ({
+ values: [teamLogic, ['currentProjectId']],
+ actions: [experimentLogic({ experimentId: props.experimentId }), ['loadExperiment']],
+ })),
+ loaders(({ props, values }) => ({
+ // The experiment's copy of the flag has no `can_edit` and no deleted-cohort marks. The flag API's copy has both.
+ deletedFlag: [
+ null as FeatureFlagType | null,
+ {
+ loadDeletedFlag: async () => {
+ try {
+ return (await featureFlagsRetrieve(
+ String(values.currentProjectId),
+ props.flagId
+ )) as unknown as FeatureFlagType
+ } catch {
+ // Without the flag API's copy, the banner offers no restore.
+ return null
+ }
+ },
+ },
+ ],
+ flagDeletion: [
+ null as FlagDeletion | null,
+ {
+ loadFlagDeletion: async () => {
+ try {
+ const activity = await featureFlagsActivityRetrieve(
+ String(values.currentProjectId),
+ props.flagId,
+ { limit: 10 }
+ )
+ // The log is newest first, so this is the delete that left the flag deleted.
+ const deletion = activity.results.find((entry) => entry.activity === 'deleted')
+ return deletion
+ ? {
+ // The generated type leaves `user` untyped. The payload is the one `ActivityLogItem` describes.
+ actor: userNameForLogItem(deletion as unknown as ActivityLogItem),
+ deletedAt: deletion.created_at,
+ client: deletion.client,
+ }
+ : null
+ } catch {
+ // The banner still works without who and when, so a failed read stays quiet.
+ return null
+ }
+ },
+ },
+ ],
+ restoredFlag: [
+ null as FeatureFlagType | null,
+ {
+ restoreFlag: async () => {
+ try {
+ // nosemgrep: prefer-codegen-api -- The generated partial update request type has no `deleted` field.
+ const flag: FeatureFlagType = await api.update(
+ `api/projects/${values.currentProjectId}/feature_flags/${props.flagId}`,
+ { deleted: false }
+ )
+ // Restore gives the flag a new tree entry. A delete from another tab or the API leaves the old entry in this tab's tree.
+ deleteFromTree('feature_flag', String(props.flagId))
+ refreshTreeItem('feature_flag', String(props.flagId))
+ // The response carries the restored key, not the one the delete renamed it to.
+ lemonToast.success(`${flag.key} has been restored`)
+ return flag
+ } catch (error: any) {
+ lemonToast.error(error?.detail || "Couldn't restore this feature flag. Try again.")
+ return null
+ }
+ },
+ },
+ ],
+ })),
+ listeners(({ actions }) => ({
+ restoreFlagSuccess: ({ restoredFlag }) => {
+ if (restoredFlag) {
+ actions.loadExperiment()
+ }
+ },
+ })),
+ afterMount(({ actions }) => {
+ actions.loadDeletedFlag()
+ actions.loadFlagDeletion()
+ }),
+])
diff --git a/frontend/src/scenes/feature-flags/FeatureFlag.tsx b/frontend/src/scenes/feature-flags/FeatureFlag.tsx
index b80e50d51e04..eee91f29fd1e 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlag.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlag.tsx
@@ -90,6 +90,7 @@ import {
featureFlagConfigFormatLabel,
isRulesV2EditableConfig,
} from 'products/feature_flags/frontend/featureFlagConfigFormat'
+import { FeatureFlagDeletedBanner } from 'products/feature_flags/frontend/FeatureFlagDeletedBanner'
import { FeatureFlagDeletedCohortBanner } from 'products/feature_flags/frontend/FeatureFlagDeletedCohortBanner'
import { FeatureFlagStaleBanner } from 'products/feature_flags/frontend/FeatureFlagStaleBanner'
import { AGENT_TOOL_APPLY_BACK_CONTEXT_ITEM, useAttachedContext } from 'products/posthog_ai/frontend/api/logics'
@@ -564,29 +565,11 @@ export function FeatureFlag({ id }: FeatureFlagLogicProps): JSX.Element {
<PendingChangeRequestBanner resourceType="feature_flag" resourceId={featureFlag.id} />
)}
- {featureFlag.deleted && (
- <LemonBanner
- type="error"
- action={
- featureFlag.can_edit && canRestore
- ? {
- children: 'Restore',
- onClick: () => restoreFeatureFlag(featureFlag),
- loading: featureFlagRestoreLoading,
- disabledReason: restoreBlockedReason,
- 'data-attr': 'restore-feature-flag-banner',
- }
- : undefined
- }
- >
- This feature flag is deleted. It's hidden from the flag list and can't be evaluated.{' '}
- {!canRestore
- ? RESTORE_UNAVAILABLE_DISABLED_REASON
- : featureFlag.can_edit
- ? 'Restore it to use it again.'
- : 'Ask someone with edit access to restore it.'}
- </LemonBanner>
- )}
+ <FeatureFlagDeletedBanner
+ flag={featureFlag}
+ onRestore={() => restoreFeatureFlag(featureFlag)}
+ restoreLoading={featureFlagRestoreLoading}
+ />
{featureFlag.archived && (
<LemonBanner
type="warning"
diff --git a/products/feature_flags/frontend/FeatureFlagDeletedBanner.test.tsx b/products/feature_flags/frontend/FeatureFlagDeletedBanner.test.tsx
new file mode 100644
index 000000000000..45e90c0a98ef
--- /dev/null
+++ b/products/feature_flags/frontend/FeatureFlagDeletedBanner.test.tsx
@@ -0,0 +1,97 @@
+import '@testing-library/jest-dom'
+
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { Provider } from 'kea'
+
+import { initKeaTests } from '~/test/init'
+import { AnyPropertyFilter, FeatureFlagType, PropertyFilterType, PropertyOperator } from '~/types'
+
+import { FeatureFlagDeletedBanner, FeatureFlagDeletedBannerProps } from './FeatureFlagDeletedBanner'
+
+type BannerFlag = FeatureFlagDeletedBannerProps['flag']
+
+const deletedFlag: BannerFlag = { deleted: true, archived: false, can_edit: true, filters: { groups: [] } }
+
+const deletedCohortCondition = {
+ key: 'id',
+ type: PropertyFilterType.Cohort,
+ operator: PropertyOperator.In,
+ value: 5,
+ cohort_name: 'Frequent buyers',
+ cohort_deleted: true,
+} as AnyPropertyFilter
+
+const flagWithDeletedCohort: BannerFlag = {
+ ...deletedFlag,
+ filters: { groups: [{ properties: [deletedCohortCondition], rollout_percentage: 100 }] },
+}
+
+// LemonBanner renders its action twice, once per layout.
+function restoreButtons(): NodeListOf<HTMLButtonElement> {
+ return document.querySelectorAll<HTMLButtonElement>('[data-attr="restore-feature-flag-banner"]')
+}
+
+describe('FeatureFlagDeletedBanner', () => {
+ let onRestore: jest.Mock
+
+ function renderBanner(flag: BannerFlag): void {
+ render(
+ <Provider>
+ <FeatureFlagDeletedBanner flag={flag} onRestore={onRestore} restoreLoading={false} />
+ </Provider>
+ )
+ }
+
+ beforeEach(() => {
+ initKeaTests()
+ onRestore = jest.fn()
+ })
+
+ afterEach(() => {
+ cleanup()
+ })
+
+ it('lets an editor restore the flag', () => {
+ renderBanner(deletedFlag)
+
+ expect(screen.getByText(/This feature flag is deleted\. .* Restore it to use it again\./)).toBeInTheDocument()
+ fireEvent.click(restoreButtons()[0])
+ expect(onRestore).toHaveBeenCalledTimes(1)
+ })
+
+ it.each([
+ {
+ state: 'a viewer',
+ flag: { ...deletedFlag, can_edit: false },
+ text: 'Ask someone with edit access to restore it.',
+ },
+ {
+ state: 'a flag on the new config format',
+ flag: { ...deletedFlag, filters: { version: 2, rules: [] } as unknown as FeatureFlagType['filters'] },
+ text: 'Restoring is not available for this flag yet.',
+ },
+ ])('offers no restore to $state', ({ flag, text }) => {
+ renderBanner(flag)
+
+ expect(screen.getByText(text, { exact: false })).toBeInTheDocument()
+ expect(restoreButtons()).toHaveLength(0)
+ })
+
+ it('blocks the restore while a release condition targets a deleted cohort', () => {
+ renderBanner(flagWithDeletedCohort)
+
+ expect(restoreButtons()[0]).toHaveAttribute('aria-disabled', 'true')
+ })
+
+ it('allows the restore of an archived flag, because unarchiving checks the cohorts', () => {
+ renderBanner({ ...flagWithDeletedCohort, archived: true })
+
+ expect(restoreButtons()[0]).toHaveAttribute('aria-disabled', 'false')
+ })
+
+ it('renders nothing for a flag that is not deleted', () => {
+ renderBanner({ ...deletedFlag, deleted: false })
+
+ expect(screen.queryByText(/is deleted/)).not.toBeInTheDocument()
+ })
+})
diff --git a/products/feature_flags/frontend/FeatureFlagDeletedBanner.tsx b/products/feature_flags/frontend/FeatureFlagDeletedBanner.tsx
new file mode 100644
index 000000000000..92a8a45ce3d4
--- /dev/null
+++ b/products/feature_flags/frontend/FeatureFlagDeletedBanner.tsx
@@ -0,0 +1,69 @@
+import { ReactNode } from 'react'
+
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+
+import { FeatureFlagType } from '~/types'
+
+import { deletedCohortDisabledReason, deletedCohortFilters, restoreChecksCohorts } from './deletedCohortFilters'
+import { RESTORE_UNAVAILABLE_DISABLED_REASON, canRestoreFeatureFlag } from './featureFlagConfigFormat'
+
+export interface FeatureFlagDeletedBannerProps {
+ /** The flag as the flag API returns it. That response sets `can_edit` and marks conditions on deleted cohorts. */
+ flag: Pick<FeatureFlagType, 'deleted' | 'archived' | 'can_edit' | 'filters'>
+ onRestore: () => void
+ restoreLoading: boolean
+ /** How the first sentence names the flag. */
+ subject?: ReactNode
+ /** Tells apart the pages that people restore from. */
+ restoreDataAttr?: string
+ className?: string
+ /** Lines that the page adds after the explanation. */
+ children?: ReactNode
+}
+
+/** Explains that a flag is deleted, and offers a restore to people who can edit the flag. */
+export function FeatureFlagDeletedBanner({
+ flag,
+ onRestore,
+ restoreLoading,
+ subject = 'This feature flag',
+ restoreDataAttr = 'restore-feature-flag-banner',
+ className,
+ children,
+}: FeatureFlagDeletedBannerProps): JSX.Element | null {
+ if (!flag.deleted) {
+ return null
+ }
+
+ const canRestore = canRestoreFeatureFlag(flag.filters)
+ // The flag API refuses the restore while a release condition targets a deleted cohort.
+ const restoreBlockedReason = restoreChecksCohorts(flag)
+ ? deletedCohortDisabledReason(deletedCohortFilters(flag.filters))
+ : undefined
+
+ return (
+ <LemonBanner
+ type="error"
+ className={className}
+ action={
+ flag.can_edit && canRestore
+ ? {
+ children: 'Restore',
+ onClick: onRestore,
+ loading: restoreLoading,
+ disabledReason: restoreBlockedReason,
+ 'data-attr': restoreDataAttr,
+ }
+ : undefined
+ }
+ >
+ {subject} is deleted. It's hidden from the flag list and can't be evaluated.{' '}
+ {!canRestore
+ ? RESTORE_UNAVAILABLE_DISABLED_REASON
+ : flag.can_edit
+ ? 'Restore it to use it again.'
+ : 'Ask someone with edit access to restore it.'}
+ {children}
+ </LemonBanner>
+ )
+}