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.

19.8 KB
Raw Blame
import {
    MakeLogicType,
    actions,
    connect,
    kea,
    key,
    listeners,
    path,
    props,
    propsChanged,
    reducers,
    selectors,
} from 'kea'

import { FEATURE_FLAGS } from 'lib/constants'
import { dayjs } from 'lib/dayjs'
import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { tabUiStateLogic } from 'lib/logic/tabUiStateLogic'
import { objectsEqual, sortedKeys } from 'lib/utils/objects'
import { RequiredExcept } from 'lib/utils/types'
import { teamLogic } from 'scenes/teamLogic'

import { dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
import { QueryFeature, getQueryFeatures } from '~/queries/nodes/DataTable/queryFeatures'
import { insightVizDataCollectionId } from '~/queries/nodes/InsightViz/insightVizKeys'
import { isDataTableNode } from '~/queries/schema/node-guards'
import {
    AnyDataNode,
    AnyResponseType,
    DataTableNode,
    EventsQuery,
    HogQLExpression,
    NodeKind,
} from '~/queries/schema/schema-general'
import { QueryContext } from '~/queries/types'
import { isEventsQuery } from '~/queries/utils'

import type { FeatureFlagsSet } from '../../../lib/logic/featureFlagLogic'
import type { TeamPublicType, TeamType } from '../../../types'
import type {
    ErrorTrackingQueryResponse,
    HogQLAutocompleteResponse,
    HogQLMetadataResponse,
    HogQLQueryResponse,
    HogQueryResponse,
    LogAttributesQueryResponse,
    LogValuesQueryResponse,
    MetricsQueryResponse,
    SessionsQueryResponse,
    TraceSpansAggregationQueryResponse,
    TraceSpansAttributeBreakdownQueryResponse,
    TraceSpansQueryResponse,
} from '../../schema/schema-general'
import type { TraceSpansTreeQueryResponse } from '../../schema/schema-general'
import { getColumnsForQuery, removeExpressionComment } from './utils'

export interface DataTableLogicProps {
    vizKey: string
    dataKey: string
    query: DataTableNode
    context?: QueryContext<DataTableNode>
    // Override the data logic node key if needed
    dataNodeLogicKey?: string
}

export interface DataTableRow {
    /** Display a row with a label. */
    label?: JSX.Element | string | null
    /** Display a row with results */
    result?: Record<string, any> | any[]
}

export const loadingColumn = Symbol('...')
export const errorColumn = Symbol('Error!')

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataTableLogicValues {
    response:
        | ErrorTrackingQueryResponse
        | HogQLAutocompleteResponse
        | HogQLMetadataResponse
        | HogQLQueryResponse<any[]>
        | HogQueryResponse
        | LogAttributesQueryResponse
        | LogValuesQueryResponse
        | MetricsQueryResponse
        | Record<string, any>
        | SessionsQueryResponse
        | TraceSpansAggregationQueryResponse
        | TraceSpansAttributeBreakdownQueryResponse
        | TraceSpansQueryResponse
        | TraceSpansTreeQueryResponse
        | null // dataNodeLogic
    responseError: string | null // dataNodeLogic
    responseLoading: boolean // dataNodeLogic
    featureFlags: FeatureFlagsSet // featureFlagLogic
    expandedRowsFor: (tabId: string | undefined, vizKey: string) => number[] // tabUiStateLogic
    currentTeam: TeamPublicType | TeamType | null // teamLogic
    canSort: boolean
    columnsInQuery: string[]
    columnsInResponse: string[] | null
    context: any
    dataTableRows: DataTableRow[] | null
    expandedRows: number[]
    orderBy: string[] | null
    queryWithDefaults: RequiredExcept<
        Omit<DataTableNode, 'response'>,
        'contextKey' | 'defaultColumns' | 'tags' | 'version'
    >
    rowsTransformer: ((rows: DataTableRow[]) => DataTableRow[]) | null
    sourceFeatures: Set<QueryFeature>
    sourceKind: NodeKind | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataTableLogicActions {
    toggleExpandedRow: (
        tabId: string | undefined,
        vizKey: string,
        rowIndex: number
    ) => {
        rowIndex: number
        tabId: string
        vizKey: string
    } // tabUiStateLogic
    setColumnsInQuery: (columns: HogQLExpression[]) => {
        columns: string[]
    }
    setRowsTransformer: (rowsTransformer: ((rows: DataTableRow[]) => DataTableRow[]) | null) => {
        rowsTransformer: ((rows: DataTableRow[]) => DataTableRow[]) | null
    }
    toggleRowExpanded: (rowIndex: number) => {
        rowIndex: number
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataTableLogicMeta {
    key: string
    __keaTypeGenInternalSelectorTypes: {
        context: (arg: any) => any
        expandedRows: (expandedRowsFor: (tabId: string | undefined, vizKey: string) => number[], arg: any) => number[]
        sourceKind: (query: DataTableNode) => NodeKind | null
        sourceFeatures: (query: DataTableNode, arg: any) => Set<QueryFeature>
        orderBy: (query: DataTableNode, sourceFeatures: Set<QueryFeature>) => string[] | null
        columnsInResponse: (
            response:
                | ErrorTrackingQueryResponse
                | HogQLAutocompleteResponse
                | HogQLMetadataResponse
                | HogQLQueryResponse<any[]>
                | HogQueryResponse
                | LogAttributesQueryResponse
                | LogValuesQueryResponse
                | MetricsQueryResponse
                | Record<string, any>
                | SessionsQueryResponse
                | TraceSpansAggregationQueryResponse
                | TraceSpansAttributeBreakdownQueryResponse
                | TraceSpansQueryResponse
                | TraceSpansTreeQueryResponse
                | null
        ) => string[] | null
        dataTableRows: (
            sourceKind: NodeKind | null,
            orderBy: string[] | null,
            response:
                | ErrorTrackingQueryResponse
                | HogQLAutocompleteResponse
                | HogQLMetadataResponse
                | HogQLQueryResponse<any[]>
                | HogQueryResponse
                | LogAttributesQueryResponse
                | LogValuesQueryResponse
                | MetricsQueryResponse
                | Record<string, any>
                | SessionsQueryResponse
                | TraceSpansAggregationQueryResponse
                | TraceSpansAttributeBreakdownQueryResponse
                | TraceSpansQueryResponse
                | TraceSpansTreeQueryResponse
                | null,
            columnsInResponse: string[] | null,
            rowsTransformer: ((rows: DataTableRow[]) => DataTableRow[]) | null,
            currentTeam: TeamPublicType | TeamType | null
        ) => DataTableRow[] | null
        queryWithDefaults: (
            query: DataTableNode,
            columnsInQuery: string[],
            featureFlags: FeatureFlagsSet,
            arg: any
        ) => RequiredExcept<Omit<DataTableNode, 'response'>, 'contextKey' | 'defaultColumns' | 'tags' | 'version'>
        canSort: (
            queryWithDefaults: RequiredExcept<
                Omit<DataTableNode, 'response'>,
                'contextKey' | 'defaultColumns' | 'tags' | 'version'
            >,
            sourceFeatures: Set<QueryFeature>
        ) => boolean
    }
}

export type dataTableLogicType = MakeLogicType<
    dataTableLogicValues,
    dataTableLogicActions,
    DataTableLogicProps,
    dataTableLogicMeta
>

export const dataTableLogic = kea<dataTableLogicType>([
    props({} as DataTableLogicProps),
    key((props) => {
        if (!props.vizKey) {
            throw new Error('dataTableLogic must contain a vizKey in props')
        }
        if (!isDataTableNode(props.query)) {
            throw new Error('dataTableLogic only accepts queries of type DataTableNode')
        }
        return props.vizKey
    }),
    path(['queries', 'nodes', 'DataTable', 'dataTableLogic']),
    actions({
        setColumnsInQuery: (columns: HogQLExpression[]) => ({ columns }),
        setRowsTransformer: (rowsTransformer: ((rows: DataTableRow[]) => DataTableRow[]) | null) => ({
            rowsTransformer,
        }),
        toggleRowExpanded: (rowIndex: number) => ({ rowIndex }),
    }),
    reducers(({ props }) => ({
        columnsInQuery: [getColumnsForQuery(props.query), { setColumnsInQuery: (_, { columns }) => columns }],
        // Kea mutates props in place, so a selector reading the transformer from props keeps a stale result.
        // The default is a selector because kea reads a function default as one.
        rowsTransformer: [
            (_: unknown, props: DataTableLogicProps) => props.context?.dataTableRowsTransformer ?? null,
            { setRowsTransformer: (_, { rowsTransformer }) => rowsTransformer },
        ],
    })),
    connect((props: DataTableLogicProps) => ({
        values: [
            featureFlagLogic,
            ['featureFlags'],
            teamLogic,
            ['currentTeam'],
            tabUiStateLogic,
            ['expandedRowsFor'],
            dataNodeLogic({
                key: props.dataNodeLogicKey ?? props.dataKey,
                query: props.query.source,
                dataNodeCollectionId: insightVizDataCollectionId(
                    props.context?.insightProps,
                    props.dataNodeLogicKey ?? props.dataKey
                ),
                loadPriority: props.context?.insightProps?.loadPriority,
                retainResponseOnUnmount: props.context?.insightProps?.retainResponseOnUnmount,
            }),
            ['response', 'responseLoading', 'responseError'],
        ],
        actions: [tabUiStateLogic, ['toggleExpandedRow']],
    })),
    listeners(({ props, actions }) => ({
        toggleRowExpanded: ({ rowIndex }) => {
            actions.toggleExpandedRow(undefined, props.vizKey, rowIndex)
        },
    })),
    selectors({
        context: [() => [(_, props) => props.context], (context) => context],
        expandedRows: [
            (s) => [s.expandedRowsFor, (_, p) => p.vizKey],
            (expandedRowsFor: (tabId: string | undefined, vizKey: string) => number[], vizKey: string): number[] =>
                expandedRowsFor(undefined, vizKey),
            { resultEqualityCheck: objectsEqual },
        ],
        sourceKind: [(_, p) => [p.query], (query: DataTableNode): NodeKind | null => query.source?.kind],
        sourceFeatures: [
            (_, p) => [p.query, (_, props) => props.context],
            (query: DataTableNode, context): Set<QueryFeature> => {
                const sourceFeatures = getQueryFeatures(query.source)
                if (context?.extraDataTableQueryFeatures) {
                    for (const feature of context.extraDataTableQueryFeatures) {
                        sourceFeatures.add(feature)
                    }
                }
                return sourceFeatures
            },
        ],
        orderBy: [
            (s, p) => [p.query, s.sourceFeatures],
            (query: DataTableNode, sourceFeatures: Set<QueryFeature>): string[] | null =>
                sourceFeatures.has(QueryFeature.selectAndOrderByColumns)
                    ? 'orderBy' in query.source // might not be EventsQuery, but something else with orderBy
                        ? ((query.source as EventsQuery).orderBy ?? null)
                        : isEventsQuery(query.source)
                          ? ['timestamp DESC']
                          : null
                    : null,
            { resultEqualityCheck: objectsEqual },
        ],
        columnsInResponse: [
            (s) => [s.response],
            (response: AnyDataNode['response']): string[] | null =>
                response && 'columns' in response && Array.isArray(response.columns) ? response?.columns : null,
        ],
        dataTableRows: [
            (s) => [s.sourceKind, s.orderBy, s.response, s.columnsInResponse, s.rowsTransformer, s.currentTeam],
            (
                sourceKind: NodeKind | null,
                orderBy: string[] | null,
                response: AnyDataNode['response'],
                columnsInResponse: string[] | null,
                rowsTransformer: ((rows: DataTableRow[]) => DataTableRow[]) | null,
                currentTeam: { timezone?: string } | null
            ): DataTableRow[] | null => {
                if (response && sourceKind === NodeKind.EventsQuery) {
                    const queryResponse = response as AnyResponseType
                    if (queryResponse) {
                        let results: any[] | null = []
                        if ('results' in queryResponse) {
                            results = queryResponse.results
                        } else if ('result' in queryResponse) {
                            results = queryResponse.result
                        }

                        if (!results) {
                            return []
                        }

                        const orderKey = orderBy?.[0]?.endsWith(' DESC')
                            ? orderBy[0].replace(/ DESC$/, '')
                            : orderBy?.[0]
                        const orderKeyIndex =
                            columnsInResponse?.findIndex(
                                (column) =>
                                    removeExpressionComment(column) === orderKey ||
                                    removeExpressionComment(column) === `-${orderKey}`
                            ) ?? -1

                        // Add a label between results if the day changed for events with timestamp.
                        // Use the project timezone so date headers match the date filter.
                        if (orderKey === 'timestamp' && orderKeyIndex !== -1) {
                            const tz = currentTeam?.timezone ?? 'UTC'
                            let lastResult: any = null
                            const newResults: DataTableRow[] = []
                            for (const result of results) {
                                if (
                                    result &&
                                    lastResult &&
                                    !dayjs(result[orderKeyIndex])
                                        .tz(tz)
                                        .isSame(dayjs(lastResult[orderKeyIndex]).tz(tz), 'day')
                                ) {
                                    newResults.push({
                                        label: dayjs(result[orderKeyIndex]).tz(tz).format('LL'),
                                    })
                                }
                                newResults.push({ result })
                                lastResult = result
                            }
                            return newResults
                        }
                        return results.map((result) => ({ result }))
                    }
                }

                const results = !response
                    ? null
                    : 'results' in response && Array.isArray(response.results)
                      ? response.results
                      : 'result' in response && Array.isArray(response.result)
                        ? response.result
                        : null

                const rows = results ? (results.map((result: any) => ({ result })) ?? null) : null
                return rowsTransformer ? rowsTransformer(rows ?? []) : rows
            },
            // A reload or poll reparses JSON, so unchanged results still arrive as new identities;
            // keeping the previous array lets memoized rows skip re-rendering.
            { resultEqualityCheck: objectsEqual },
        ],
        queryWithDefaults: [
            (s, p) => [p.query, s.columnsInQuery, s.featureFlags, (_, props) => props.context],
            (
                query: DataTableNode,
                columnsInQuery: string[],
                featureFlags: import('lib/logic/featureFlagLogic').FeatureFlagsSet,
                context
            ): RequiredExcept<
                Omit<DataTableNode, 'response'>,
                'version' | 'tags' | 'defaultColumns' | 'contextKey'
            > => {
                const { kind, columns: _columns, source, ...rest } = query
                const showIfFull = !!query.full
                const flagQueryRunningTimeEnabled = !!featureFlags[FEATURE_FLAGS.QUERY_RUNNING_TIME]
                const flagQueryTimingsEnabled = !!featureFlags[FEATURE_FLAGS.QUERY_TIMINGS]
                return {
                    kind,
                    columns: columnsInQuery,
                    hiddenColumns: [],
                    pinnedColumns: query.pinnedColumns ?? [],
                    source,
                    context: query.context ?? { type: 'team_columns' },
                    ...sortedKeys({
                        ...rest,
                        full: query.full ?? false,

                        // The settings under features.tsx override some of these
                        expandable: query.expandable ?? true,
                        embedded: query.embedded ?? false,
                        propertiesViaUrl: query.propertiesViaUrl ?? false,
                        showPropertyFilter: query.showPropertyFilter ?? showIfFull,
                        showEventFilter: query.showEventFilter ?? showIfFull,
                        showEventsFilter: query.showEventsFilter ?? false,
                        showSearch: query.showSearch ?? showIfFull,
                        showActions: query.showActions ?? true,
                        showDateRange: query.showDateRange ?? showIfFull,
                        showTestAccountFilters: query.showTestAccountFilters ?? showIfFull,
                        showExport: query.showExport ?? showIfFull,
                        showReload: query.showReload ?? showIfFull,
                        showTimings: query.showTimings ?? flagQueryTimingsEnabled,
                        showElapsedTime:
                            (query.showTimings ?? flagQueryTimingsEnabled) ||
                            (query.showElapsedTime ??
                                ((flagQueryRunningTimeEnabled || source.kind === NodeKind.HogQLQuery) && showIfFull)),
                        showColumnConfigurator: query.showColumnConfigurator ?? showIfFull,
                        showPersistentColumnConfigurator: query.showPersistentColumnConfigurator ?? false,
                        showSavedQueries: query.showSavedQueries ?? false,
                        showSavedFilters: query.showSavedFilters ?? false,
                        showTableViews: query.showTableViews ?? false,
                        showAbsoluteTime: query.showAbsoluteTime ?? false,
                        showHogQLEditor: query.showHogQLEditor ?? showIfFull,
                        allowSorting: query.allowSorting ?? true,
                        showOpenEditorButton:
                            context?.showOpenEditorButton !== undefined
                                ? context.showOpenEditorButton
                                : (query.showOpenEditorButton ?? true),
                        showResultsTable: query.showResultsTable ?? true,
                        showRecordingColumn: query.showRecordingColumn ?? false,
                        showSourceQueryOptions: query.showSourceQueryOptions ?? true,
                        showCount: query.showCount ?? false,
                    }),
                }
            },
        ],
        canSort: [
            (s) => [s.queryWithDefaults, s.sourceFeatures],
            (query: DataTableNode, sourceFeatures: Set<QueryFeature>): boolean =>
                sourceFeatures.has(QueryFeature.selectAndOrderByColumns) && !!query.allowSorting,
        ],
    }),
    propsChanged(({ actions, props }, oldProps) => {
        const newColumns = getColumnsForQuery(props.query)
        const oldColumns = getColumnsForQuery(oldProps.query)
        if (JSON.stringify(newColumns) !== JSON.stringify(oldColumns)) {
            actions.setColumnsInQuery(newColumns)
        }
        const rowsTransformer = props.context?.dataTableRowsTransformer ?? null
        if (rowsTransformer !== (oldProps.context?.dataTableRowsTransformer ?? null)) {
            actions.setRowsTransformer(rowsTransformer)
        }
    }),
])