: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
import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { beforeUnload } from 'kea-router'
import { lemonToast } from '@posthog/lemon-ui'
import api from 'lib/api'
import { ApiError, isApprovalRequiredError } from 'lib/api-error'
import { PromiseTimeoutError, withTimeout } from 'lib/utils/async'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
import { pluralize } from 'lib/utils/strings'
import { dispatchChangeRequestCreated } from 'scenes/approvals/utils'
import { organizationLogic } from 'scenes/organizationLogic'
import { projectLogic } from 'scenes/projectLogic'
import { RESTORE_UNAVAILABLE_DISABLED_REASON } from 'products/feature_flags/frontend/featureFlagConfigFormat'
import { featureFlagsPartialUpdate } from 'products/feature_flags/frontend/generated/api'
import type { CopyFlagsResponseApi } from 'products/feature_flags/frontend/generated/api.schemas'
import type { OrganizationType, TeamBasicType } from '../../types'
import { featureFlagsLogic } from './featureFlagsLogic'
export type FlagRolloutState = 'fully_rolled_out' | 'not_rolled_out' | 'partial'
export interface DeletedFlagInfo {
id: number
key: string
rollout_state: FlagRolloutState
active_variant: string | null
}
export interface BulkDeleteResult {
deleted: DeletedFlagInfo[]
errors: Array<{ id: number; key?: string; reason: string }>
}
export interface BulkArchiveFailure {
id: number
errorMessage: string
/** The flag wasn't archived because the change needs approval — a change request was created. */
approvalPending: boolean
}
export interface BulkArchiveResult {
archivedIds: number[]
failed: BulkArchiveFailure[]
}
export interface BulkRestoreFailure {
id: number
key: string
errorMessage: string
/** False when the API won't restore this flag at all, so trying again fails the same way. */
retryable: boolean
}
/**
* Bulk archive issues one request per flag, so it's capped the same way bulk copy is rather than
* letting a "select all matching" run fan out to thousands of sequential requests.
*/
export const BULK_ARCHIVE_MAX_FLAGS = 100
export const BULK_COPY_MAX_FLAGS = 100
// Mirrors MAX_COPY_FLAGS_TARGET_PROJECTS in
// products/feature_flags/backend/api/organization_feature_flag.py, which rejects more. Keep in sync.
export const BULK_COPY_MAX_TARGET_PROJECTS = 50
/**
* Bulk restore waits for each request before it sends the next, and the dialog stays locked until the
* last one returns. A request that stalls would keep it locked for good, so each one is cancelled after
* this long and counts as a failure the person can retry.
*/
export const BULK_RESTORE_REQUEST_TIMEOUT_MS = 30_000
export interface BulkCopyParams {
/** Project the flags are copied from. */
sourceProjectId: number
/** Selected flag IDs (overview tab) — resolved to keys via bulk_keys at submit time. */
flagIds?: number[]
/** Selected flag keys (projects grid) — used as-is. */
flagKeys?: string[]
/** Whether the modal lets the user change the source project (projects grid rows are org-level). */
sourceSelectable?: boolean
}
export interface BulkCopyFailure {
key: string
projectId: number | null
errorMessage: string
/** The copy wasn't applied because the target project requires approval — a change request was created. */
approvalPending?: boolean
}
export interface BulkCopyResult {
copied: Array<{
key: string
projectIds: number[]
/** Subset of projectIds where a flag with this key already existed and was overwritten. */
updatedProjectIds: number[]
}>
failed: BulkCopyFailure[]
warnings: string[]
/** Selected flags that no longer resolved to a key (e.g. deleted between selection and submit). */
skippedFlagCount: number
}
function summarizeBulkCopy(
copied: BulkCopyResult['copied'],
failed: BulkCopyFailure[],
targetCount: number
): { level: 'success' | 'warning' | 'error'; message: string } {
const pendingApprovalCount = failed.filter((failure) => failure.approvalPending).length
const hardFailureCount = failed.length - pendingApprovalCount
const updatedPairCount = copied.reduce((count, entry) => count + entry.updatedProjectIds.length, 0)
// Omit the "Copied N flags" clause entirely when nothing copied, rather than showing a
// contradictory "Copied 0 flags ... pending approval" message.
const summary =
copied.length > 0
? `Copied ${pluralize(copied.length, 'flag')} to ${pluralize(targetCount, 'project')}` +
(updatedPairCount > 0 ? ` (${pluralize(updatedPairCount, 'existing flag')} overwritten)` : '')
: null
if (failed.length === 0 && copied.length > 0) {
return { level: 'success', message: summary as string }
}
if (copied.length > 0 || pendingApprovalCount > 0) {
const parts = [
summary,
pendingApprovalCount > 0 ? `${pluralize(pendingApprovalCount, 'copy', 'copies')} pending approval` : null,
hardFailureCount > 0 ? `${pluralize(hardFailureCount, 'copy', 'copies')} failed` : null,
].filter((part): part is string => part !== null)
return {
level: 'warning',
message: parts.join(', '),
}
}
return { level: 'error', message: 'No flags were copied' }
}
function summarizeBulkArchive(
archivedCount: number,
failed: BulkArchiveFailure[]
): { level: 'success' | 'warning' | 'error'; message: string } {
const pendingApprovalCount = failed.filter((failure) => failure.approvalPending).length
const hardFailureCount = failed.length - pendingApprovalCount
if (failed.length === 0) {
return { level: 'success', message: `Archived ${pluralize(archivedCount, 'flag')}` }
}
if (archivedCount > 0 || pendingApprovalCount > 0) {
const parts = [
archivedCount > 0 ? `Archived ${pluralize(archivedCount, 'flag')}` : null,
pendingApprovalCount > 0 ? `${pluralize(pendingApprovalCount, 'flag')} pending approval` : null,
hardFailureCount > 0 ? `${pluralize(hardFailureCount, 'flag')} failed` : null,
].filter((part): part is string => part !== null)
return { level: 'warning', message: parts.join(', ') }
}
return { level: 'error', message: 'No flags were archived' }
}
function summarizeBulkRestore(
restoredCount: number,
failedCount: number
): { level: 'success' | 'warning' | 'error'; message: string } {
if (failedCount === 0) {
return { level: 'success', message: `Restored ${pluralize(restoredCount, 'flag')}` }
}
if (restoredCount > 0) {
return {
level: 'warning',
message: `Restored ${pluralize(restoredCount, 'flag')}, ${pluralize(failedCount, 'flag')} failed`,
}
}
return { level: 'error', message: 'No flags were restored' }
}
// The API refuses to restore a flag on config version 2.
function isUnsupportedConfigVersion(error: unknown): boolean {
return error instanceof ApiError && error.code === 'unsupported_config_version'
}
function restoreErrorMessage(error: unknown): string {
if (error instanceof PromiseTimeoutError) {
return 'The request timed out. Try again.'
}
// Say why a version 2 flag can't be restored in the words the flag page uses.
return isUnsupportedConfigVersion(error) ? RESTORE_UNAVAILABLE_DISABLED_REASON : errorMessageFrom(error)
}
export function errorMessageFrom(error: unknown): string {
if (typeof error === 'string') {
return error
}
if (error instanceof ApiError) {
return error.detail ?? error.message
}
return 'Request failed'
}
/** Turns one key's copy response into the copied/failed/warning entries the bulk-copy listener accumulates. */
export function aggregateCopyResponse(
key: string,
targetProjectIds: number[],
response: CopyFlagsResponseApi
): { copied: BulkCopyResult['copied'][number] | null; failed: BulkCopyFailure[]; warnings: string[] } {
// Copied targets are inferred as requested-minus-failed (robust to success items
// missing team_id during deploy skew); overwrites come from the per-item flag.
const failedProjectIds = new Set(
response.failed.map((entry) => entry.project_id).filter((id): id is number => id != null)
)
const copiedProjectIds = targetProjectIds.filter((id) => !failedProjectIds.has(id))
const updatedProjectIds = response.success
.filter((item) => item.updated_existing && item.team_id != null)
.map((item) => item.team_id)
const failed: BulkCopyFailure[] = response.failed.map((entry) => ({
key,
projectId: entry.project_id ?? null,
errorMessage: errorMessageFrom(entry.error_message || 'Copy failed'),
approvalPending: entry.approval_pending,
}))
const warnings: string[] = []
for (const successItem of response.success) {
for (const warning of successItem.flag_dependency_warnings ?? []) {
warnings.push(`${key}: ${warning}`)
}
if (successItem.schedule_copy_warning) {
warnings.push(`${key}: ${successItem.schedule_copy_warning}`)
}
}
return {
copied: copiedProjectIds.length > 0 ? { key, projectIds: copiedProjectIds, updatedProjectIds } : null,
failed,
warnings,
}
}
/** Splits each copied entry's projectIds into freshly created flags vs. overwrites of flags that already existed in the target. */
export function splitCopiedByOverwrite(copied: BulkCopyResult['copied']): {
newCopies: Array<{ key: string; projectIds: number[] }>
overwrites: Array<{ key: string; projectIds: number[] }>
} {
const newCopies = copied
.map((entry) => ({
key: entry.key,
projectIds: entry.projectIds.filter((id) => !entry.updatedProjectIds.includes(id)),
}))
.filter((entry) => entry.projectIds.length > 0)
const overwrites = copied
.map((entry) => ({ key: entry.key, projectIds: entry.updatedProjectIds }))
.filter((entry) => entry.projectIds.length > 0)
return { newCopies, overwrites }
}
export interface ProjectSelectOption {
key: string
label: string
value: number
}
/** Copy-destination options for a project picker: the org's teams minus one excluded project, sorted by name. */
export function projectSelectOptions(
teams: TeamBasicType[] | null | undefined,
excludeProjectId: number | null
): ProjectSelectOption[] {
return (teams ?? [])
.filter((team) => team.id !== excludeProjectId)
.map((team) => ({ key: String(team.id), label: team.name, value: team.id }))
.sort((a, b) => a.label.localeCompare(b.label))
}
export function getBulkCopyDisabledReason(selectedCount: number, extraReason?: string | null): string | undefined {
if (extraReason) {
return extraReason
}
if (selectedCount > BULK_COPY_MAX_FLAGS) {
return `Bulk copy supports up to ${BULK_COPY_MAX_FLAGS} flags at once`
}
return undefined
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagSelectionLogicValues {
paramsFromFilters: {
active?: string | undefined
archived?: string | undefined
created_by_id?: number[] | undefined
deleted?: string | undefined
evaluation_runtime?: string | undefined
excluded_tags?: string[] | undefined
limit: number
offset: number
order?: string | undefined
page?: number | undefined
search?: string | undefined
tags?: string[] | undefined
type?: string | undefined
} // featureFlagsLogic
currentOrganization: OrganizationType | null // organizationLogic
currentProjectId: number | null // projectLogic
bulkArchiveProgress: {
done: number
total: number
} | null
bulkArchiveResult: BulkArchiveResult | null
bulkArchiveRunning: boolean
bulkCopyDisableCopiedFlag: boolean
bulkCopyFlagCount: number
bulkCopyHardFailures: BulkCopyFailure[]
bulkCopyModalVisible: boolean
bulkCopyParams: BulkCopyParams | null
bulkCopyPendingApproval: BulkCopyFailure[]
bulkCopyProgress: {
done: number
total: number
} | null
bulkCopyResult: BulkCopyResult | null
bulkCopyRunning: boolean
bulkCopySchedule: boolean
bulkCopySourceProjectId: number | null
bulkCopySplitCopied: {
newCopies: {
key: string
projectIds: number[]
}[]
overwrites: {
key: string
projectIds: number[]
}[]
}
bulkCopySubmitDisabledReason: string | undefined
bulkCopyTargetProjectIds: number[]
bulkDeleteResponse: BulkDeleteResult | null
bulkDeleteResponseLoading: boolean
bulkDeleteResult: BulkDeleteResult | null
bulkRestoreFailures: BulkRestoreFailure[]
bulkRestoreProgress: {
done: number
total: number
} | null
bulkRestoreRunning: boolean
bulkRestoredIds: number[]
restorableFlags: DeletedFlagInfo[]
resultsModalVisible: boolean
stillDeletedFlags: DeletedFlagInfo[]
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagSelectionLogicActions {
reportFeatureFlagBulkCopy: (
flagCount: number,
projectCount: number,
failedCount: number
) => {
failedCount: number
flagCount: number
projectCount: number
} // eventUsageLogic
reportFeatureFlagsBulkArchived: (
archivedCount: number,
pendingApprovalCount: number,
failedCount: number
) => {
archivedCount: number
failedCount: number
pendingApprovalCount: number
} // eventUsageLogic
reportFeatureFlagsBulkRestored: (
restoredCount: number,
failedCount: number
) => {
failedCount: number
restoredCount: number
} // eventUsageLogic
loadFeatureFlags: (_?: void | undefined) => void // featureFlagsLogic
bulkArchiveFlags: (ids: number[]) => {
ids: number[]
}
bulkArchiveFlagsFinished: (result: BulkArchiveResult | null) => {
result: BulkArchiveResult | null
}
bulkCopyFlags: () => {
value: true
}
bulkCopyFlagsFinished: (result: BulkCopyResult | null) => {
result: BulkCopyResult | null
}
bulkDeleteFlags: ({ ids, allMatching }: { allMatching: boolean; ids: number[] }) => {
ids: number[]
allMatching: boolean
}
bulkDeleteFlagsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
bulkDeleteFlagsSuccess: (
bulkDeleteResponse: BulkDeleteResult,
payload?: {
ids: number[]
allMatching: boolean
}
) => {
bulkDeleteResponse: BulkDeleteResult
payload?: {
ids: number[]
allMatching: boolean
}
}
bulkRestoreFlagSucceeded: (id: number) => {
id: number
}
bulkRestoreFlags: (flags: DeletedFlagInfo[]) => {
flags: DeletedFlagInfo[]
}
bulkRestoreFlagsFinished: (failed: BulkRestoreFailure[]) => {
failed: BulkRestoreFailure[]
}
closeBulkCopyModal: () => {
value: true
}
hideResultsModal: () => {
value: true
}
openBulkCopyModal: (params: BulkCopyParams) => {
params: BulkCopyParams
}
setBulkArchiveProgress: (
done: number,
total: number
) => {
done: number
total: number
}
setBulkCopyDisableCopiedFlag: (disableCopiedFlag: boolean) => {
disableCopiedFlag: boolean
}
setBulkCopyProgress: (
done: number,
total: number
) => {
done: number
total: number
}
setBulkCopySchedule: (copySchedule: boolean) => {
copySchedule: boolean
}
setBulkCopySourceProjectId: (projectId: number) => {
projectId: number
}
setBulkCopyTargetProjectIds: (projectIds: number[]) => {
projectIds: number[]
}
setBulkRestoreProgress: (
done: number,
total: number
) => {
done: number
total: number
}
showResultsModal: (result: BulkDeleteResult) => {
result: BulkDeleteResult
}
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagSelectionLogicMeta {
__keaTypeGenInternalSelectorTypes: {
resultsModalVisible: (bulkDeleteResult: BulkDeleteResult | null) => boolean
bulkCopyModalVisible: (bulkCopyParams: BulkCopyParams | null) => boolean
bulkCopyFlagCount: (bulkCopyParams: BulkCopyParams | null) => number
bulkCopySplitCopied: (bulkCopyResult: BulkCopyResult | null) => {
newCopies: {
key: string
projectIds: number[]
}[]
overwrites: {
key: string
projectIds: number[]
}[]
}
bulkCopyPendingApproval: (bulkCopyResult: BulkCopyResult | null) => BulkCopyFailure[]
bulkCopyHardFailures: (bulkCopyResult: BulkCopyResult | null) => BulkCopyFailure[]
bulkCopySubmitDisabledReason: (bulkCopyTargetProjectIds: number[]) => string | undefined
stillDeletedFlags: (bulkDeleteResult: BulkDeleteResult | null, bulkRestoredIds: number[]) => DeletedFlagInfo[]
restorableFlags: (
stillDeletedFlags: DeletedFlagInfo[],
bulkRestoreFailures: BulkRestoreFailure[]
) => DeletedFlagInfo[]
}
}
export type flagSelectionLogicType = MakeLogicType<
flagSelectionLogicValues,
flagSelectionLogicActions,
Record<string, any>,
flagSelectionLogicMeta
>
export const flagSelectionLogic = kea<flagSelectionLogicType>([
path(['scenes', 'feature-flags', 'flagSelectionLogic']),
connect(() => ({
values: [
projectLogic,
['currentProjectId'],
featureFlagsLogic({}),
['paramsFromFilters'],
organizationLogic,
['currentOrganization'],
],
actions: [
featureFlagsLogic({}),
['loadFeatureFlags'],
eventUsageLogic,
['reportFeatureFlagBulkCopy', 'reportFeatureFlagsBulkArchived', 'reportFeatureFlagsBulkRestored'],
],
})),
actions({
showResultsModal: (result: BulkDeleteResult) => ({ result }),
hideResultsModal: true,
openBulkCopyModal: (params: BulkCopyParams) => ({ params }),
closeBulkCopyModal: true,
setBulkCopySourceProjectId: (projectId: number) => ({ projectId }),
setBulkCopyTargetProjectIds: (projectIds: number[]) => ({ projectIds }),
setBulkCopySchedule: (copySchedule: boolean) => ({ copySchedule }),
setBulkCopyDisableCopiedFlag: (disableCopiedFlag: boolean) => ({ disableCopiedFlag }),
setBulkCopyProgress: (done: number, total: number) => ({ done, total }),
bulkCopyFlags: true,
bulkCopyFlagsFinished: (result: BulkCopyResult | null) => ({ result }),
setBulkArchiveProgress: (done: number, total: number) => ({ done, total }),
bulkArchiveFlags: (ids: number[]) => ({ ids }),
bulkArchiveFlagsFinished: (result: BulkArchiveResult | null) => ({ result }),
setBulkRestoreProgress: (done: number, total: number) => ({ done, total }),
bulkRestoreFlags: (flags: DeletedFlagInfo[]) => ({ flags }),
bulkRestoreFlagSucceeded: (id: number) => ({ id }),
bulkRestoreFlagsFinished: (failed: BulkRestoreFailure[]) => ({ failed }),
}),
reducers({
bulkDeleteResult: [
null as BulkDeleteResult | null,
{
showResultsModal: (_, { result }) => result,
hideResultsModal: () => null,
},
],
bulkCopyParams: [
null as BulkCopyParams | null,
{
openBulkCopyModal: (_, { params }) => params,
closeBulkCopyModal: () => null,
},
],
bulkCopySourceProjectId: [
null as number | null,
{
openBulkCopyModal: (_, { params }) => params.sourceProjectId,
setBulkCopySourceProjectId: (_, { projectId }) => projectId,
},
],
bulkCopyTargetProjectIds: [
[] as number[],
{
openBulkCopyModal: () => [],
setBulkCopyTargetProjectIds: (_, { projectIds }) => projectIds,
// A project can't be both source and destination of the same copy
setBulkCopySourceProjectId: (state, { projectId }) => state.filter((id) => id !== projectId),
},
],
bulkCopySchedule: [
false,
{
openBulkCopyModal: () => false,
setBulkCopySchedule: (_, { copySchedule }) => copySchedule,
},
],
bulkCopyDisableCopiedFlag: [
false,
{
openBulkCopyModal: () => false,
setBulkCopyDisableCopiedFlag: (_, { disableCopiedFlag }) => disableCopiedFlag,
},
],
bulkCopyRunning: [
false,
{
bulkCopyFlags: () => true,
bulkCopyFlagsFinished: () => false,
},
],
bulkCopyProgress: [
null as { done: number; total: number } | null,
{
openBulkCopyModal: () => null,
setBulkCopyProgress: (_, { done, total }) => ({ done, total }),
},
],
bulkCopyResult: [
null as BulkCopyResult | null,
{
openBulkCopyModal: () => null,
bulkCopyFlagsFinished: (_, { result }) => result,
},
],
bulkArchiveRunning: [
false,
{
bulkArchiveFlags: () => true,
bulkArchiveFlagsFinished: () => false,
},
],
bulkArchiveProgress: [
null as { done: number; total: number } | null,
{
bulkArchiveFlags: () => null,
setBulkArchiveProgress: (_, { done, total }) => ({ done, total }),
},
],
bulkArchiveResult: [
null as BulkArchiveResult | null,
{
bulkArchiveFlags: () => null,
bulkArchiveFlagsFinished: (_, { result }) => result,
},
],
bulkRestoreRunning: [
false,
{
bulkRestoreFlags: () => true,
bulkRestoreFlagsFinished: () => false,
},
],
bulkRestoreProgress: [
null as { done: number; total: number } | null,
{
bulkRestoreFlags: () => null,
setBulkRestoreProgress: (_, { done, total }) => ({ done, total }),
},
],
bulkRestoreFailures: [
[] as BulkRestoreFailure[],
{
showResultsModal: () => [],
// A retry clears the failures of the flags it tries again. The flags it leaves out keep their
// reason on show.
bulkRestoreFlags: (state, { flags }) => {
const retriedIds = new Set(flags.map((flag) => flag.id))
return state.filter((failure) => !retriedIds.has(failure.id))
},
bulkRestoreFlagsFinished: (state, { failed }) => [...state, ...failed],
},
],
// Filled as each restore lands, not when the batch ends, because a restored flag is live again
// and the cleanup prompt must stop asking to remove its code straight away.
bulkRestoredIds: [
[] as number[],
{
showResultsModal: () => [],
bulkRestoreFlagSucceeded: (state, { id }) => [...state, id],
},
],
}),
loaders(({ values }) => ({
bulkDeleteResponse: [
null as BulkDeleteResult | null,
{
bulkDeleteFlags: async ({ ids, allMatching }: { ids: number[]; allMatching: boolean }) => {
if (allMatching) {
const { limit, offset, ...filters } = values.paramsFromFilters
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use featureFlagsBulkDeleteCreate() from 'products/feature_flags/frontend/generated/api' instead.
const response = await api.create(
`api/projects/${values.currentProjectId}/feature_flags/bulk_delete/`,
{ filters }
)
return response as BulkDeleteResult
}
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use featureFlagsBulkDeleteCreate() from 'products/feature_flags/frontend/generated/api' instead.
const response = await api.create(
`api/projects/${values.currentProjectId}/feature_flags/bulk_delete/`,
{ ids }
)
return response as BulkDeleteResult
},
},
],
})),
selectors({
resultsModalVisible: [(s) => [s.bulkDeleteResult], (result: BulkDeleteResult | null) => result !== null],
bulkCopyModalVisible: [(s) => [s.bulkCopyParams], (params: BulkCopyParams | null) => params !== null],
bulkCopyFlagCount: [
(s) => [s.bulkCopyParams],
(params: BulkCopyParams | null): number => params?.flagKeys?.length ?? params?.flagIds?.length ?? 0,
],
bulkCopySplitCopied: [
(s) => [s.bulkCopyResult],
(result: BulkCopyResult | null) => splitCopiedByOverwrite(result?.copied ?? []),
],
bulkCopyPendingApproval: [
(s) => [s.bulkCopyResult],
(result: BulkCopyResult | null): BulkCopyFailure[] =>
result?.failed.filter((failure) => failure.approvalPending) ?? [],
],
bulkCopyHardFailures: [
(s) => [s.bulkCopyResult],
(result: BulkCopyResult | null): BulkCopyFailure[] =>
result?.failed.filter((failure) => !failure.approvalPending) ?? [],
],
bulkCopySubmitDisabledReason: [
(s) => [s.bulkCopyTargetProjectIds],
(targetProjectIds: number[]): string | undefined =>
targetProjectIds.length === 0
? 'Select at least one destination project'
: targetProjectIds.length > BULK_COPY_MAX_TARGET_PROJECTS
? `Bulk copy supports up to ${BULK_COPY_MAX_TARGET_PROJECTS} destination projects at once`
: undefined,
],
stillDeletedFlags: [
(s) => [s.bulkDeleteResult, s.bulkRestoredIds],
(bulkDeleteResult: BulkDeleteResult | null, bulkRestoredIds: number[]): DeletedFlagInfo[] => {
const restoredIds = new Set(bulkRestoredIds)
return bulkDeleteResult?.deleted.filter((flag) => !restoredIds.has(flag.id)) ?? []
},
],
// What the restore button offers: the flags still deleted, minus those the API already refused.
restorableFlags: [
(s) => [s.stillDeletedFlags, s.bulkRestoreFailures],
(stillDeletedFlags: DeletedFlagInfo[], bulkRestoreFailures: BulkRestoreFailure[]): DeletedFlagInfo[] => {
const refusedIds = new Set(
bulkRestoreFailures.filter((failure) => !failure.retryable).map((failure) => failure.id)
)
return stillDeletedFlags.filter((flag) => !refusedIds.has(flag.id))
},
],
}),
listeners(({ actions, values }) => ({
bulkDeleteFlagsSuccess: ({ bulkDeleteResponse }) => {
if (bulkDeleteResponse) {
actions.showResultsModal(bulkDeleteResponse)
actions.loadFeatureFlags()
}
},
bulkArchiveFlags: async ({ ids }) => {
const projectId = values.currentProjectId
if (!projectId || ids.length === 0) {
actions.bulkArchiveFlagsFinished(null)
return
}
if (ids.length > BULK_ARCHIVE_MAX_FLAGS) {
lemonToast.error(`Bulk archive supports up to ${BULK_ARCHIVE_MAX_FLAGS} flags at once.`)
actions.bulkArchiveFlagsFinished(null)
return
}
const archivedIds: number[] = []
const failed: BulkArchiveFailure[] = []
actions.setBulkArchiveProgress(0, ids.length)
// One request per flag through the regular update endpoint, on purpose: archiving disables
// the flag, so each one has to pass the approval gate the same way a single archive does.
// Sequential keeps the write load and the rollback ordering the same as archiving by hand.
for (const [index, id] of ids.entries()) {
try {
await featureFlagsPartialUpdate(String(projectId), id, { archived: true, active: false })
archivedIds.push(id)
} catch (error: any) {
const approvalPending = isApprovalRequiredError(error)
if (approvalPending) {
dispatchChangeRequestCreated({ resourceType: 'feature_flag', resourceId: id })
}
failed.push({ id, errorMessage: errorMessageFrom(error), approvalPending })
}
actions.setBulkArchiveProgress(index + 1, ids.length)
}
actions.bulkArchiveFlagsFinished({ archivedIds, failed })
actions.loadFeatureFlags()
const pendingApprovalCount = failed.filter((failure) => failure.approvalPending).length
actions.reportFeatureFlagsBulkArchived(
archivedIds.length,
pendingApprovalCount,
failed.length - pendingApprovalCount
)
const { level, message } = summarizeBulkArchive(archivedIds.length, failed)
lemonToast[level](message)
},
bulkRestoreFlags: async ({ flags }) => {
const projectId = values.currentProjectId
if (!projectId || flags.length === 0) {
actions.bulkRestoreFlagsFinished([])
return
}
let restoredCount = 0
const failed: BulkRestoreFailure[] = []
actions.setBulkRestoreProgress(0, flags.length)
// One request per flag, like the flag page's restore but with no row version. Only a v2 flag sends a
// row version there, and the API won't restore a v2 flag, so leaving it out here is safe. It undoes
// a delete the person just made, so it covers every deleted flag rather than stopping at a cap.
for (const [index, flag] of flags.entries()) {
const url = `api/projects/${projectId}/feature_flags/${flag.id}`
try {
await withTimeout(
// nosemgrep: prefer-codegen-api -- The generated partial update request type has no `deleted` field.
(signal) => api.update(url, { deleted: false }, { signal }),
BULK_RESTORE_REQUEST_TIMEOUT_MS
)
restoredCount += 1
actions.bulkRestoreFlagSucceeded(flag.id)
} catch (error) {
failed.push({
id: flag.id,
key: flag.key,
errorMessage: restoreErrorMessage(error),
retryable: !isUnsupportedConfigVersion(error),
})
}
actions.setBulkRestoreProgress(index + 1, flags.length)
}
actions.bulkRestoreFlagsFinished(failed)
actions.loadFeatureFlags()
actions.reportFeatureFlagsBulkRestored(restoredCount, failed.length)
// Keep the results open while any flag is still deleted, so the person can see which ones. That
// includes a flag an earlier run found the API won't restore, which this run left out.
if (values.stillDeletedFlags.length === 0) {
actions.hideResultsModal()
}
const { level, message } = summarizeBulkRestore(restoredCount, failed.length)
lemonToast[level](message)
},
bulkCopyFlags: async () => {
const params = values.bulkCopyParams
const sourceProjectId = values.bulkCopySourceProjectId
const targetProjectIds = values.bulkCopyTargetProjectIds
if (!params || !sourceProjectId || targetProjectIds.length === 0) {
actions.bulkCopyFlagsFinished(null)
return
}
let keys: string[] = []
let skippedFlagCount = 0
try {
if (params.flagKeys?.length) {
keys = Array.from(new Set(params.flagKeys))
} else if (params.flagIds?.length) {
const response = await api.featureFlags.bulkKeys(params.flagIds)
keys = Array.from(new Set(Object.values(response.keys)))
skippedFlagCount = params.flagIds.length - Object.keys(response.keys).length
}
} catch (error) {
lemonToast.error(`Failed to resolve selected flags: ${errorMessageFrom(error)}`)
actions.bulkCopyFlagsFinished(null)
return
}
if (keys.length === 0) {
lemonToast.error('None of the selected flags could be resolved — they may have been deleted.')
actions.bulkCopyFlagsFinished(null)
return
}
if (keys.length > BULK_COPY_MAX_FLAGS) {
lemonToast.error(`Bulk copy supports up to ${BULK_COPY_MAX_FLAGS} flags at once.`)
actions.bulkCopyFlagsFinished(null)
return
}
const copied: BulkCopyResult['copied'] = []
const failed: BulkCopyFailure[] = []
const warnings = new Set<string>()
actions.setBulkCopyProgress(0, keys.length)
// Sequential on purpose: each call already fans out to every target project server-side
// (and may create cohorts there), so parallel calls would multiply write load and risk
// rate limiting without improving perceived progress.
for (const [index, key] of keys.entries()) {
try {
const response = await api.organizationFeatureFlags.copy(values.currentOrganization?.id, {
feature_flag_key: key,
from_project: sourceProjectId,
target_project_ids: targetProjectIds,
copy_schedule: values.bulkCopySchedule,
disable_copied_flag: values.bulkCopyDisableCopiedFlag,
})
const aggregated = aggregateCopyResponse(key, targetProjectIds, response)
if (aggregated.copied) {
copied.push(aggregated.copied)
}
failed.push(...aggregated.failed)
aggregated.warnings.forEach((warning) => warnings.add(warning))
} catch (error) {
for (const projectId of targetProjectIds) {
failed.push({ key, projectId, errorMessage: errorMessageFrom(error) })
}
}
actions.setBulkCopyProgress(index + 1, keys.length)
}
actions.bulkCopyFlagsFinished({
copied,
failed,
warnings: Array.from(warnings),
skippedFlagCount,
})
actions.reportFeatureFlagBulkCopy(keys.length, targetProjectIds.length, failed.length)
const { level, message } = summarizeBulkCopy(copied, failed, targetProjectIds.length)
lemonToast[level](message)
},
})),
beforeUnload(({ values }) => ({
enabled: () =>
values.bulkDeleteResponseLoading ||
values.bulkCopyRunning ||
values.bulkArchiveRunning ||
values.bulkRestoreRunning,
message: 'A bulk flag operation is in progress. Leaving may interrupt it.',
})),
])