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.

22.8 KB
Raw Blame
import {
    MakeLogicType,
    actions,
    afterMount,
    beforeUnmount,
    connect,
    kea,
    key,
    listeners,
    path,
    props,
    reducers,
    selectors,
} from 'kea'
import { beforeUnload, router } from 'kea-router'
import { CombinedLocation } from 'kea-router/lib/utils'
import { subscriptions } from 'kea-subscriptions'

import { readableErrorMessage } from 'lib/api-error'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import type { FeatureFlagsSet } from 'lib/logic/featureFlagLogic'
import { objectsEqual } from 'lib/utils/objects'
import { projectLogic } from 'scenes/projectLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'

import { refreshTreeItem } from '~/layout/panel-layout/ProjectTree/projectTreeLogic'
import {
    FeatureFlagConfig,
    FeatureFlagRulesV2DraftConfig,
    FeatureFlagRulesV2DraftRule,
    FeatureFlagRulesV2ReturnType,
    FeatureFlagType,
    TeamPublicType,
    TeamType,
} from '~/types'

import {
    isRulesV2FeatureFlagConfig,
    isStaleRowVersionError,
    rulesV2CreateDisabledReason,
} from 'products/feature_flags/frontend/featureFlagConfigFormat'
import { featureFlagsCreate, featureFlagsPartialUpdate } from 'products/feature_flags/frontend/generated/api'
import type {
    FeatureFlagCreateRequestSchemaApi,
    PatchedFeatureFlagPartialUpdateRequestSchemaApi,
} from 'products/feature_flags/frontend/generated/api.schemas'

import { checkFeatureFlagConfirmation } from './featureFlagConfirmationLogic'
import { confirmFeatureFlagKeyChange } from './featureFlagKeyChangeDialog'
import {
    FeatureFlagLogicProps,
    featureFlagLogic,
    prefilledFlagKey,
    validateFeatureFlagKey,
    variantKeyToIndexFeatureFlagPayloads,
} from './featureFlagLogic'
import {
    duplicatedRule,
    insertedAfter,
    isIncompleteRulesV2Condition,
    moved,
    newRulesV2Rule,
    rulesV2DraftErrors,
    rulesV2ShadowingRules,
    withReturnType,
} from './featureFlagRulesV2Draft'

export interface FeatureFlagRulesV2Draft {
    key: string
    name: string
    tags: string[]
    config: FeatureFlagRulesV2DraftConfig
    /** The row version the draft was loaded from, so a save never pairs old rules with a newer version. */
    version: number | null
}

/** The first save error, keyed to the editor field its path names; `field` is null when no field owns it. */
export interface RulesV2SaveError {
    field: string | null
    message: string
}

export interface RulesV2WriteBody {
    key: string
    name: string
    tags: string[]
    filters: FeatureFlagRulesV2DraftConfig
    version?: number
}

export const NEW_RULES_V2_DRAFT: FeatureFlagRulesV2Draft = {
    key: '',
    name: '',
    tags: [],
    config: { version: 2, return_type: 'boolean', default_value: false, rules: [] },
    version: null,
}

// React keys for rule cards: new rules have no id, and index keys would follow a moved rule's position.
let lastRuleKey = 0
const nextRuleKey = (): number => ++lastRuleKey

/** The draft holds the stored document as loaded, seeds and unrendered fields included, so a save echoes them. */
export function rulesV2DraftFromFlag(flag: FeatureFlagType): FeatureFlagRulesV2Draft {
    if (!isRulesV2FeatureFlagConfig(flag.filters)) {
        return NEW_RULES_V2_DRAFT
    }
    return {
        key: flag.key,
        name: flag.name ?? '',
        tags: flag.tags ?? [],
        config: flag.filters,
        version: flag.version,
    }
}

/** A create carries no row version; an update replaces the whole document and must carry it. */
export function rulesV2WriteBody(draft: FeatureFlagRulesV2Draft): RulesV2WriteBody {
    return {
        key: draft.key,
        name: draft.name,
        tags: draft.tags,
        filters: draft.config,
        ...(draft.version != null ? { version: draft.version } : {}),
    }
}

const RULE_FIELDS = [
    'rule_type',
    'description',
    'targeting',
    'value',
    'rollout_percentage',
    'on_rollout_miss',
    'paused',
    'seed',
    'variants',
    'variants[]',
    'variants[].key',
    'variants[].weight',
    'variants[].value',
    'holdout',
    'holdout.exclusion_percentage',
    'holdout.seed',
]
// The paths, with list indices removed, that the editor shows an error against.
const EDITOR_FIELDS = new Set([
    'key',
    'name',
    'tags',
    'filters.return_type',
    'filters.default_value',
    'filters.rules[]',
    ...RULE_FIELDS.map((field) => `filters.rules[].${field}`),
])

/** The longest prefix of `path` that the editor has a field for, so a nested error lands on its nearest field. */
function editorField(path: string): string | null {
    let prefix: string | undefined = path
    while (prefix) {
        if (EDITOR_FIELDS.has(prefix.replace(/\[\d+\]/g, '[]'))) {
            return prefix
        }
        prefix = /^(.+)(?:\.\w+|\[\d+\])$/.exec(prefix)?.[1]
    }
    return null
}

/** `attr` joins nested keys with `__`; a document path that is not the input's own stays in the message. */
export function rulesV2SaveError(error: any): RulesV2SaveError {
    const detail = readableErrorMessage(error) ?? 'This flag could not be saved.'
    if (error?.code === 'unknown_field') {
        // The server keeps client key names out of `attr`, but this editor sends only its own keys.
        return { field: editorField(detail.split(': ', 1)[0]), message: detail }
    }
    const attr: string | null = error?.attr || null
    const path = attr ? attr.replace(/__(\d+)(?=__|$)/g, '[$1]').replace(/__/g, '.') : null
    const field = path ? editorField(path) : null
    const named = path !== null && path !== field && (field !== null || path.startsWith('filters.'))
    return { field, message: named ? `${path}: ${detail}` : detail }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface featureFlagRulesV2EditorLogicValues {
    enabledFeatures: FeatureFlagsSet // featureFlagLogic
    featureFlag: FeatureFlagType // featureFlagLogic
    currentProjectId: number | null // projectLogic
    currentTeam: TeamPublicType | TeamType | null // teamLogic
    draft: FeatureFlagRulesV2Draft
    draftErrors: Record<string, string>
    fieldError: (field: string) => string | null
    hasUnsavedChanges: boolean
    ruleKeys: number[]
    rules: FeatureFlagRulesV2DraftRule[]
    saveDisabledReason: string | null
    saveError: RulesV2SaveError | null
    saving: boolean
    shadowingRules: (number | null)[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface featureFlagRulesV2EditorLogicActions {
    editFeatureFlag: (
        editing: boolean,
        options?:
            | {
                  expandAdvanced?: boolean
              }
            | undefined
    ) => {
        editing: boolean
        expandAdvanced: boolean
    } // featureFlagLogic
    loadFeatureFlagSuccess: (
        featureFlag: FeatureFlagType,
        payload?: any
    ) => {
        featureFlag: FeatureFlagType
        payload?: any
    } // featureFlagLogic
    refreshFeatureFlag: (
        payload?:
            | {
                  afterAgentChange?: boolean
              }
            | undefined
    ) => {
        afterAgentChange?: boolean
    } // featureFlagLogic
    setRulesV2DraftDirty: (dirty: boolean) => {
        dirty: boolean
    } // featureFlagLogic
    addRule: (ruleType?: FeatureFlagRulesV2DraftRule['rule_type']) => {
        ruleType: 'experiment' | 'percentage_rollout' | 'targeted_release'
    }
    duplicateRule: (index: number) => {
        index: number
    }
    loadDraft: (draft: FeatureFlagRulesV2Draft) => {
        draft: FeatureFlagRulesV2Draft
    }
    moveRule: (
        from: number,
        to: number
    ) => {
        from: number
        to: number
    }
    removeRule: (index: number) => {
        index: number
    }
    saveRulesV2Flag: () => {
        value: true
    }
    saveRulesV2FlagFailure: (error: RulesV2SaveError | null) => {
        error: RulesV2SaveError | null
    }
    saveRulesV2FlagSuccess: (flag: FeatureFlagType) => {
        flag: FeatureFlagType
    }
    setConfig: (config: Partial<FeatureFlagRulesV2DraftConfig>) => {
        config: Partial<FeatureFlagRulesV2DraftConfig>
    }
    setDraft: (draft: Partial<FeatureFlagRulesV2Draft>) => {
        draft: Partial<FeatureFlagRulesV2Draft>
    }
    setReturnType: (returnType: FeatureFlagRulesV2ReturnType) => {
        returnType: FeatureFlagRulesV2ReturnType
    }
    setRule: (
        index: number,
        rule: FeatureFlagRulesV2DraftRule
    ) => {
        index: number
        rule: FeatureFlagRulesV2DraftRule
    }
    submitRulesV2Flag: () => {
        value: true
    }
    updateRule: (
        index: number,
        rule: FeatureFlagRulesV2DraftRule
    ) => {
        index: number
        rule: FeatureFlagRulesV2DraftRule
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface featureFlagRulesV2EditorLogicMeta {
    key: number | 'link' | 'new'
    __keaTypeGenInternalSelectorTypes: {
        draftErrors: (draft: FeatureFlagRulesV2Draft) => Record<string, string>
        rules: (draft: FeatureFlagRulesV2Draft) => FeatureFlagRulesV2DraftRule[]
        shadowingRules: (rules: FeatureFlagRulesV2DraftRule[]) => (number | null)[]
        fieldError: (
            saveError: RulesV2SaveError | null,
            draftErrors: Record<string, string>
        ) => (field: string) => string | null
        saveDisabledReason: (
            draft: FeatureFlagRulesV2Draft,
            draftErrors: Record<string, string>,
            currentTeam: TeamPublicType | TeamType | null,
            enabledFeatures: FeatureFlagsSet,
            hasUnsavedChanges: boolean,
            id: number | 'link' | 'new'
        ) => string | null
    }
}

export type featureFlagRulesV2EditorLogicType = MakeLogicType<
    featureFlagRulesV2EditorLogicValues,
    featureFlagRulesV2EditorLogicActions,
    FeatureFlagLogicProps,
    featureFlagRulesV2EditorLogicMeta
>

export const featureFlagRulesV2EditorLogic = kea<featureFlagRulesV2EditorLogicType>([
    path(['scenes', 'feature-flags', 'featureFlagRulesV2EditorLogic']),
    props({} as FeatureFlagLogicProps),
    key(({ id }) => id),
    connect((props: FeatureFlagLogicProps) => ({
        values: [
            featureFlagLogic(props),
            ['featureFlag', 'enabledFeatures'],
            projectLogic,
            ['currentProjectId'],
            teamLogic,
            ['currentTeam'],
        ],
        actions: [
            featureFlagLogic(props),
            ['editFeatureFlag', 'loadFeatureFlagSuccess', 'refreshFeatureFlag', 'setRulesV2DraftDirty'],
        ],
    })),
    actions({
        loadDraft: (draft: FeatureFlagRulesV2Draft) => ({ draft }),
        setDraft: (draft: Partial<FeatureFlagRulesV2Draft>) => ({ draft }),
        setConfig: (config: Partial<FeatureFlagRulesV2DraftConfig>) => ({ config }),
        setReturnType: (returnType: FeatureFlagRulesV2ReturnType) => ({ returnType }),
        addRule: (ruleType: FeatureFlagRulesV2DraftRule['rule_type'] = 'targeted_release') => ({ ruleType }),
        duplicateRule: (index: number) => ({ index }),
        updateRule: (index: number, rule: FeatureFlagRulesV2DraftRule) => ({ index, rule }),
        setRule: (index: number, rule: FeatureFlagRulesV2DraftRule) => ({ index, rule }),
        removeRule: (index: number) => ({ index }),
        moveRule: (from: number, to: number) => ({ from, to }),
        saveRulesV2Flag: true,
        submitRulesV2Flag: true,
        saveRulesV2FlagSuccess: (flag: FeatureFlagType) => ({ flag }),
        saveRulesV2FlagFailure: (error: RulesV2SaveError | null) => ({ error }),
    }),
    reducers({
        draft: [
            NEW_RULES_V2_DRAFT,
            {
                loadDraft: (_, { draft }) => draft,
                setDraft: (state, { draft }) => ({ ...state, ...draft }),
                setConfig: (state, { config }) => ({ ...state, config: { ...state.config, ...config } }),
                setReturnType: (state, { returnType }) => ({
                    ...state,
                    config: withReturnType(state.config, returnType),
                }),
                addRule: (state, { ruleType }) => ({
                    ...state,
                    config: {
                        ...state.config,
                        rules: [...state.config.rules, newRulesV2Rule(ruleType, state.config.return_type)],
                    },
                }),
                duplicateRule: (state, { index }) => ({
                    ...state,
                    config: {
                        ...state.config,
                        rules: insertedAfter(state.config.rules, index, duplicatedRule(state.config.rules[index])),
                    },
                }),
                setRule: (state, { index, rule }) => ({
                    ...state,
                    config: { ...state.config, rules: state.config.rules.map((r, i) => (i === index ? rule : r)) },
                }),
                removeRule: (state, { index }) => ({
                    ...state,
                    config: { ...state.config, rules: state.config.rules.filter((_, i) => i !== index) },
                }),
                moveRule: (state, { from, to }) => ({
                    ...state,
                    config: { ...state.config, rules: moved(state.config.rules, from, to) },
                }),
            },
        ],
        ruleKeys: [
            [] as number[],
            {
                loadDraft: (_, { draft }) => draft.config.rules.map(nextRuleKey),
                setDraft: (state, { draft }) => (draft.config ? draft.config.rules.map(nextRuleKey) : state),
                setConfig: (state, { config }) => (config.rules ? config.rules.map(nextRuleKey) : state),
                addRule: (state) => [...state, nextRuleKey()],
                duplicateRule: (state, { index }) => insertedAfter(state, index, nextRuleKey()),
                removeRule: (state, { index }) => state.filter((_, i) => i !== index),
                moveRule: (state, { from, to }) => moved(state, from, to),
            },
        ],
        // Rule indices shift on any edit, so an error is only shown against the document it came from.
        saveError: [
            null as RulesV2SaveError | null,
            {
                saveRulesV2FlagFailure: (_, { error }) => error,
                saveRulesV2Flag: () => null,
                setDraft: () => null,
                setConfig: () => null,
                setReturnType: () => null,
                addRule: () => null,
                duplicateRule: () => null,
                setRule: () => null,
                removeRule: () => null,
                moveRule: () => null,
            },
        ],
        hasUnsavedChanges: [
            false,
            {
                loadDraft: () => false,
                saveRulesV2FlagSuccess: () => false,
                setDraft: () => true,
                setConfig: () => true,
                setReturnType: () => true,
                addRule: () => true,
                duplicateRule: () => true,
                setRule: () => true,
                removeRule: () => true,
                moveRule: () => true,
            },
        ],
        saving: [
            false,
            {
                submitRulesV2Flag: () => true,
                saveRulesV2FlagSuccess: () => false,
                saveRulesV2FlagFailure: () => false,
            },
        ],
    }),
    selectors({
        draftErrors: [
            (s) => [s.draft],
            (draft: FeatureFlagRulesV2Draft): Record<string, string> => rulesV2DraftErrors(draft.config),
            { resultEqualityCheck: objectsEqual },
        ],
        rules: [
            (s) => [s.draft],
            (draft: FeatureFlagRulesV2Draft): FeatureFlagRulesV2DraftRule[] => draft.config.rules,
        ],
        shadowingRules: [
            (s) => [s.rules],
            (rules: FeatureFlagRulesV2DraftRule[]): (number | null)[] => rulesV2ShadowingRules(rules),
        ],
        // The server's error wins: it is about the document as it was sent.
        fieldError: [
            (s) => [s.saveError, s.draftErrors],
            (saveError: RulesV2SaveError | null, draftErrors: Record<string, string>) =>
                (field: string): string | null =>
                    saveError?.field === field ? saveError.message : (draftErrors[field] ?? null),
        ],
        saveDisabledReason: [
            (s, p) => [s.draft, s.draftErrors, s.currentTeam, s.enabledFeatures, s.hasUnsavedChanges, p.id],
            (
                draft: FeatureFlagRulesV2Draft,
                draftErrors: Record<string, string>,
                currentTeam: TeamPublicType | TeamType | null,
                enabledFeatures: FeatureFlagsSet,
                hasUnsavedChanges: boolean,
                id: FeatureFlagLogicProps['id']
            ): string | null => {
                // The list disables this entry point, but a direct link still opens the editor.
                const createDisabledReason =
                    id === 'new' ? rulesV2CreateDisabledReason(currentTeam, enabledFeatures) : null
                if (createDisabledReason) {
                    return createDisabledReason
                }
                const keyError = validateFeatureFlagKey(draft.key)
                if (keyError) {
                    return keyError
                }
                const [firstErrorField, firstError] = Object.entries(draftErrors)[0] ?? []
                if (firstErrorField) {
                    const ruleIndex = /^filters\.rules\[(\d+)\]/.exec(firstErrorField)?.[1]
                    return ruleIndex === undefined
                        ? `Default value: ${firstError}`
                        : `Rule ${Number(ruleIndex) + 1}: ${firstError}`
                }
                const emptyConditionIndex = draft.config.rules.findIndex((rule) =>
                    rule.targeting.properties.some(isIncompleteRulesV2Condition)
                )
                if (emptyConditionIndex >= 0) {
                    return `Choose a value for every condition in rule ${emptyConditionIndex + 1}.`
                }
                return id !== 'new' && !hasUnsavedChanges ? 'Nothing to save yet.' : null
            },
        ],
    }),
    listeners(({ actions, values, props }) => ({
        // Inputs such as PercentageInput report a change on every blur, and an unchanged rule is not an edit.
        updateRule: ({ index, rule }) => {
            if (!objectsEqual(values.draft.config.rules[index], rule)) {
                actions.setRule(index, rule)
            }
        },
        saveRulesV2Flag: async () => {
            const storedFlag = values.featureFlag
            if (
                storedFlag.id &&
                storedFlag.key !== values.draft.key &&
                !(await confirmFeatureFlagKeyChange(storedFlag.key))
            ) {
                return
            }
            // The server does not enforce the project's confirmation setting, so this check is the only gate.
            // The draft holds the stored seeds, so only a real edit differs from the stored document.
            const confirmationEnabled = !!values.currentTeam?.feature_flag_confirmation_enabled
            const confirmationShown = checkFeatureFlagConfirmation(
                storedFlag,
                { ...storedFlag, key: values.draft.key, filters: values.draft.config as FeatureFlagConfig },
                confirmationEnabled,
                confirmationEnabled ? values.currentTeam?.feature_flag_confirmation_message : undefined,
                confirmationEnabled,
                actions.submitRulesV2Flag
            )
            if (!confirmationShown) {
                actions.submitRulesV2Flag()
            }
        },
        submitRulesV2Flag: async () => {
            const projectId = String(values.currentProjectId)
            const body = rulesV2WriteBody(values.draft)
            try {
                // The wire types describe the v1 document; the v2 document travels under the same `filters` key.
                const saved =
                    props.id === 'new'
                        ? await featureFlagsCreate(projectId, body as unknown as FeatureFlagCreateRequestSchemaApi)
                        : await featureFlagsPartialUpdate(
                              projectId,
                              props.id as number,
                              body as unknown as PatchedFeatureFlagPartialUpdateRequestSchemaApi
                          )
                actions.saveRulesV2FlagSuccess(saved as unknown as FeatureFlagType)
            } catch (error: any) {
                if (isStaleRowVersionError(body, error)) {
                    lemonToast.error(
                        'This flag changed while you were editing it. It has been reloaded; your edits were not saved.'
                    )
                    actions.saveRulesV2FlagFailure(null)
                    actions.editFeatureFlag(false)
                    actions.refreshFeatureFlag()
                    return
                }
                const saveError = rulesV2SaveError(error)
                actions.saveRulesV2FlagFailure(saveError)
                // The inline error can sit off-screen and is not announced, so a toast reports the rejection too.
                lemonToast.error(`Flag not saved: ${saveError.message}`)
            }
        },
        saveRulesV2FlagSuccess: ({ flag }) => {
            lemonToast.success(props.id === 'new' ? 'Flag created' : 'Flag saved')
            if (flag.id) {
                refreshTreeItem('feature_flag', String(flag.id))
            }
            if (props.id === 'new') {
                router.actions.push(urls.featureFlag(flag.id ?? 'new'))
                return
            }
            // The response is the stored flag, so the page takes it without a second request.
            actions.loadFeatureFlagSuccess(variantKeyToIndexFeatureFlagPayloads(flag))
            actions.editFeatureFlag(false)
        },
    })),
    // featureFlagLogic resets the page on a same-URL navigation unless it knows the draft is dirty.
    subscriptions(({ actions }) => ({
        hasUnsavedChanges: (dirty: boolean) => actions.setRulesV2DraftDirty(dirty),
    })),
    beforeUnmount(({ actions }) => actions.setRulesV2DraftDirty(false)),
    beforeUnload(({ values }) => ({
        // In-page URL updates such as opening the side panel keep the pathname and the draft.
        enabled: (newLocation?: CombinedLocation) =>
            values.hasUnsavedChanges && newLocation?.pathname !== router.values.location.pathname,
        message: 'Leave this flag?\nChanges you made will be discarded.',
    })),
    afterMount(({ actions, values, props }) => {
        if (typeof props.id === 'number') {
            actions.loadDraft(rulesV2DraftFromFlag(values.featureFlag))
        } else if (props.id === 'new') {
            const key = prefilledFlagKey(router.values.searchParams.key)
            if (key) {
                actions.loadDraft({ ...NEW_RULES_V2_DRAFT, key })
            }
        }
    }),
])