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.

13.5 KB
Raw Blame
import { MakeLogicType, afterMount, connect, kea, listeners, path, selectors } from 'kea'
import { loaders } from 'kea-loaders'

import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
import { GroupsAccessStatus, groupsAccessLogic } from 'lib/introductions/groupsAccessLogic'
import { wordPluralize } from 'lib/utils/strings'
import { projectLogic } from 'scenes/projectLogic'
import { userLogic } from 'scenes/userLogic'

import { GroupType, GroupTypeIndex, UserType } from '~/types'

import {
    groupsTypesCreateDetailDashboardUpdate,
    groupsTypesDestroy,
    groupsTypesList,
    groupsTypesSetDefaultColumnsUpdate,
    groupsTypesUpdateMetadataPartialUpdate,
} from 'products/groups/frontend/generated/api'
import type { GroupTypeApi } from 'products/groups/frontend/generated/api.schemas'

export interface Noun {
    singular: string
    plural: string
}

const toGroupType = ({ group_type_index, default_columns, ...groupType }: GroupTypeApi): GroupType => ({
    ...groupType,
    // Ingestion creates at most five group types per project, so every index fits GroupTypeIndex.
    group_type_index: group_type_index as GroupTypeIndex,
    default_columns: default_columns ?? undefined,
})

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface groupsModelValues {
    groupsAccessStatus: GroupsAccessStatus // groupsAccessLogic
    groupsEnabled: boolean // groupsAccessLogic
    currentProjectId: number | null // projectLogic
    aggregationLabel: (groupTypeIndex: number | null | undefined, deferToUserWording?: boolean) => Noun
    groupNamesTaxonomicTypes: TaxonomicFilterGroupType[]
    groupTypes: Map<GroupTypeIndex, GroupType>
    groupTypesLoading: boolean
    groupTypesRaw: Array<GroupType>
    groupTypesRawLoading: boolean
    groupsTaxonomicTypes: TaxonomicFilterGroupType[]
    showGroupsOptions: boolean
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface groupsModelActions {
    loadUserSuccess: (
        user: UserType | null,
        payload?:
            | {
                  resetOnFailure: boolean | undefined
              }
            | undefined
    ) => {
        payload?: {
            resetOnFailure: boolean | undefined
        }
        user: UserType | null
    } // userLogic
    updateUserSuccess: (
        user: UserType,
        payload?:
            | {
                  failureCallback: (() => void) | undefined
                  successCallback: (() => void) | undefined
                  user: Partial<UserType>
              }
            | undefined
    ) => {
        payload?: {
            failureCallback: (() => void) | undefined
            successCallback: (() => void) | undefined
            user: Partial<UserType>
        }
        user: UserType
    } // userLogic
    createDetailDashboard: (groupTypeIndex: number) => number
    createDetailDashboardFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    createDetailDashboardSuccess: (
        groupTypesRaw: GroupType[],
        payload?: number
    ) => {
        groupTypesRaw: GroupType[]
        payload?: number
    }
    deleteGroupType: (groupTypeIndex: number) => number
    deleteGroupTypeFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    deleteGroupTypeSuccess: (
        groupTypesRaw: never[],
        payload?: number
    ) => {
        groupTypesRaw: never[]
        payload?: number
    }
    loadAllGroupTypes: () => any
    loadAllGroupTypesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadAllGroupTypesSuccess: (
        groupTypesRaw: GroupType[],
        payload?: any
    ) => {
        groupTypesRaw: GroupType[]
        payload?: any
    }
    removeDetailDashboard: (dashboardId: number) => number
    removeDetailDashboardFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    removeDetailDashboardSuccess: (
        groupTypesRaw: GroupType[],
        payload?: number
    ) => {
        groupTypesRaw: GroupType[]
        payload?: number
    }
    setDefaultColumns: ({ groupTypeIndex, defaultColumns }: { defaultColumns: string[]; groupTypeIndex: number }) => {
        groupTypeIndex: number
        defaultColumns: string[]
    }
    setDefaultColumnsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    setDefaultColumnsSuccess: (
        groupTypesRaw: GroupType[],
        payload?: {
            groupTypeIndex: number
            defaultColumns: string[]
        }
    ) => {
        groupTypesRaw: GroupType[]
        payload?: {
            groupTypeIndex: number
            defaultColumns: string[]
        }
    }
    updateGroupTypesMetadata: (payload: Array<GroupType>) => Array<GroupType>
    updateGroupTypesMetadataFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    updateGroupTypesMetadataSuccess: (
        groupTypesRaw: GroupType[],
        payload?: Array<GroupType>
    ) => {
        groupTypesRaw: GroupType[]
        payload?: Array<GroupType>
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface groupsModelMeta {
    __keaTypeGenInternalSelectorTypes: {
        groupTypes: (groupTypesRaw: GroupType[]) => Map<GroupTypeIndex, GroupType>
        groupTypesLoading: (groupTypesRawLoading: boolean) => boolean
        showGroupsOptions: (
            groupsAccessStatus: GroupsAccessStatus,
            groupsEnabled: boolean,
            groupTypes: Map<GroupTypeIndex, GroupType>
        ) => boolean
        groupsTaxonomicTypes: (groupTypes: Map<GroupTypeIndex, GroupType>) => TaxonomicFilterGroupType[]
        groupNamesTaxonomicTypes: (groupTypes: Map<GroupTypeIndex, GroupType>) => TaxonomicFilterGroupType[]
        aggregationLabel: (
            groupTypes: Map<GroupTypeIndex, GroupType>
        ) => (groupTypeIndex: number | null | undefined, deferToUserWording?: boolean) => Noun
    }
}

export type groupsModelType = MakeLogicType<groupsModelValues, groupsModelActions, Record<string, any>, groupsModelMeta>

export const groupsModel = kea<groupsModelType>([
    path(['models', 'groupsModel']),
    connect(() => ({
        values: [projectLogic, ['currentProjectId'], groupsAccessLogic, ['groupsEnabled', 'groupsAccessStatus']],
        actions: [userLogic, ['loadUserSuccess', 'updateUserSuccess']],
    })),
    loaders(({ values }) => ({
        groupTypesRaw: [
            [] as Array<GroupType>,
            {
                loadAllGroupTypes: async () => {
                    if (!values.currentProjectId) {
                        return []
                    }
                    const groupTypes = await groupsTypesList(String(values.currentProjectId))
                    return groupTypes.map(toGroupType)
                },
                updateGroupTypesMetadata: async (payload: Array<GroupType>) => {
                    if (values.groupsEnabled) {
                        const groupTypes = await groupsTypesUpdateMetadataPartialUpdate(
                            String(values.currentProjectId),
                            payload.map(({ group_type_index, name_singular, name_plural }) => ({
                                group_type_index,
                                name_singular,
                                name_plural,
                            }))
                        )
                        return groupTypes.map(toGroupType)
                    }
                    return []
                },
                deleteGroupType: async (groupTypeIndex: number) => {
                    if (values.groupsEnabled) {
                        await groupsTypesDestroy(String(values.currentProjectId), groupTypeIndex)
                    }
                    return []
                },
                createDetailDashboard: async (groupTypeIndex: number) => {
                    const groupType = toGroupType(
                        await groupsTypesCreateDetailDashboardUpdate(String(values.currentProjectId), {
                            group_type_index: groupTypeIndex,
                        })
                    )
                    return values.groupTypesRaw.map((gt) => (gt.group_type_index === groupTypeIndex ? groupType : gt))
                },
                removeDetailDashboard: async (dashboardId: number) => {
                    return values.groupTypesRaw.map((gt) => {
                        if (gt.detail_dashboard === dashboardId) {
                            return {
                                ...gt,
                                detail_dashboard: null,
                            }
                        }
                        return gt
                    })
                },
                setDefaultColumns: async ({
                    groupTypeIndex,
                    defaultColumns,
                }: {
                    groupTypeIndex: number
                    defaultColumns: string[]
                }) => {
                    const groupType = toGroupType(
                        await groupsTypesSetDefaultColumnsUpdate(String(values.currentProjectId), {
                            group_type_index: groupTypeIndex,
                            default_columns: defaultColumns,
                        })
                    )
                    return values.groupTypesRaw.map((gt) => (gt.group_type_index === groupTypeIndex ? groupType : gt))
                },
            },
        ],
    })),
    selectors({
        groupTypes: [
            (s) => [s.groupTypesRaw],
            (groupTypesRaw: Array<GroupType>) =>
                new Map<GroupTypeIndex, GroupType>(
                    (groupTypesRaw ?? []).map((groupType) => [groupType.group_type_index, groupType])
                ),
        ],
        groupTypesLoading: [(s) => [s.groupTypesRawLoading], (groupTypesRawLoading: boolean) => groupTypesRawLoading],

        showGroupsOptions: [
            (s) => [s.groupsAccessStatus, s.groupsEnabled, s.groupTypes],
            (status: GroupsAccessStatus, enabled: boolean, groupTypes: Map<GroupTypeIndex, GroupType>) =>
                status !== GroupsAccessStatus.Hidden || (enabled && Array.from(groupTypes.values()).length > 0),
        ],
        groupsTaxonomicTypes: [
            (s) => [s.groupTypes],
            (groupTypes: Map<GroupTypeIndex, GroupType>): TaxonomicFilterGroupType[] => {
                return Array.from(groupTypes.values()).map(
                    (groupType: GroupType) =>
                        `${TaxonomicFilterGroupType.GroupsPrefix}_${groupType.group_type_index}` as TaxonomicFilterGroupType
                )
            },
        ],
        groupNamesTaxonomicTypes: [
            (s) => [s.groupTypes],
            (groupTypes: Map<GroupTypeIndex, GroupType>): TaxonomicFilterGroupType[] => {
                return Array.from(groupTypes.values()).map(
                    (groupType: GroupType) =>
                        `${TaxonomicFilterGroupType.GroupNamesPrefix}_${groupType.group_type_index}` as TaxonomicFilterGroupType
                )
            },
        ],
        aggregationLabel: [
            (s) => [s.groupTypes],
            (groupTypes: Map<GroupTypeIndex, GroupType>) =>
                (groupTypeIndex: number | null | undefined, deferToUserWording: boolean = false): Noun => {
                    if (groupTypeIndex != undefined) {
                        const groupType = groupTypes.get(groupTypeIndex as GroupTypeIndex)
                        if (groupType) {
                            return {
                                singular: groupType.name_singular || groupType.group_type || 'group',
                                plural: groupType.name_plural || wordPluralize(groupType.group_type) || 'groups',
                            }
                        }
                        return {
                            singular: 'unknown group',
                            plural: 'unknown groups',
                        }
                    }
                    return deferToUserWording
                        ? {
                              singular: 'user',
                              plural: 'users',
                          }
                        : { singular: 'person', plural: 'persons' }
                },
        ],
    }),
    listeners(({ actions, values, cache }) => {
        // groupsEnabled comes from the organization's available features on the user, so it can only
        // turn on when the user reloads, for example after an upgrade.
        const loadGroupTypesIfGroupsTurnedOn = (): void => {
            if (values.groupsEnabled && !cache.groupsWereEnabled && !values.groupTypesLoading) {
                actions.loadAllGroupTypes()
            }
            cache.groupsWereEnabled = values.groupsEnabled
        }
        return {
            loadUserSuccess: loadGroupTypesIfGroupsTurnedOn,
            updateUserSuccess: loadGroupTypesIfGroupsTurnedOn,
            deleteGroupTypeSuccess: () => {
                actions.loadAllGroupTypes()
            },
        }
    }),
    afterMount(({ actions, values, cache }) => {
        cache.groupsWereEnabled = values.groupsEnabled
        if (window.POSTHOG_APP_CONTEXT?.current_team?.group_types) {
            actions.loadAllGroupTypesSuccess(window.POSTHOG_APP_CONTEXT.current_team.group_types)
        } else {
            actions.loadAllGroupTypes()
        }
    }),
])