: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(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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxindex 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 } fromimport { 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.tsnew file mode 100644index 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.tsxindex 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 && (<LemonBannertype="warning"diff --git a/products/feature_flags/frontend/FeatureFlagDeletedBanner.test.tsx b/products/feature_flags/frontend/FeatureFlagDeletedBanner.test.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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>+ )+}