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.

5.8 KB
Raw Blame
import { deepEqual as equal } from 'fast-equals'
import { MakeLogicType, actions, connect, kea, key, listeners, path, reducers, selectors } from 'kea'
import { urlToAction } from 'kea-router'
import { UrlToActionPayload } from 'kea-router/lib/types'

import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { trackedActionToUrl } from 'lib/logic/scenes/trackedActionToUrl'
import { tabUiStateLogic } from 'lib/logic/tabUiStateLogic'
import { objectsEqual } from 'lib/utils/objects'
import { applyTestAccountFilter, getDefaultSessionsSceneQuery } from 'scenes/activity/explore/defaults'
import { sceneConfigurations } from 'scenes/scenes'
import { Scene } from 'scenes/sceneTypes'
import { filterTestAccountsDefaultsLogic } from 'scenes/settings/environment/filterTestAccountDefaultsLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'

import { DataTableNode, Node } from '~/queries/schema/schema-general'
import { ActivityTab, Breadcrumb } from '~/types'

import type { TeamPublicType, TeamType } from '../../../types'

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface sessionsSceneLogicValues {
    filterTestAccountsDefault: boolean // filterTestAccountsDefaultsLogic
    savedQueryFor: (tabId: string | undefined, sceneKey: string) => Node | null // tabUiStateLogic
    currentTeam: TeamPublicType | TeamType | null // teamLogic
    breadcrumbs: Breadcrumb[]
    defaultQuery: DataTableNode
    query: Node
    savedQuery: Node | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface sessionsSceneLogicActions {
    setSavedQueryForTab: (
        tabId: string | undefined,
        sceneKey: string,
        query: Node<Record<string, any>> | null
    ) => {
        query: Node<Record<string, any>> | null
        sceneKey: string
        tabId: string
    } // tabUiStateLogic
    setQuery: (query: Node) => {
        query: Node<Record<string, any>>
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface sessionsSceneLogicMeta {
    key: string
    __keaTypeGenInternalSelectorTypes: {
        defaultQuery: (
            currentTeam: TeamPublicType | TeamType | null,
            filterTestAccountsDefault: boolean
        ) => DataTableNode
        query: (savedQuery: Node<Record<string, any>> | null, defaultQuery: DataTableNode) => Node
    }
}

export type sessionsSceneLogicType = MakeLogicType<
    sessionsSceneLogicValues,
    sessionsSceneLogicActions,
    Record<string, any>,
    sessionsSceneLogicMeta
>

export const sessionsSceneLogic = kea<sessionsSceneLogicType>([
    key(() => 'scene'),
    path((key) => ['scenes', 'sessions', 'sessionsSceneLogic', key]),
    connect(() => ({
        values: [
            teamLogic,
            ['currentTeam'],
            filterTestAccountsDefaultsLogic,
            ['filterTestAccountsDefault'],
            tabUiStateLogic,
            ['savedQueryFor'],
        ],
        actions: [tabUiStateLogic, ['setSavedQueryForTab']],
    })),

    actions({ setQuery: (query: Node) => ({ query }) }),
    reducers({ savedQuery: [null as Node | null, { setQuery: (_, { query }) => query }] }),
    listeners(({ actions, values }) => ({
        setQuery: ({ query }) => {
            const isDefault = objectsEqual(query, values.defaultQuery)
            actions.setSavedQueryForTab(undefined, 'sessions', isDefault ? null : query)
        },
    })),
    selectors({
        defaultQuery: [
            (s) => [s.currentTeam, s.filterTestAccountsDefault],
            (
                currentTeam: null | import('~/types').TeamPublicType | import('~/types').TeamType,
                filterTestAccountsDefault: boolean
            ): DataTableNode =>
                applyTestAccountFilter(getDefaultSessionsSceneQuery(), currentTeam, filterTestAccountsDefault),
        ],
        query: [
            (s) => [s.savedQuery, s.defaultQuery],
            (savedQuery: Node | null, defaultQuery: DataTableNode): Node => savedQuery || defaultQuery,
        ],
        breadcrumbs: [
            () => [],
            (): Breadcrumb[] => [
                {
                    key: Scene.ExploreSessions,
                    name: sceneConfigurations[Scene.ExploreSessions].name,
                    iconType: sceneConfigurations[Scene.ExploreSessions].iconType || 'default_icon_type',
                },
            ],
        ],
    }),
    trackedActionToUrl(({ values }) => ({
        setQuery: () => [
            urls.activity(ActivityTab.ExploreSessions),
            {},
            objectsEqual(values.query, values.defaultQuery) ? {} : { q: values.query },
            { replace: true },
        ],
    })),

    urlToAction(({ actions, values }) => {
        const sessionsQueryHandler: UrlToActionPayload[keyof UrlToActionPayload] = (_, __, { q: queryParam }): void => {
            // If query hasn't changed, do nothing
            if (equal(queryParam, values.query)) {
                return
            }

            // Handle missing query param - restore from the persisted query, else fall back to default
            if (!queryParam) {
                const persisted = values.savedQueryFor(undefined, 'sessions')
                const target = persisted ?? values.defaultQuery
                if (!objectsEqual(values.query, target)) {
                    actions.setQuery(target)
                }
                return
            }

            // Handle invalid query param type
            if (typeof queryParam !== 'object') {
                lemonToast.error('Invalid query in URL')
                console.error({ queryParam })
                return
            }

            // Valid query object - update state
            actions.setQuery(queryParam)
        }

        return {
            [urls.activity(ActivityTab.ExploreSessions)]: sessionsQueryHandler,
        }
    }),
])