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.

20.0 KB
Raw Blame
import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import type { PostHog } from 'posthog-js'

import { createFuse } from 'lib/utils/fuseSearch'
import { permanentlyMount } from 'lib/utils/kea-logic-builders'

import { toolbarApi } from '~/toolbar/shared/toolbarApi'
import { toolbarConfigLogic } from '~/toolbar/shared/toolbarConfigLogic'
import { toolbarLogger } from '~/toolbar/shared/toolbarLogger'
import { captureToolbarException, toolbarPosthogJS } from '~/toolbar/shared/toolbarPosthogJS'
import { CombinedFeatureFlagAndValueType } from '~/types'

import type { FeatureFlagType } from '../../../types'

export type PayloadOverrides = Record<string, any>

type EvaluationReasonsResponse = Record<
    string,
    { value: boolean | string; evaluation: { reason: string; condition_index: number | null } }
>

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagsToolbarLogicValues {
    posthog: PostHog | null // toolbarConfigLogic
    countFlagsOverridden: number
    draftDistinctId: string
    draftPayloads: Record<string, string>
    filteredFlags: {
        currentValue: boolean | string
        feature_flag: FeatureFlagType
        hasOverride: boolean
        hasVariants: boolean
        payloadOverride: any
        value: boolean | string
    }[]
    impersonatedDistinctId: string | null
    impersonatedFlagValues: Record<string, boolean | string> | null
    impersonationOpen: boolean
    localOverrides: Record<string, boolean | string>
    openPayloadEditors: Record<string, boolean>
    payloadErrors: Record<string, string | null>
    payloadOverrides: PayloadOverrides
    posthogClientFlagValues: Record<string, boolean | string>
    searchTerm: string
    userFlags: CombinedFeatureFlagAndValueType[]
    userFlagsLoading: boolean
    userFlagsWithOverrideInfo: {
        currentValue: boolean | string
        feature_flag: FeatureFlagType
        hasOverride: boolean
        hasVariants: boolean
        payloadOverride: any
        value: boolean | string
    }[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagsToolbarLogicActions {
    logout: () => {
        value: true
    } // toolbarConfigLogic
    tokenExpired: () => {
        value: true
    } // toolbarConfigLogic
    checkLocalOverrides: () => {
        value: true
    }
    clearAllOverrides: () => {
        value: true
    }
    clearImpersonation: () => {
        value: true
    }
    deleteOverriddenUserFlag: (flagKey: string) => {
        flagKey: string
    }
    getUserFlags: () => {
        value: true
    }
    getUserFlagsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    getUserFlagsSuccess: (
        userFlags: CombinedFeatureFlagAndValueType[],
        payload?: {
            value: true
        }
    ) => {
        userFlags: CombinedFeatureFlagAndValueType[]
        payload?: {
            value: true
        }
    }
    loadFlagsForDistinctId: (distinctId: string) => {
        distinctId: string
    }
    savePayloadOverride: (flagKey: string) => {
        flagKey: string
    }
    setDraftDistinctId: (draftDistinctId: string) => {
        draftDistinctId: string
    }
    setDraftPayload: (
        flagKey: string,
        draftPayload: string
    ) => {
        draftPayload: string
        flagKey: string
    }
    setFeatureFlagValueFromPostHogClient: (
        flags: string[],
        variants: Record<string, boolean | string>
    ) => {
        flags: string[]
        variants: Record<string, boolean | string>
    }
    setImpersonatedFlagValues: (flagValues: Record<string, boolean | string>) => {
        flagValues: Record<string, boolean | string>
    }
    setImpersonationOpen: (isOpen: boolean) => {
        isOpen: boolean
    }
    setOverriddenUserFlag: (
        flagKey: string,
        overrideValue: boolean | string,
        payloadOverride?: PayloadOverrides
    ) => {
        flagKey: string
        overrideValue: boolean | string
        payloadOverride: PayloadOverrides | undefined
    }
    setPayloadEditorOpen: (
        flagKey: string,
        isOpen: boolean
    ) => {
        flagKey: string
        isOpen: boolean
    }
    setPayloadError: (
        flagKey: string,
        error: string | null
    ) => {
        error: string | null
        flagKey: string
    }
    setPayloadOverride: (
        flagKey: string,
        payload: any
    ) => {
        flagKey: string
        payload: any
    }
    setSearchTerm: (searchTerm: string) => {
        searchTerm: string
    }
    storeLocalOverrides: (localOverrides: Record<string, boolean | string>) => {
        localOverrides: Record<string, boolean | string>
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface flagsToolbarLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        userFlagsWithOverrideInfo: (
            userFlags: CombinedFeatureFlagAndValueType[],
            localOverrides: Record<string, boolean | string>,
            posthogClientFlagValues: Record<string, boolean | string>,
            payloadOverrides: PayloadOverrides,
            impersonatedFlagValues: Record<string, boolean | string> | null
        ) => {
            currentValue: boolean | string
            feature_flag: FeatureFlagType
            hasOverride: boolean
            hasVariants: boolean
            payloadOverride: any
            value: boolean | string
        }[]
        filteredFlags: (
            searchTerm: string,
            userFlagsWithOverrideInfo: {
                currentValue: boolean | string
                feature_flag: FeatureFlagType
                hasOverride: boolean
                hasVariants: boolean
                payloadOverride: any
                value: boolean | string
            }[]
        ) => {
            currentValue: boolean | string
            feature_flag: FeatureFlagType
            hasOverride: boolean
            hasVariants: boolean
            payloadOverride: any
            value: boolean | string
        }[]
        countFlagsOverridden: (localOverrides: Record<string, boolean | string>) => number
    }
}

export type flagsToolbarLogicType = MakeLogicType<
    flagsToolbarLogicValues,
    flagsToolbarLogicActions,
    Record<string, any>,
    flagsToolbarLogicMeta
>

export const flagsToolbarLogic = kea<flagsToolbarLogicType>([
    path(['toolbar', 'flags', 'flagsToolbarLogic']),
    connect(() => ({
        values: [toolbarConfigLogic, ['posthog']],
        actions: [toolbarConfigLogic, ['logout', 'tokenExpired']],
    })),
    actions({
        getUserFlags: true,
        setFeatureFlagValueFromPostHogClient: (flags: string[], variants: Record<string, string | boolean>) => ({
            flags,
            variants,
        }),
        setOverriddenUserFlag: (
            flagKey: string,
            overrideValue: string | boolean,
            payloadOverride?: PayloadOverrides
        ) => ({
            flagKey,
            overrideValue,
            payloadOverride,
        }),
        setPayloadOverride: (flagKey: string, payload: any) => ({ flagKey, payload }),
        deleteOverriddenUserFlag: (flagKey: string) => ({ flagKey }),
        setSearchTerm: (searchTerm: string) => ({ searchTerm }),
        checkLocalOverrides: true,
        storeLocalOverrides: (localOverrides: Record<string, string | boolean>) => ({ localOverrides }),
        setDraftPayload: (flagKey: string, draftPayload: string) => ({ flagKey, draftPayload }),
        savePayloadOverride: (flagKey: string) => ({ flagKey }),
        setPayloadError: (flagKey: string, error: string | null) => ({ flagKey, error }),
        setPayloadEditorOpen: (flagKey: string, isOpen: boolean) => ({ flagKey, isOpen }),
        clearAllOverrides: true,
        // Impersonation: view flags as a different user
        loadFlagsForDistinctId: (distinctId: string) => ({ distinctId }),
        setImpersonatedFlagValues: (flagValues: Record<string, string | boolean>) => ({ flagValues }),
        clearImpersonation: true,
        setDraftDistinctId: (draftDistinctId: string) => ({ draftDistinctId }),
        setImpersonationOpen: (isOpen: boolean) => ({ isOpen }),
    }),
    loaders(({ values }) => ({
        userFlags: [
            [] as CombinedFeatureFlagAndValueType[],
            {
                getUserFlags: async (_, breakpoint) => {
                    const result = await toolbarApi.featureFlags.myFlags(
                        { groups: getGroups(values.posthog) },
                        { context: 'load_user_flags' }
                    )

                    breakpoint()
                    if (!result.ok) {
                        return values.userFlags
                    }
                    return result.data
                },
            },
        ],
    })),
    reducers({
        localOverrides: [
            {} as Record<string, string | boolean>,
            {
                storeLocalOverrides: (_, { localOverrides }) => localOverrides,
            },
        ],
        searchTerm: [
            '',
            {
                setSearchTerm: (_, { searchTerm }) => searchTerm,
            },
        ],
        posthogClientFlagValues: [
            {} as Record<string, string | boolean>,
            {
                setFeatureFlagValueFromPostHogClient: (_, { variants }) => {
                    return variants
                },
            },
        ],
        payloadOverrides: [
            {} as PayloadOverrides,
            {
                setPayloadOverride: (state, { flagKey, payload }) => ({
                    ...state,
                    [flagKey]: payload,
                }),
                deleteOverriddenUserFlag: (state, { flagKey }) => {
                    const newState = { ...state }
                    delete newState[flagKey]
                    return newState
                },
            },
        ],
        draftPayloads: [
            {} as Record<string, string>,
            {
                setDraftPayload: (state, { flagKey, draftPayload }) => ({
                    ...state,
                    [flagKey]: draftPayload,
                }),
                deleteOverriddenUserFlag: (state, { flagKey }) => {
                    const newState = { ...state }
                    delete newState[flagKey]
                    return newState
                },
            },
        ],
        payloadErrors: [
            {} as Record<string, string | null>,
            {
                setPayloadError: (state, { flagKey, error }) => ({
                    ...state,
                    [flagKey]: error,
                }),
                setDraftPayload: (state, { flagKey }) => ({
                    ...state,
                    [flagKey]: null,
                }),
            },
        ],
        openPayloadEditors: [
            {} as Record<string, boolean>,
            {
                setPayloadEditorOpen: (state, { flagKey, isOpen }) => ({
                    ...state,
                    [flagKey]: isOpen,
                }),
                deleteOverriddenUserFlag: (state, { flagKey }) => {
                    const newState = { ...state }
                    delete newState[flagKey]
                    return newState
                },
            },
        ],
        impersonatedDistinctId: [
            null as string | null,
            {
                loadFlagsForDistinctId: (_, { distinctId }) => distinctId,
                clearImpersonation: () => null,
                clearAllOverrides: () => null,
            },
        ],
        impersonatedFlagValues: [
            null as Record<string, string | boolean> | null,
            {
                setImpersonatedFlagValues: (_, { flagValues }) => flagValues,
                clearImpersonation: () => null,
                clearAllOverrides: () => null,
            },
        ],
        draftDistinctId: [
            '',
            {
                setDraftDistinctId: (_, { draftDistinctId }) => draftDistinctId,
                loadFlagsForDistinctId: () => '',
            },
        ],
        impersonationOpen: [
            false,
            {
                setImpersonationOpen: (_, { isOpen }) => isOpen,
                clearImpersonation: () => false,
            },
        ],
    }),
    selectors({
        userFlagsWithOverrideInfo: [
            (s) => [
                s.userFlags,
                s.localOverrides,
                s.posthogClientFlagValues,
                s.payloadOverrides,
                s.impersonatedFlagValues,
            ],
            (
                userFlags: CombinedFeatureFlagAndValueType[],
                localOverrides: Record<string, boolean | string>,
                posthogClientFlagValues: Record<string, boolean | string>,
                payloadOverrides: PayloadOverrides,
                impersonatedFlagValues: Record<string, boolean | string> | null
            ) => {
                return userFlags.map((flag) => {
                    const hasVariants = (flag.feature_flag.filters?.multivariate?.variants?.length || 0) > 0

                    const baseValue = impersonatedFlagValues
                        ? (impersonatedFlagValues[flag.feature_flag.key] ?? false)
                        : (posthogClientFlagValues[flag.feature_flag.key] ?? flag.value)

                    const currentValue =
                        flag.feature_flag.key in localOverrides ? localOverrides[flag.feature_flag.key] : baseValue

                    return {
                        ...flag,
                        hasVariants,
                        currentValue,
                        hasOverride: flag.feature_flag.key in localOverrides,
                        payloadOverride: payloadOverrides[flag.feature_flag.key],
                    }
                })
            },
        ],
        filteredFlags: [
            (s) => [s.searchTerm, s.userFlagsWithOverrideInfo],
            (
                searchTerm: string,
                userFlagsWithOverrideInfo: {
                    currentValue: boolean | string
                    feature_flag: import('~/types').FeatureFlagType
                    hasOverride: boolean
                    hasVariants: boolean
                    payloadOverride: any
                    value: boolean | string
                }[]
            ) => {
                return searchTerm
                    ? createFuse(userFlagsWithOverrideInfo, {
                          keys: ['feature_flag.key', 'feature_flag.name'],
                      })
                          .search(searchTerm)
                          .map(({ item }) => item)
                    : userFlagsWithOverrideInfo
            },
        ],
        countFlagsOverridden: [
            (s) => [s.localOverrides],
            (localOverrides: Record<string, boolean | string>) => Object.keys(localOverrides).length,
        ],
    }),
    listeners(({ actions, values }) => {
        const clearFeatureFlagOverrides = (): void => {
            const clientPostHog = values.posthog
            if (clientPostHog) {
                clientPostHog.featureFlags.overrideFeatureFlags(false)
                clientPostHog.featureFlags.reloadFeatureFlags()
                actions.storeLocalOverrides({})
            }
        }

        return {
            checkLocalOverrides: () => {
                const clientPostHog = values.posthog
                if (clientPostHog) {
                    const locallyOverrideFeatureFlags = clientPostHog.get_property('$override_feature_flags') || {}
                    actions.storeLocalOverrides(locallyOverrideFeatureFlags)
                }
            },
            setOverriddenUserFlag: ({ flagKey, overrideValue, payloadOverride }) => {
                const clientPostHog = values.posthog
                if (clientPostHog) {
                    const payloads = payloadOverride ? { [flagKey]: payloadOverride } : undefined
                    clientPostHog.featureFlags.overrideFeatureFlags({
                        flags: { ...values.localOverrides, [flagKey]: overrideValue },
                        payloads: payloads,
                    })
                    toolbarPosthogJS.capture('toolbar feature flag overridden')
                    actions.checkLocalOverrides()
                    if (payloadOverride) {
                        actions.setPayloadOverride(flagKey, payloadOverride)
                    }
                    clientPostHog.featureFlags.reloadFeatureFlags()
                }
            },
            deleteOverriddenUserFlag: ({ flagKey }) => {
                const clientPostHog = values.posthog
                if (clientPostHog) {
                    const updatedFlags = { ...values.localOverrides }
                    delete updatedFlags[flagKey]
                    if (Object.keys(updatedFlags).length > 0) {
                        clientPostHog.featureFlags.overrideFeatureFlags({ flags: updatedFlags })
                    } else {
                        clientPostHog.featureFlags.overrideFeatureFlags(false)
                    }
                    toolbarPosthogJS.capture('toolbar feature flag override removed')
                    actions.checkLocalOverrides()
                    clientPostHog.featureFlags.reloadFeatureFlags()
                }
            },
            savePayloadOverride: ({ flagKey }) => {
                try {
                    const draftPayload = values.draftPayloads[flagKey]
                    if (!draftPayload || draftPayload.trim() === '') {
                        actions.setPayloadError(flagKey, null)
                        actions.setPayloadOverride(flagKey, null)
                        actions.setOverriddenUserFlag(flagKey, true)
                        actions.setPayloadEditorOpen(flagKey, false)
                        return
                    }

                    const payload = JSON.parse(draftPayload)
                    actions.setPayloadError(flagKey, null)
                    actions.setOverriddenUserFlag(flagKey, true, payload)
                    actions.setPayloadEditorOpen(flagKey, false)
                } catch (e) {
                    actions.setPayloadError(flagKey, 'Invalid JSON')
                    toolbarLogger.error('flags', 'Invalid JSON payload', { flag_key: flagKey })
                    captureToolbarException(e, 'flag_payload_parse', { flag_key: flagKey })
                }
            },
            loadFlagsForDistinctId: async ({ distinctId }, breakpoint) => {
                const result = await toolbarApi.featureFlags.evaluationReasons<EvaluationReasonsResponse>(distinctId, {
                    context: 'load_flags_for_distinct_id',
                })
                breakpoint()

                if (!result.ok) {
                    return
                }

                const data = result.data
                const flagValues: Record<string, string | boolean> = {}
                for (const [key, entry] of Object.entries(data)) {
                    flagValues[key] = entry.value
                }
                actions.setImpersonatedFlagValues(flagValues)

                // Apply as overrides so the page actually re-renders with these flags
                const clientPostHog = values.posthog
                if (clientPostHog) {
                    clientPostHog.featureFlags.overrideFeatureFlags({ flags: flagValues })
                    actions.checkLocalOverrides()
                }
                toolbarPosthogJS.capture('toolbar flags impersonated', { distinct_id: distinctId })
            },
            clearImpersonation: () => {
                clearFeatureFlagOverrides()
            },
            clearAllOverrides: () => {
                clearFeatureFlagOverrides()
            },
            logout: () => {
                clearFeatureFlagOverrides()
            },
            tokenExpired: () => {
                clearFeatureFlagOverrides()
            },
        }
    }),
    permanentlyMount(),
])

function getGroups(posthogInstance: PostHog | null): Record<string, any> {
    try {
        return posthogInstance?.getGroups() || {}
    } catch {
        return {}
    }
}