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.

24.1 KB
Raw Blame
import { MakeLogicType, actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { router, urlToAction } from 'kea-router'
import posthog from 'posthog-js'

import api, { ApiConfig } from 'lib/api'
import { FEATURE_FLAGS } from 'lib/constants'
import { lemonToast } from 'lib/lemon-ui/LemonToast'
import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { objectsEqual } from 'lib/utils/objects'
import { capitalizeFirstLetter } from 'lib/utils/strings'
import { getRelativeNextPath } from 'lib/utils/url'
import { Scene } from 'scenes/sceneTypes'
import { urls } from 'scenes/urls'

import { SIDE_PANEL_CONTEXT_KEY, SidePanelSceneContext } from '~/layout/navigation-3000/sidepanel/types'
import { TODAY_PEOPLE_RECENT_KEY, TodayPeopleRecent } from '~/layout/today/todayPeople'
import { groupsModel } from '~/models/groupsModel'
import { defaultDataTableColumns } from '~/queries/nodes/DataTable/utils'
import { isDataTableNode } from '~/queries/schema/node-guards'
import { DataTableNode, HogQLQuery, Node, NodeKind } from '~/queries/schema/schema-general'
import { ActivityScope, Breadcrumb, Group, GroupTypeIndex, PropertyFilterType, PropertyOperator } from '~/types'

import { CUSTOMER_ANALYTICS_DEFAULT_QUERY_TAGS } from 'products/customer_analytics/frontend/constants'
import { groupDisplayId } from 'products/persons/frontend/components/GroupActorDisplay'

import type { FeatureFlagsSet } from '../../../../frontend/src/lib/logic/featureFlagLogic'
import type { Noun } from '../../../../frontend/src/models/groupsModel'
import type { GroupType } from '../../../../frontend/src/types'
import { groupsFindRetrieve } from '../generated/api'

function reportGroupPropertyUpdated(
    action: 'added' | 'updated' | 'removed',
    totalProperties: number,
    oldPropertyType?: string,
    newPropertyType?: string
): void {
    posthog.capture(`group property ${action}`, {
        old_property_type: oldPropertyType !== 'undefined' ? oldPropertyType : undefined,
        new_property_type: newPropertyType !== 'undefined' ? newPropertyType : undefined,
        total_properties: totalProperties,
    })
}

function getGroupEventsQuery(groupTypeIndex: number, groupKey: string): DataTableNode {
    return {
        kind: NodeKind.DataTableNode,
        full: true,
        source: {
            kind: NodeKind.EventsQuery,
            select: defaultDataTableColumns(NodeKind.EventsQuery),
            after: '-24h',
            fixedProperties: [
                {
                    key: `$group_${groupTypeIndex}`,
                    value: groupKey,
                    type: PropertyFilterType.Event,
                    operator: PropertyOperator.Exact,
                },
            ],
        },
    }
}

export type GroupLogicProps = {
    groupTypeIndex: number
    groupKey: string
}

export interface GroupBackNavigation {
    url: string
    name: string
}

// `backUrl` comes from an untrusted search param; only honor it as an internal relative path so a
// crafted link can't turn the back button into an open redirect. `getRelativeNextPath` also sanitizes.
export function resolveBackNavigation(searchParams: Record<string, any>): GroupBackNavigation | null {
    const url = getRelativeNextPath(searchParams.backUrl, window.location)
    if (!url) {
        return null
    }
    const name = searchParams.backName
    return { url, name: typeof name === 'string' && name ? name : 'Back' }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface groupLogicValues {
    featureFlags: FeatureFlagsSet // featureFlagLogic
    aggregationLabel: (groupTypeIndex: number | null | undefined, deferToUserWording?: boolean) => Noun // groupsModel
    groupTypes: Map<GroupTypeIndex, GroupType> // groupsModel
    backNavigation: GroupBackNavigation | null
    backTo: Breadcrumb
    breadcrumbs: Breadcrumb[]
    effectiveLifetimeValue: {
        source: 'properties' | 'revenue-analytics' | null
        value: number | null
    }
    effectiveMRR: {
        source: 'properties' | 'revenue-analytics' | null
        value: number | null
    }
    groupData: Group | null
    groupDataLoading: boolean
    groupEventsQuery: DataTableNode | null
    groupEventsQueryIsDirty: boolean
    groupRevenueAnalyticsData: {
        lifetimeValue: number | null
        mrr: number | null
    } | null
    groupRevenueAnalyticsDataLoading: boolean
    groupTab: string | null
    groupType: string | null
    groupTypeDetailDashboard: number | null
    groupTypeName: string
    groupTypeNamePlural: string
    hasRevenueData: boolean
    logicProps: GroupLogicProps
    sidePanelContext: SidePanelSceneContext | null
    todayPeopleRecent: TodayPeopleRecent | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface groupLogicActions {
    createDetailDashboard: (groupTypeIndex: number) => number // groupsModel
    deleteProperty: (key: string) => {
        key: string
    }
    editProperty: (
        key: string,
        newValue?: boolean | number | string | null
    ) => {
        key: string
        newValue: boolean | number | string | null | undefined
    }
    loadGroup: () => any
    loadGroupFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadGroupRevenueAnalyticsData: () => any
    loadGroupRevenueAnalyticsDataFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadGroupRevenueAnalyticsDataSuccess: (
        groupRevenueAnalyticsData: {
            lifetimeValue: any
            mrr: any
        } | null,
        payload?: any
    ) => {
        groupRevenueAnalyticsData: {
            lifetimeValue: any
            mrr: any
        } | null
        payload?: any
    }
    loadGroupSuccess: (
        groupData: Group,
        payload?: any
    ) => {
        groupData: Group
        payload?: any
    }
    resetGroupEventsQuery: () => {
        value: true
    }
    setGroupData: (group: Group) => {
        group: Group
    }
    setGroupEventsQuery: (query: Node) => {
        query: Node<Record<string, any>>
    }
    setGroupTab: (groupTab: string | null) => {
        groupTab: string | null
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface groupLogicMeta {
    key: string
    __keaTypeGenInternalSelectorTypes: {
        logicProps: (arg: any) => GroupLogicProps
        groupEventsQueryIsDirty: (
            groupEventsQuery: DataTableNode | null,
            groupTypeIndex: number,
            groupKey: string
        ) => boolean
        groupTypeName: (
            aggregationLabel: (groupTypeIndex: number | null | undefined, deferToUserWording?: boolean) => Noun, // groupsModel
            groupTypeIndex: number
        ) => string
        groupTypeNamePlural: (
            aggregationLabel: (groupTypeIndex: number | null | undefined, deferToUserWording?: boolean) => Noun, // groupsModel
            groupTypeIndex: number
        ) => string
        groupType: (groupTypes: Map<GroupTypeIndex, GroupType>, groupTypeIndex: number) => string | null
        groupTypeDetailDashboard: (groupTypes: Map<GroupTypeIndex, GroupType>, groupTypeIndex: number) => number | null
        effectiveMRR: (
            groupRevenueAnalyticsData: {
                lifetimeValue: number | null
                mrr: number | null
            } | null,
            groupData: Group | null
        ) => {
            source: 'properties' | 'revenue-analytics' | null
            value: number | null
        }
        effectiveLifetimeValue: (
            groupRevenueAnalyticsData: {
                lifetimeValue: number | null
                mrr: number | null
            } | null,
            groupData: Group | null
        ) => {
            source: 'properties' | 'revenue-analytics' | null
            value: number | null
        }
        hasRevenueData: (
            effectiveMRR: {
                source: 'properties' | 'revenue-analytics' | null
                value: number | null
            },
            effectiveLifetimeValue: {
                source: 'properties' | 'revenue-analytics' | null
                value: number | null
            }
        ) => boolean
        backNavigation: (searchParams: Record<string, any>) => GroupBackNavigation | null
        backTo: (
            aggregationLabel: (groupTypeIndex: number | null | undefined, deferToUserWording?: boolean) => Noun, // groupsModel
            groupTypeIndex: number,
            backNavigation: GroupBackNavigation | null
        ) => Breadcrumb
        todayPeopleRecent: (
            groupTypeIndex: number,
            groupKey: string,
            groupData: Group | null
        ) => TodayPeopleRecent | null
        breadcrumbs: (
            groupTypeName: string,
            groupTypeIndex: number,
            groupKey: string,
            groupData: Group | null
        ) => Breadcrumb[]
        sidePanelContext: (
            groupTypeIndex: number,
            groupKey: string,
            featureFlags: FeatureFlagsSet
        ) => SidePanelSceneContext | null
    }
}

export type groupLogicType = MakeLogicType<groupLogicValues, groupLogicActions, GroupLogicProps, groupLogicMeta>

export const groupLogic = kea<groupLogicType>([
    props({} as GroupLogicProps),
    key(({ groupKey, groupTypeIndex }) => `${groupTypeIndex}-${groupKey}`),
    path((key) => ['scenes', 'groups', 'groupLogic', key]),
    connect(() => ({
        actions: [groupsModel, ['createDetailDashboard']],
        values: [groupsModel, ['groupTypes', 'aggregationLabel'], featureFlagLogic, ['featureFlags']],
    })),
    actions(() => ({
        setGroupData: (group: Group) => ({ group }),
        setGroupTab: (groupTab: string | null) => ({ groupTab }),
        setGroupEventsQuery: (query: Node) => ({ query }),
        resetGroupEventsQuery: true,
        editProperty: (key: string, newValue?: string | number | boolean | null) => ({ key, newValue }),
        deleteProperty: (key: string) => ({ key }),
    })),
    loaders(({ props }) => ({
        groupData: [
            null as Group | null,
            {
                loadGroup: async (): Promise<Group> => {
                    // The generated parameter is named projectId because OpenAPI renders the
                    // path segment as {project_id}, but the groups routes register on team_id, so
                    // this takes a team id. A project id resolves the wrong environment.
                    const group = await groupsFindRetrieve(String(ApiConfig.getCurrentTeamId()), {
                        group_type_index: props.groupTypeIndex,
                        group_key: props.groupKey,
                    })
                    // Group narrows group_type_index to the five indexes a team can have.
                    return { ...group, group_type_index: group.group_type_index as GroupTypeIndex }
                },
            },
        ],
        groupRevenueAnalyticsData: [
            null as { mrr: number | null; lifetimeValue: number | null } | null,
            {
                loadGroupRevenueAnalyticsData: async () => {
                    try {
                        const response = await api.query<HogQLQuery>({
                            kind: NodeKind.HogQLQuery,
                            query: `
                                SELECT
                                    mrr,
                                    revenue as lifetimeValue
                                FROM groups_revenue_analytics
                                WHERE group_key = {groupKey}
                            `,
                            values: { groupKey: props.groupKey },
                            tags: CUSTOMER_ANALYTICS_DEFAULT_QUERY_TAGS,
                        })

                        const row = response?.results?.[0]
                        if (!row) {
                            return null
                        }

                        return {
                            mrr: row[0] ?? null,
                            lifetimeValue: row[1] ?? null,
                        }
                    } catch (error) {
                        // Silently fall back to group properties
                        posthog.captureException(error, { tag: 'group_revenue_analytics_data_query_failed' })
                        return null
                    }
                },
            },
        ],
    })),
    listeners(({ actions, values, props }) => ({
        resetGroupEventsQuery: () => {
            actions.setGroupEventsQuery(getGroupEventsQuery(props.groupTypeIndex, props.groupKey))
        },
        editProperty: async ({ key, newValue }) => {
            const group = values.groupData

            if (group) {
                let parsedValue = newValue

                // Instrumentation stuff
                let action: 'added' | 'updated'
                const oldPropertyType =
                    group.group_properties[key] === null ? 'null' : typeof group.group_properties[key]
                let newPropertyType: string = typeof newValue

                // If the property is a number, store it as a number
                const attemptedParsedNumber = Number(newValue)
                if (!Number.isNaN(attemptedParsedNumber) && typeof newValue !== 'boolean') {
                    parsedValue = attemptedParsedNumber
                    newPropertyType = 'number'
                }

                const lowercaseValue = typeof parsedValue === 'string' && parsedValue.toLowerCase()
                if (lowercaseValue === 'true' || lowercaseValue === 'false' || lowercaseValue === 'null') {
                    parsedValue = lowercaseValue === 'true' ? true : lowercaseValue === 'null' ? null : false
                    newPropertyType = parsedValue !== null ? 'boolean' : 'null'
                }

                let updatedProperties = { ...group.group_properties }
                if (!Object.keys(updatedProperties).includes(key)) {
                    updatedProperties = { [key]: parsedValue, ...updatedProperties } // To add property at the top (if new)
                    action = 'added'
                } else {
                    updatedProperties[key] = parsedValue
                    action = 'updated'
                }

                actions.setGroupData({ ...group, group_properties: updatedProperties }) // To update the UI immediately while the request is being processed
                await api.groups.updateProperty(group.group_type_index, group.group_key, key, parsedValue)
                lemonToast.success(`Group property ${action}`)

                reportGroupPropertyUpdated(
                    action,
                    Object.keys(group.group_properties).length,
                    oldPropertyType,
                    newPropertyType
                )
            }
        },
        deleteProperty: async ({ key }) => {
            const group = values.groupData

            if (group) {
                const updatedProperties = { ...group.group_properties }
                delete updatedProperties[key]

                actions.setGroupData({ ...group, group_properties: updatedProperties }) // To update the UI immediately
                await api.groups.deleteProperty(group.group_type_index, group.group_key, key)
                lemonToast.success(`Group property deleted`)

                reportGroupPropertyUpdated('removed', 1, undefined, undefined)
            }
        },
    })),
    reducers({
        groupTab: [
            null as string | null,
            {
                setGroupTab: (_, { groupTab }) => groupTab,
            },
        ],
        groupEventsQuery: [
            null as DataTableNode | null,
            {
                setGroupEventsQuery: (_, { query }) => (isDataTableNode(query) ? query : null),
            },
        ],
        groupData: [
            null as Group | null,
            {
                setGroupData: (_, { group }) => group,
            },
        ],
    }),
    selectors({
        logicProps: [() => [(_, props) => props], (props): GroupLogicProps => props],

        groupEventsQueryIsDirty: [
            (s, p) => [s.groupEventsQuery, p.groupTypeIndex, p.groupKey],
            (groupEventsQuery: DataTableNode | null, groupTypeIndex: number, groupKey: string): boolean => {
                if (!groupEventsQuery) {
                    return false
                }
                return !objectsEqual(groupEventsQuery, getGroupEventsQuery(groupTypeIndex, groupKey))
            },
        ],

        groupTypeName: [
            (s, p) => [s.aggregationLabel, p.groupTypeIndex],
            (
                aggregationLabel: (
                    groupTypeIndex: number | null | undefined,
                    deferToUserWording?: boolean
                ) => import('~/models/groupsModel').Noun,
                index: number
            ): string => aggregationLabel(index).singular,
        ],
        groupTypeNamePlural: [
            (s, p) => [s.aggregationLabel, p.groupTypeIndex],
            (
                aggregationLabel: (
                    groupTypeIndex: number | null | undefined,
                    deferToUserWording?: boolean
                ) => import('~/models/groupsModel').Noun,
                index: number
            ): string => aggregationLabel(index).plural,
        ],
        groupType: [
            (s, p) => [s.groupTypes, p.groupTypeIndex],
            (groupTypes: Map<GroupTypeIndex, import('~/types').GroupType>, index: number): string | null =>
                groupTypes.get(index as GroupTypeIndex)?.group_type ?? null,
        ],
        groupTypeDetailDashboard: [
            (s, p) => [s.groupTypes, p.groupTypeIndex],
            (groupTypes: Map<GroupTypeIndex, import('~/types').GroupType>, index: number): number | null =>
                groupTypes.get(index as GroupTypeIndex)?.detail_dashboard ?? null,
        ],
        // Combine revenue analytics with group properties, prioritizing analytics
        effectiveMRR: [
            (s) => [s.groupRevenueAnalyticsData, s.groupData],
            (
                revenueData: {
                    lifetimeValue: number | null
                    mrr: number | null
                } | null,
                groupData: Group | null
            ): { value: number | null; source: 'revenue-analytics' | 'properties' | null } => {
                // Use pre-calculated data if available
                if (revenueData?.mrr !== null && revenueData?.mrr !== undefined) {
                    return { value: revenueData.mrr, source: 'revenue-analytics' }
                }
                // Fallback to group properties
                const mrrValue = groupData?.group_properties?.mrr
                if (typeof mrrValue === 'number' && !isNaN(mrrValue)) {
                    return { value: mrrValue, source: 'properties' }
                }
                return { value: null, source: null }
            },
        ],
        effectiveLifetimeValue: [
            (s) => [s.groupRevenueAnalyticsData, s.groupData],
            (
                revenueData: {
                    lifetimeValue: number | null
                    mrr: number | null
                } | null,
                groupData: Group | null
            ): { value: number | null; source: 'revenue-analytics' | 'properties' | null } => {
                // Use pre-calculated data if available
                if (revenueData?.lifetimeValue !== null && revenueData?.lifetimeValue !== undefined) {
                    return { value: revenueData.lifetimeValue, source: 'revenue-analytics' }
                }
                // Fallback to group properties
                const ltv = groupData?.group_properties?.customer_lifetime_value
                if (typeof ltv === 'number' && !isNaN(ltv)) {
                    return { value: ltv, source: 'properties' }
                }
                return { value: null, source: null }
            },
        ],
        hasRevenueData: [
            (s) => [s.effectiveMRR, s.effectiveLifetimeValue],
            (
                mrr: {
                    source: 'properties' | 'revenue-analytics' | null
                    value: number | null
                },
                ltv: {
                    source: 'properties' | 'revenue-analytics' | null
                    value: number | null
                }
            ): boolean => mrr.value !== null || ltv.value !== null,
        ],
        backNavigation: [
            () => [router.selectors.searchParams],
            (searchParams: Record<string, any>): GroupBackNavigation | null => resolveBackNavigation(searchParams),
        ],
        backTo: [
            (s, p) => [s.aggregationLabel, p.groupTypeIndex, s.backNavigation],
            (
                aggregationLabel: (
                    groupTypeIndex: number | null | undefined,
                    deferToUserWording?: boolean
                ) => import('~/models/groupsModel').Noun,
                groupTypeIndex: number,
                backNavigation: GroupBackNavigation | null
            ): Breadcrumb => {
                if (backNavigation) {
                    return { key: 'group-back', name: backNavigation.name, path: backNavigation.url }
                }
                return {
                    key: 'groups',
                    name: capitalizeFirstLetter(aggregationLabel(groupTypeIndex).plural),
                    path: urls.groups(groupTypeIndex),
                }
            },
        ],
        [TODAY_PEOPLE_RECENT_KEY]: [
            (s, p) => [p.groupTypeIndex, p.groupKey, s.groupData],
            (groupTypeIndex: number, groupKey: string, groupData: Group | null): TodayPeopleRecent | null =>
                groupData
                    ? {
                          type: 'group',
                          name: groupDisplayId(groupKey, groupData.group_properties || {}),
                          href: urls.group(String(groupTypeIndex), groupKey),
                      }
                    : null,
        ],
        breadcrumbs: [
            (s, p) => [s.groupTypeName, p.groupTypeIndex, p.groupKey, s.groupData],
            (
                groupTypeName: string,
                groupTypeIndex: number,
                groupKey: string,
                groupData: Group | null
            ): Breadcrumb[] => {
                const breadcrumbs: Breadcrumb[] = []
                breadcrumbs.push({
                    key: Scene.DataManagement,
                    name: 'People',
                    path: urls.persons(),
                    iconType: 'persons',
                })
                breadcrumbs.push({
                    key: groupTypeIndex,
                    name: capitalizeFirstLetter(groupTypeName),
                    path: urls.groups(String(groupTypeIndex)),
                    iconType: 'group',
                })
                breadcrumbs.push({
                    key: [Scene.Group, `${groupTypeIndex}-${groupKey}`],
                    name: groupDisplayId(groupKey, groupData?.group_properties || {}),
                    path: urls.group(String(groupTypeIndex), groupKey),
                    iconType: 'group',
                })

                return breadcrumbs
            },
        ],
        [SIDE_PANEL_CONTEXT_KEY]: [
            (s, p) => [p.groupTypeIndex, p.groupKey, s.featureFlags],
            (
                groupTypeIndex: number,
                groupKey: string,
                featureFlags: import('lib/logic/featureFlagLogic').FeatureFlagsSet
            ): SidePanelSceneContext | null => {
                if (!featureFlags[FEATURE_FLAGS.CUSTOMER_ANALYTICS]) {
                    return null
                }
                return {
                    activity_scope: ActivityScope.GROUP,
                    activity_item_id: `${groupTypeIndex}-${groupKey}`,
                }
            },
        ],
    }),
    urlToAction(({ actions }) => ({
        '/groups/:groupTypeIndex/:groupKey(/:groupTab)': ({ groupTab }) => {
            actions.setGroupTab(groupTab || null)
        },
    })),

    afterMount(({ actions, props }) => {
        actions.loadGroup()
        actions.setGroupEventsQuery(getGroupEventsQuery(props.groupTypeIndex, props.groupKey))
        actions.loadGroupRevenueAnalyticsData()
    }),
])